private boolean isSameFile(VFSLeaf currentFile, VersionsFileImpl versions) { boolean same = false; if (versions.getRevisions() != null && !versions.getRevisions().isEmpty()) { VFSRevision lastRevision = versions.getRevisions().get(versions.getRevisions().size() - 1); long lastSize = lastRevision.getSize(); long currentSize = currentFile.getSize(); if (currentSize == lastSize && currentSize > 0 && lastRevision instanceof RevisionFileImpl && currentFile instanceof LocalFileImpl) { RevisionFileImpl lastRev = ((RevisionFileImpl) lastRevision); LocalFileImpl current = (LocalFileImpl) currentFile; // can be the same file try { Checksum cm1 = FileUtils.checksum(((LocalFileImpl) lastRev.getFile()).getBasefile(), new Adler32()); Checksum cm2 = FileUtils.checksum(current.getBasefile(), new Adler32()); same = cm1.getValue() == cm2.getValue(); } catch (IOException e) { log.debug("Error calculating the checksum of files"); } } } return same; }
private Versions readVersions(VFSLeaf leaf, VFSLeaf fVersions) { if (fVersions == null) { return new NotVersioned(); } try { VFSContainer fVersionContainer = fVersions.getParentContainer(); VersionsFileImpl versions = (VersionsFileImpl) XStreamHelper.readObject(mystream, fVersions); versions.setVersionFile(fVersions); versions.setCurrentVersion((Versionable) leaf); if (versions.getRevisionNr() == null || versions.getRevisionNr().length() == 0) { versions.setRevisionNr(getNextRevisionNr(versions)); } for (VFSRevision revision : versions.getRevisions()) { RevisionFileImpl revisionImpl = (RevisionFileImpl) revision; revisionImpl.setContainer(fVersionContainer); } return versions; } catch (Exception e) { log.warn("This file is not a versions XML file: " + fVersions, e); fVersions.delete(); VersionsFileImpl versions = new VersionsFileImpl(); versions.setCurrentVersion((Versionable) leaf); versions.setVersioned(isVersioned(leaf)); versions.setRevisionNr(getNextRevisionNr(versions)); log.warn("Deleted corrupt version XML file and created new version XML file: " + versions); // the old revisions can not be restored automatically. They are still on disk, you could // recover them // manually. This is not a perfect solution, but at least the user does not get an RS return versions; } }
private boolean copyRevision( VFSRevision revision, VFSLeaf fNewVersions, VersionsFileImpl targetVersions) { if (!(revision instanceof RevisionFileImpl)) { logWarn("Copy only copy persisted revisions", null); } RevisionFileImpl revisionImpl = (RevisionFileImpl) revision; String revUuid = revisionImpl.getUuid(); for (VFSRevision rev : targetVersions.getRevisions()) { if (rev instanceof RevisionFileImpl) { RevisionFileImpl fRev = (RevisionFileImpl) rev; if (StringHelper.containsNonWhitespace(fRev.getUuid()) && fRev.getUuid().equals(revUuid)) { return true; } } } String uuid = UUID.randomUUID().toString().replace("-", "") + "_" + revision.getName(); RevisionFileImpl newRevision = new RevisionFileImpl(); newRevision.setName(revision.getName()); newRevision.setFilename(uuid); newRevision.setRevisionNr(getNextRevisionNr(targetVersions)); newRevision.setComment(revision.getComment()); newRevision.setAuthor(revision.getAuthor()); newRevision.setLastModified(revision.getLastModified()); newRevision.setUuid(revUuid); // copy -> the files revision InputStream revisionIn = revision.getInputStream(); VFSLeaf target = fNewVersions.getParentContainer().createChildLeaf(uuid); if (VFSManager.copyContent(revisionIn, target)) { targetVersions.setComment(revision.getComment()); targetVersions.getRevisions().add(newRevision); targetVersions.setRevisionNr(getNextRevisionNr(targetVersions)); targetVersions.setAuthor(revision.getAuthor()); return true; } return false; }
@Override public boolean deleteVersions(List<Versions> versions) { for (Versions versionToDelete : versions) { if (versionToDelete instanceof VersionsFileImpl) { VersionsFileImpl versionsImpl = (VersionsFileImpl) versionToDelete; VFSLeaf versionFile = versionsImpl.getVersionFile(); if (versionFile != null) { // robust against manual file system manipulation versionFile.deleteSilently(); } for (VFSRevision revisionToDelete : versionsImpl.getRevisions()) { RevisionFileImpl versionImpl = (RevisionFileImpl) revisionToDelete; VFSLeaf fileToDelete = versionImpl.getFile(); if (fileToDelete != null) { fileToDelete.deleteSilently(); } } } } return true; }
/** * @see * org.olat.core.util.vfs.version.VersionsManager#addToRevisions(org.olat.core.util.vfs.version.Versionable, * org.olat.core.id.Identity, java.lang.String) */ @Override public boolean addToRevisions(Versionable currentVersion, Identity identity, String comment) { int maxNumOfVersions = versioningConfigurator.getMaxNumOfVersionsAllowed(); if (maxNumOfVersions == 0) { return true; // deactivated, return all ok } VFSLeaf currentFile = (VFSLeaf) currentVersion; VFSLeaf versionFile = getCanonicalVersionXmlFile(currentFile, true); if (versionFile == null) { return false; // cannot do something with the current file } VFSContainer versionContainer = versionFile.getParentContainer(); String name = currentFile.getName(); // read from the Versions v = readVersions(currentFile, versionFile); if (!(v instanceof VersionsFileImpl)) { log.error("Wrong implementation of Versions: " + v); return false; } VersionsFileImpl versions = (VersionsFileImpl) v; boolean sameFile = isSameFile(currentFile, versions); String uuid = sameFile ? getLastRevisionFilename(versions) : UUID.randomUUID().toString() + "_" + name; String versionNr = getNextRevisionNr(versions); String currentAuthor = versions.getAuthor(); long lastModifiedDate = 0; if (currentFile instanceof MetaTagged) { MetaInfo metaInfo = ((MetaTagged) currentFile).getMetaInfo(); if (metaInfo != null) { metaInfo.clearThumbnails(); if (currentAuthor == null) { currentAuthor = metaInfo.getAuthor(); } lastModifiedDate = metaInfo.getLastModified(); } } if (lastModifiedDate <= 0) { Calendar cal = Calendar.getInstance(); cal.setTime(new Date()); lastModifiedDate = cal.getTimeInMillis(); } RevisionFileImpl newRevision = new RevisionFileImpl(); newRevision.setUuid(UUID.randomUUID().toString()); newRevision.setName(name); newRevision.setFilename(uuid); newRevision.setRevisionNr(versionNr); newRevision.setComment(versions.getComment()); newRevision.setAuthor(currentAuthor); newRevision.setLastModified(lastModifiedDate); if (versions.getRevisions().isEmpty() && currentVersion instanceof MetaTagged) { MetaTagged metaTagged = (MetaTagged) currentVersion; versions.setCreator(metaTagged.getMetaInfo().getAuthor()); } if (sameFile || VFSManager.copyContent(currentFile, versionContainer.createChildLeaf(uuid))) { if (identity != null) { versions.setAuthor(identity.getName()); } if (maxNumOfVersions >= 0 && versions.getRevisions().size() >= maxNumOfVersions) { List<VFSRevision> revisions = versions.getRevisions(); int numOfVersionsToDelete = Math.min(revisions.size(), (revisions.size() - maxNumOfVersions) + 1); if (numOfVersionsToDelete > 0) { List<VFSRevision> versionsToDelete = revisions.subList(0, numOfVersionsToDelete); deleteRevisions(currentVersion, versionsToDelete); versions = (VersionsFileImpl) currentVersion.getVersions(); } } versions.setComment(comment); versions.getRevisions().add(newRevision); versions.setRevisionNr(getNextRevisionNr(versions)); XStreamHelper.writeObject(mystream, versionFile, versions); if (currentVersion.getVersions() instanceof VersionsFileImpl) { ((VersionsFileImpl) currentVersion.getVersions()).update(versions); } return true; } else { log.error("Cannot create a version of this file: " + currentVersion); } return false; }