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;
}
/**
* Get the canonical path to the file's meta file.
*
* @param bcPath
* @return String
*/
private VFSLeaf getCanonicalVersionXmlFile(VFSItem item, boolean create) {
File f = getOriginFile(item);
if (!f.exists()) {
return null;
}
String relPath = getRelPath(item);
if (relPath == null) {
// cannot handle
return null;
}
File fVersion = new File(getRootVersionsFile(), relPath + ".xml");
File fParentVersion = fVersion.getParentFile();
if (!fParentVersion.exists() && create) {
fParentVersion.mkdirs();
}
if (fVersion.exists()) {
LocalFolderImpl localVersionContainer = new LocalFolderImpl(fParentVersion);
return (VFSLeaf) localVersionContainer.resolve(fVersion.getName());
} else if (create) {
LocalFolderImpl localVersionContainer = new LocalFolderImpl(fParentVersion);
VersionsFileImpl versions = new VersionsFileImpl();
versions.setVersioned(isVersioned(item));
versions.setRevisionNr(getNextRevisionNr(versions));
VFSLeaf fVersions = localVersionContainer.createChildLeaf(fVersion.getName());
XStreamHelper.writeObject(mystream, fVersions, versions);
return fVersions;
}
return null;
}
private Versions readVersions(VFSLeaf leaf, boolean create) {
VFSLeaf fVersions = getCanonicalVersionXmlFile(leaf, create);
if (!create && fVersions == null) {
VersionsFileImpl versions = new VersionsFileImpl();
versions.setCurrentVersion((Versionable) leaf);
versions.setVersioned(isVersioned(leaf));
versions.setRevisionNr(getNextRevisionNr(versions));
return versions;
}
return readVersions(leaf, fVersions);
}
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;
}
@Override
public boolean move(VFSLeaf currentFile, VFSLeaf targetFile, Identity author) {
VFSLeaf fCurrentVersions = getCanonicalVersionXmlFile(currentFile, true);
Versions currentVersions = readVersions(currentFile, fCurrentVersions);
boolean brandNewVersionFile = false;
VFSLeaf fTargetVersions = getCanonicalVersionXmlFile(targetFile, false);
if (fTargetVersions == null) {
brandNewVersionFile = true;
fTargetVersions = getCanonicalVersionXmlFile(targetFile, true);
}
Versions targetVersions = readVersions(targetFile, fTargetVersions);
if (!(currentVersions instanceof VersionsFileImpl)
|| !(targetVersions instanceof VersionsFileImpl)) {
return false;
}
VersionsFileImpl targetVersionsImpl = (VersionsFileImpl) targetVersions;
if (author != null) {
targetVersionsImpl.setAuthor(author.getName());
}
if (brandNewVersionFile) {
targetVersionsImpl.setCreator(currentVersions.getCreator());
targetVersionsImpl.setComment(currentVersions.getComment());
}
boolean allOk = true;
for (VFSRevision revision : currentVersions.getRevisions()) {
allOk &= copyRevision(revision, fTargetVersions, targetVersionsImpl);
}
targetVersionsImpl.setRevisionNr(getNextRevisionNr(targetVersionsImpl));
XStreamHelper.writeObject(mystream, fTargetVersions, targetVersionsImpl);
return allOk;
}
@Override
public boolean restore(VFSContainer container, VFSRevision revision) {
String filename = revision.getName();
VFSItem restoredItem = container.resolve(filename);
if (restoredItem == null) {
restoredItem = container.createChildLeaf(filename);
}
if (restoredItem instanceof VFSLeaf) {
VFSLeaf restoredLeaf = (VFSLeaf) restoredItem;
InputStream inStream = revision.getInputStream();
if (VFSManager.copyContent(inStream, restoredLeaf)) {
VFSLeaf versionFile = getCanonicalVersionXmlFile(restoredLeaf, true);
Versions versions = readVersions(restoredLeaf, versionFile);
if (versions instanceof VersionsFileImpl) {
versions.getRevisions().remove(revision);
((VersionsFileImpl) versions).setRevisionNr(getNextRevisionNr(versions));
}
XStreamHelper.writeObject(mystream, versionFile, versions);
return true;
}
}
return false;
}
/**
* @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;
}
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;
}
}
