diff options
24 files changed, 899 insertions, 53 deletions
diff --git a/gradle.properties b/gradle.properties index 8f29ad1..8b22d27 100644 --- a/gradle.properties +++ b/gradle.properties @@ -6,7 +6,7 @@ minecraft_version=1.14.4 yarn_mappings=1.14.4+build.18 loader_version=0.11.0 # Mod Properties -mod_version=1.4.5 +mod_version=1.4.6 maven_group=com.keuin.kbackupfabric archives_base_name=kbackup-fabric # Dependencies diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollection2.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollection2.java new file mode 100644 index 0000000..8d8eb14 --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollection2.java @@ -0,0 +1,70 @@ +package com.keuin.kbackupfabric.backup.incremental; + +import java.io.Serializable; +import java.util.*; + +/** + * This class must be in package `com.keuin.kbackupfabric.util.backup.incremental.ObjectCollection`, + * or it will not be compatible with old backups. + */ +public class ObjectCollection2 implements Serializable { + + private final String name; + private final Map<String, ObjectElement> elements; + private final Map<String, ObjectCollection2> subCollections; + + ObjectCollection2(String name, Set<ObjectElement> elements, Map<String, ObjectCollection2> subCollections) { + this.name = Objects.requireNonNull(name); + this.elements = new HashMap<>(); + for (ObjectElement e : elements) { + Objects.requireNonNull(e); + if (this.elements.put(e.getName(), e) != null) { + throw new IllegalStateException("elements conflict with the same name"); + } + } + this.subCollections = new HashMap<>(Objects.requireNonNull(subCollections)); + } + + public String getName() { + return name; + } + + public Set<ObjectElement> getElementSet() { + return new HashSet<>(elements.values()); + } + + public Map<String, ObjectElement> getElementMap() { + return Collections.unmodifiableMap(elements); + } + + public ObjectElement getElement(String name) { + return elements.get(name); + } + + public Set<ObjectCollection2> getSubCollectionSet() { + return new HashSet<>(subCollections.values()); + } + + public Map<String, ObjectCollection2> getSubCollectionMap() { + return Collections.unmodifiableMap(subCollections); + } + + public ObjectCollection2 getSubCollection(String name) { + return subCollections.get(name); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ObjectCollection2 that = (ObjectCollection2) o; + return name.equals(that.name) && + elements.equals(that.elements) && + subCollections.equals(that.subCollections); + } + + @Override + public int hashCode() { + return Objects.hash(name, elements, subCollections); + } +} diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionConverter.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionConverter.java new file mode 100644 index 0000000..4e8a379 --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionConverter.java @@ -0,0 +1,30 @@ +package com.keuin.kbackupfabric.backup.incremental; + +import com.keuin.kbackupfabric.util.backup.incremental.ObjectCollection; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +/** + * Convert legacy `ObjectCollection` (keep for backward-compatibility after refactoring the code) + * to new `ObjectCollection2`. + */ +public class ObjectCollectionConverter { + /** + * Convert legacy `ObjectCollection` (keep for backward-compatibility after refactoring the code) + * to new `ObjectCollection2`. + * + * @param objectCollection old instance. + * @return new instance. + */ + public static ObjectCollection2 convert(ObjectCollection objectCollection) { + Map<String, ObjectCollection> oldSubCollectionMap = objectCollection.getSubCollectionMap(); + Map<String, ObjectCollection2> convertedSubCollectionMap = new HashMap<>(oldSubCollectionMap.size()); + oldSubCollectionMap.forEach((s, c) -> convertedSubCollectionMap.put(s, convert(c))); + Set<ObjectElement> convertedElementSet = new HashSet<>(); + objectCollection.getElementSet().forEach(oldElement -> convertedElementSet.add(ObjectElementConverter.convert(oldElement))); + return new ObjectCollection2(objectCollection.getName(), convertedElementSet, convertedSubCollectionMap); + } +} diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionFactory.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionFactory.java index 17eddaf..9b1a226 100644 --- a/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionFactory.java +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionFactory.java @@ -37,9 +37,9 @@ public class ObjectCollectionFactory<T extends ObjectIdentifier> { throw new IllegalArgumentException("minParallelProcessFileCountThreshold must not be negative."); } - public ObjectCollection fromDirectory(File directory, Set<String> ignoredFiles) throws IOException { + public ObjectCollection2 fromDirectory(File directory, Set<String> ignoredFiles) throws IOException { - final Map<String, ObjectCollection> subCollections = new HashMap<>(); + final Map<String, ObjectCollection2> subCollections = new HashMap<>(); if (!Objects.requireNonNull(directory).isDirectory()) throw new IllegalArgumentException("given file is not a directory"); @@ -92,10 +92,10 @@ public class ObjectCollectionFactory<T extends ObjectIdentifier> { } } - return new ObjectCollection(directory.getName(), subFiles, subCollections); + return new ObjectCollection2(directory.getName(), subFiles, subCollections); } - public ObjectCollection fromDirectory(File directory) throws IOException { + public ObjectCollection2 fromDirectory(File directory) throws IOException { return fromDirectory(directory, Collections.emptySet()); } diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionSerializer.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionSerializer.java index f45d4d0..f663f20 100644 --- a/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionSerializer.java +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionSerializer.java @@ -5,14 +5,20 @@ import java.util.Objects; /** * Serialize and deserialize ObjectCollection from/to the disk file. + * Now we want to save additional metadata in incremental backups. So the serializer on pure ObjectCollection is depreciated. */ public class ObjectCollectionSerializer { - public static ObjectCollection fromFile(File file) throws IOException { + + /** + * This doesn't work with the latest format. Use IncBackupInfoSerializer instead. + */ + @Deprecated + public static ObjectCollection2 fromFile(File file) throws IOException { Objects.requireNonNull(file); - ObjectCollection collection; + ObjectCollection2 collection; try (FileInputStream fileInputStream = new FileInputStream(file)) { try (ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream)) { - collection = (ObjectCollection) objectInputStream.readObject(); + collection = (ObjectCollection2) objectInputStream.readObject(); } catch (ClassNotFoundException ignored) { // this should not happen return null; @@ -21,7 +27,10 @@ public class ObjectCollectionSerializer { return collection; } - public static void toFile(ObjectCollection collection, File file) throws IOException { + /** + * Only used for testing backward-compatibility with legacy backups. + */ + public static void toFile(ObjectCollection2 collection, File file) throws IOException { Objects.requireNonNull(collection); Objects.requireNonNull(file); try (FileOutputStream fileOutputStream = new FileOutputStream(file)) { diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectElementConverter.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectElementConverter.java new file mode 100644 index 0000000..512c2d2 --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectElementConverter.java @@ -0,0 +1,18 @@ +package com.keuin.kbackupfabric.backup.incremental; + +import com.keuin.kbackupfabric.backup.incremental.identifier.Sha256IdentifierConverter; +import com.keuin.kbackupfabric.util.backup.incremental.identifier.Sha256Identifier; + +public class ObjectElementConverter { + public static ObjectElement convert(com.keuin.kbackupfabric.util.backup.incremental.ObjectElement oldObjectElement) { + try { + return new ObjectElement( + oldObjectElement.getName(), + // in real world case, Sha256Identifier is the only used identifier in KBackup. So the cast is surely safe + Sha256IdentifierConverter.convert((Sha256Identifier) oldObjectElement.getIdentifier()) + ); + } catch (IllegalAccessException | NoSuchFieldException e) { + throw new RuntimeException(e); + } + } +} diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/identifier/Sha256IdentifierConverter.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/identifier/Sha256IdentifierConverter.java new file mode 100644 index 0000000..a8ec77c --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/identifier/Sha256IdentifierConverter.java @@ -0,0 +1,14 @@ +package com.keuin.kbackupfabric.backup.incremental.identifier; + +import com.keuin.kbackupfabric.util.backup.incremental.identifier.SingleHashIdentifier; + +import java.lang.reflect.Field; + +public class Sha256IdentifierConverter { + public static Sha256Identifier convert(com.keuin.kbackupfabric.util.backup.incremental.identifier.Sha256Identifier old) throws NoSuchFieldException, IllegalAccessException { + Field field = ((SingleHashIdentifier) old).getClass().getSuperclass().getDeclaredField("hash"); + field.setAccessible(true); + byte[] hash = (byte[]) field.get(old); + return new Sha256Identifier(hash); + } +} diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/manager/IncCopyResult.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/manager/IncCopyResult.java new file mode 100644 index 0000000..6011ea5 --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/manager/IncCopyResult.java @@ -0,0 +1,105 @@ +package com.keuin.kbackupfabric.backup.incremental.manager; + +import com.keuin.kbackupfabric.backup.BackupFilesystemUtil; + +import java.util.Objects; + +/** + * Returned by `addObjectCollection` in IncrementalBackupStorageManager. + * Immutable. + */ +public class IncCopyResult { + + private final int totalFiles; + private final int filesCopied; + private final long bytesCopied; + private final long bytesTotal; + + public static final IncCopyResult ZERO = new IncCopyResult(0, 0, 0, 0); + + public IncCopyResult(int totalFiles, int filesCopied, long bytesCopied, long bytesTotal) { + this.totalFiles = totalFiles; + this.filesCopied = filesCopied; + this.bytesCopied = bytesCopied; + this.bytesTotal = bytesTotal; + } + + /** + * Get total files in the collection, containing reused files. + * + * @return file count. + */ + public int getTotalFiles() { + return totalFiles; + } + + /** + * Get new files added to the base. + * + * @return file count. + */ + public int getFilesCopied() { + return filesCopied; + } + + /** + * Get total bytes of new files added to the base. + * + * @return bytes. + */ + public long getBytesCopied() { + return bytesCopied; + } + + /** + * Get total bytes of all files in the collection. This equals to copied_files_bytes + reused_files_bytes. + * + * @return bytes. + */ + public long getBytesTotal() { + return bytesTotal; + } + + /** + * Add with another AddResult. + * + * @param a object. + * @return the add result. + */ + public IncCopyResult addWith(IncCopyResult a) { + Objects.requireNonNull(a); + return new IncCopyResult( + totalFiles + a.totalFiles, + filesCopied + a.filesCopied, + bytesCopied + a.bytesCopied, + bytesTotal + a.bytesTotal + ); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + IncCopyResult that = (IncCopyResult) o; + return totalFiles == that.totalFiles && + filesCopied == that.filesCopied && + bytesCopied == that.bytesCopied && + bytesTotal == that.bytesTotal; + } + + @Override + public int hashCode() { + return Objects.hash(totalFiles, filesCopied, bytesCopied, bytesTotal); + } + + @Override + public String toString() { + return String.format( + "Files copied: %d (%s in size, totally %d files). Total file tree size: %s.", + filesCopied, + BackupFilesystemUtil.getFriendlyFileSizeString(bytesCopied), + totalFiles, + BackupFilesystemUtil.getFriendlyFileSizeString(bytesTotal) + ); + } +} diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/manager/IncrementalBackupStorageManager.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/manager/IncrementalBackupStorageManager.java index 945fcc4..78c6943 100644 --- a/src/main/java/com/keuin/kbackupfabric/backup/incremental/manager/IncrementalBackupStorageManager.java +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/manager/IncrementalBackupStorageManager.java @@ -1,17 +1,18 @@ package com.keuin.kbackupfabric.backup.incremental.manager; -import com.keuin.kbackupfabric.backup.incremental.ObjectCollection; +import com.keuin.kbackupfabric.backup.incremental.ObjectCollection2; import com.keuin.kbackupfabric.backup.incremental.ObjectElement; import com.keuin.kbackupfabric.backup.incremental.identifier.ObjectIdentifier; import com.keuin.kbackupfabric.backup.incremental.identifier.StorageObjectLoader; +import com.keuin.kbackupfabric.util.FilesystemUtil; import com.keuin.kbackupfabric.util.PrintUtil; +import org.jetbrains.annotations.Nullable; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; -import java.nio.file.Paths; import java.util.*; import static org.apache.commons.io.FileUtils.forceDelete; @@ -28,11 +29,14 @@ public class IncrementalBackupStorageManager { /** * Add a object collection to storage base. + * * @param collection the collection. * @return objects copied to the base. * @throws IOException I/O Error. */ - public int addObjectCollection(ObjectCollection collection, File collectionBasePath) throws IOException { + public @Nullable + IncCopyResult addObjectCollection(ObjectCollection2 collection, File collectionBasePath) throws IOException { + // TODO: add failure detection if (!backupStorageBase.toFile().isDirectory()) { if (!backupStorageBase.toFile().mkdirs()) throw new IOException("Backup storage base directory does not exist, and failed to create it."); @@ -40,22 +44,28 @@ public class IncrementalBackupStorageManager { Objects.requireNonNull(collection); Objects.requireNonNull(collectionBasePath); - int copyCount = 0; + IncCopyResult copyCount = IncCopyResult.ZERO; // copy sub files for (Map.Entry<String, ObjectElement> entry : collection.getElementMap().entrySet()) { File copyDestination = new File(backupStorageBase.toFile(), entry.getValue().getIdentifier().getIdentification()); + File copySourceFile = new File(collectionBasePath.getAbsolutePath(), entry.getKey()); + final long fileBytes = FilesystemUtil.getFileSizeBytes(copySourceFile.getAbsolutePath()); if (!baseContainsObject(entry.getValue())) { // element does not exist. copy. - Files.copy(Paths.get(collectionBasePath.getAbsolutePath(), entry.getKey()), copyDestination.toPath()); - ++copyCount; + Files.copy(copySourceFile.toPath(), copyDestination.toPath()); + copyCount = copyCount.addWith(new IncCopyResult(1, 1, fileBytes, fileBytes)); + } + { + // element exists (file reused). Just update the stat info + copyCount = copyCount.addWith(new IncCopyResult(1, 1, 0, fileBytes)); } } //copy sub dirs recursively - for (Map.Entry<String, ObjectCollection> entry : collection.getSubCollectionMap().entrySet()) { + for (Map.Entry<String, ObjectCollection2> entry : collection.getSubCollectionMap().entrySet()) { File newBase = new File(collectionBasePath, entry.getKey()); - copyCount += addObjectCollection(entry.getValue(), newBase); + copyCount = copyCount.addWith(addObjectCollection(entry.getValue(), newBase)); } return copyCount; @@ -63,12 +73,13 @@ public class IncrementalBackupStorageManager { /** * Restore an object collection from the storage base. i.e., restore the save from backup storage. - * @param collection the collection to be restored. + * + * @param collection the collection to be restored. * @param collectionBasePath save path of the collection. * @return objects restored from the base. * @throws IOException I/O Error. */ - public int restoreObjectCollection(ObjectCollection collection, File collectionBasePath) throws IOException { + public int restoreObjectCollection(ObjectCollection2 collection, File collectionBasePath) throws IOException { Objects.requireNonNull(collection); Objects.requireNonNull(collectionBasePath); @@ -122,7 +133,7 @@ public class IncrementalBackupStorageManager { } //copy sub dirs recursively - for (Map.Entry<String, ObjectCollection> entry : collection.getSubCollectionMap().entrySet()) { + for (Map.Entry<String, ObjectCollection2> entry : collection.getSubCollectionMap().entrySet()) { File newBase = new File(collectionBasePath, entry.getKey()); copyCount += restoreObjectCollection(entry.getValue(), newBase); } @@ -130,12 +141,12 @@ public class IncrementalBackupStorageManager { return copyCount; } - public int cleanUnusedObjects(Iterable<ObjectCollection> collectionIterable) { + public int cleanUnusedObjects(Iterable<ObjectCollection2> collectionIterable) { // construct object list in memory Set<String> objects = new HashSet<>(); // backupStorageBase - for (ObjectCollection collection : collectionIterable) { + for (ObjectCollection2 collection : collectionIterable) { for (ObjectElement ele : collection.getElementMap().values()) { } @@ -185,5 +196,4 @@ public class IncrementalBackupStorageManager { map.put(identifier, file); }); } - } diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/IncBackupInfoSerializer.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/IncBackupInfoSerializer.java new file mode 100644 index 0000000..45590ba --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/IncBackupInfoSerializer.java @@ -0,0 +1,65 @@ +package com.keuin.kbackupfabric.backup.incremental.serializer; + +import com.keuin.kbackupfabric.backup.incremental.ObjectCollection2; +import com.keuin.kbackupfabric.backup.incremental.ObjectCollectionConverter; +import com.keuin.kbackupfabric.backup.name.BackupFileNameEncoder; +import com.keuin.kbackupfabric.backup.name.IncrementalBackupFileNameEncoder; +import com.keuin.kbackupfabric.util.backup.incremental.ObjectCollection; + +import java.io.*; +import java.util.Objects; + +public class IncBackupInfoSerializer { + /** + * Load incremental backup index file into object, no matter what version it is. + * + * @param file a valid incremental backup file. (with a valid file name) + * @return the object. Not null. + * @throws IOException when failed due to an I/O error. + */ + public static SavedIncrementalBackup fromFile(File file) throws IOException { + Objects.requireNonNull(file); + try (FileInputStream fileInputStream = new FileInputStream(file)) { + try (ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream)) { + Object o = objectInputStream.readObject(); + if (o instanceof SavedIncrementalBackup) { + return (SavedIncrementalBackup) o; + } else if (o instanceof ObjectCollection) { + // backward compatibility with old-style (v0) incremental backup + BackupFileNameEncoder.BackupBasicInformation info = new IncrementalBackupFileNameEncoder().decode(file.getName()); + if (info == null) + throw new IOException("Invalid backup file name."); + return new SavedIncBackupV0(ObjectCollectionConverter.convert((ObjectCollection) o), info); + } else if (o instanceof ObjectCollection2) { + // compatible with 1.4.6 implementation + BackupFileNameEncoder.BackupBasicInformation info = new IncrementalBackupFileNameEncoder().decode(file.getName()); + if (info == null) + throw new IOException("Invalid backup file name."); + return new SavedIncBackupV0((ObjectCollection2) o, info); + } else { + throw new RuntimeException("Unrecognized backup file format: unknown class " + o.getClass().getCanonicalName()); + } + } catch (ClassNotFoundException e) { + // this should not happen + throw new RuntimeException(e); + } + } + } + + /** + * Save incremental backup index and metadata into file. + * + * @param file the file. + * @param backup the backup. + * @throws IOException when failed due to an I/O error. + */ + public static void toFile(File file, SavedIncrementalBackup backup) throws IOException { + Objects.requireNonNull(file); + Objects.requireNonNull(backup); + try (FileOutputStream fileOutputStream = new FileOutputStream(file)) { + try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream)) { + objectOutputStream.writeObject(backup); + } + } + } +} diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/SavedIncBackupV0.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/SavedIncBackupV0.java new file mode 100644 index 0000000..8b4a4a1 --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/SavedIncBackupV0.java @@ -0,0 +1,64 @@ +package com.keuin.kbackupfabric.backup.incremental.serializer; + +import com.keuin.kbackupfabric.backup.incremental.ObjectCollection2; +import com.keuin.kbackupfabric.backup.name.BackupFileNameEncoder; + +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.ZonedDateTime; +import java.util.Objects; + +/** + * The old-style incremental backup. Just to keep backward compatibility with old backups. + */ +public class SavedIncBackupV0 implements SavedIncrementalBackup { + + private final ObjectCollection2 objectCollection2; + private final String backupName; + private final LocalDateTime namedBackupTime; + + public SavedIncBackupV0(ObjectCollection2 objectCollection2, BackupFileNameEncoder.BackupBasicInformation backupBasicInformation) { + Objects.requireNonNull(objectCollection2); + Objects.requireNonNull(backupBasicInformation); + + this.objectCollection2 = objectCollection2; + this.backupName = backupBasicInformation.customName; + this.namedBackupTime = backupBasicInformation.time; + } + + + @Override + public ObjectCollection2 getObjectCollection() { + return objectCollection2; + } + + @Override + public String getBackupName() { + return backupName; + } + + @Override + public ZonedDateTime getBackupTime() { + return namedBackupTime.atZone(ZoneId.systemDefault()); + } + + @Override + public int getFilesAdded() { + return -1; // missing info + } + + @Override + public long getTotalSizeBytes() { + return -1; // missing info + } + + @Override + public long getIncreasedSizeBytes() { + return -1; // missing info + } + + @Override + public String toString() { + return String.format("(Legacy Backup) %s, created at %s", backupName, namedBackupTime); + } +} diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/SavedIncBackupV1.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/SavedIncBackupV1.java new file mode 100644 index 0000000..0ebe06a --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/SavedIncBackupV1.java @@ -0,0 +1,100 @@ +package com.keuin.kbackupfabric.backup.incremental.serializer; + +import com.keuin.kbackupfabric.backup.BackupFilesystemUtil; +import com.keuin.kbackupfabric.backup.incremental.ObjectCollection2; + +import java.io.Serializable; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.util.Objects; + +public class SavedIncBackupV1 implements SavedIncrementalBackup, Serializable { + + private final ObjectCollection2 objectCollection2; + private final String backupName; + private final ZonedDateTime backupTime; + private final long totalSizeBytes; + private final long increasedSizeBytes; + private final int filesAdded; + private final int totalFiles; + private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss"); + + public SavedIncBackupV1(ObjectCollection2 objectCollection2, String backupName, ZonedDateTime backupTime, long totalSizeBytes, long increasedSizeBytes, int filesAdded, int totalFiles) { + this.totalFiles = totalFiles; + Objects.requireNonNull(objectCollection2); + Objects.requireNonNull(backupName); + Objects.requireNonNull(backupTime); + this.objectCollection2 = objectCollection2; + this.backupName = backupName; + this.backupTime = backupTime; + this.totalSizeBytes = totalSizeBytes; + this.increasedSizeBytes = increasedSizeBytes; + this.filesAdded = filesAdded; + } + + @Override + public ObjectCollection2 getObjectCollection() { + return objectCollection2; + } + + @Override + public String getBackupName() { + return backupName; + } + + @Override + public ZonedDateTime getBackupTime() { + return backupTime; + } + + @Override + public int getFilesAdded() { + return filesAdded; + } + + @Override + public long getTotalSizeBytes() { + return totalSizeBytes; + } + + @Override + public long getIncreasedSizeBytes() { + return increasedSizeBytes; + } + + public int getTotalFiles() { + return totalFiles; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + SavedIncBackupV1 that = (SavedIncBackupV1) o; + return totalSizeBytes == that.totalSizeBytes && + increasedSizeBytes == that.increasedSizeBytes && + filesAdded == that.filesAdded && + totalFiles == that.totalFiles && + objectCollection2.equals(that.objectCollection2) && + backupName.equals(that.backupName) && + backupTime.equals(that.backupTime); + } + + @Override + public int hashCode() { + return Objects.hash(objectCollection2, backupName, backupTime, totalSizeBytes, increasedSizeBytes, filesAdded, totalFiles); + } + + @Override + public String toString() { + return String.format( + "%s, created at %s, files: %d (total size: %s), copied size: %s, files added: %d", + backupName, + backupTime.format(formatter), + totalFiles, + BackupFilesystemUtil.getFriendlyFileSizeString(totalSizeBytes), + BackupFilesystemUtil.getFriendlyFileSizeString(increasedSizeBytes), + filesAdded + ); + } +} diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/SavedIncrementalBackup.java b/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/SavedIncrementalBackup.java new file mode 100644 index 0000000..e2e50b6 --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/backup/incremental/serializer/SavedIncrementalBackup.java @@ -0,0 +1,62 @@ +package com.keuin.kbackupfabric.backup.incremental.serializer; + + +import com.keuin.kbackupfabric.backup.incremental.ObjectCollection2; + +import java.io.Serializable; +import java.time.ZonedDateTime; + +/** + * The abstraction of an object saved in the disk, containing all information (except binary data of files) about an incremental backup. + */ +public interface SavedIncrementalBackup extends Serializable { + + /** + * Get an instance with the latest version. + */ + static SavedIncrementalBackup newLatest(ObjectCollection2 objectCollection2, String backupName, ZonedDateTime backupTime, long totalSizeBytes, long increasedSizeBytes, int filesAdded, int totalFiles) { + return new SavedIncBackupV1(objectCollection2, backupName, backupTime, totalSizeBytes, increasedSizeBytes, filesAdded, totalFiles); + } + + /** + * Get the object collection of the level directory. + * + * @return the object collection. + */ + ObjectCollection2 getObjectCollection(); + + /** + * Get the custom backup name. + * + * @return the backup name. + */ + String getBackupName(); + + /** + * Get the time when this backup was made. + * + * @return the time. + */ + ZonedDateTime getBackupTime(); + + /** + * Get new files added to the base. + * + * @return file count. + */ + int getFilesAdded(); + + /** + * Get the total size of the saved world. + * + * @return the size in bytes. + */ + long getTotalSizeBytes(); + + /** + * Get the size we cost to add this backup into the base. + * + * @return the increased size in bytes. + */ + long getIncreasedSizeBytes(); +} diff --git a/src/main/java/com/keuin/kbackupfabric/operation/backup/feedback/IncrementalBackupFeedback.java b/src/main/java/com/keuin/kbackupfabric/operation/backup/feedback/IncrementalBackupFeedback.java index f39fde6..1a05c8c 100644 --- a/src/main/java/com/keuin/kbackupfabric/operation/backup/feedback/IncrementalBackupFeedback.java +++ b/src/main/java/com/keuin/kbackupfabric/operation/backup/feedback/IncrementalBackupFeedback.java @@ -1,12 +1,15 @@ package com.keuin.kbackupfabric.operation.backup.feedback; +import com.keuin.kbackupfabric.backup.incremental.manager.IncCopyResult; +import org.jetbrains.annotations.Nullable; + public class IncrementalBackupFeedback implements BackupFeedback { private final boolean success; - private final int newFilesAdded; + private final IncCopyResult copyResult; - public IncrementalBackupFeedback(boolean success, int newFilesAdded) { + public IncrementalBackupFeedback(boolean success, @Nullable IncCopyResult copyResult) { this.success = success; - this.newFilesAdded = newFilesAdded; + this.copyResult = copyResult; } @Override @@ -14,15 +17,15 @@ public class IncrementalBackupFeedback implements BackupFeedback { return success; } - public long getNewFilesAdded() { - return newFilesAdded; + public IncCopyResult getCopyResult() { + return copyResult; } @Override public String getFeedback() { - if (success && newFilesAdded >= 0) - return String.format("File(s) added: %d.", newFilesAdded); + if (success && copyResult != null) + return String.format("File(s) added: %s.", copyResult); else - return ""; + return "Backup failed."; } } diff --git a/src/main/java/com/keuin/kbackupfabric/operation/backup/method/ConfiguredIncrementalBackupMethod.java b/src/main/java/com/keuin/kbackupfabric/operation/backup/method/ConfiguredIncrementalBackupMethod.java index 569c4c6..2320ef3 100644 --- a/src/main/java/com/keuin/kbackupfabric/operation/backup/method/ConfiguredIncrementalBackupMethod.java +++ b/src/main/java/com/keuin/kbackupfabric/operation/backup/method/ConfiguredIncrementalBackupMethod.java @@ -1,10 +1,14 @@ package com.keuin.kbackupfabric.operation.backup.method; -import com.keuin.kbackupfabric.backup.incremental.ObjectCollection; +import com.keuin.kbackupfabric.backup.incremental.ObjectCollection2; import com.keuin.kbackupfabric.backup.incremental.ObjectCollectionFactory; -import com.keuin.kbackupfabric.backup.incremental.ObjectCollectionSerializer; import com.keuin.kbackupfabric.backup.incremental.identifier.Sha256Identifier; +import com.keuin.kbackupfabric.backup.incremental.manager.IncCopyResult; import com.keuin.kbackupfabric.backup.incremental.manager.IncrementalBackupStorageManager; +import com.keuin.kbackupfabric.backup.incremental.serializer.IncBackupInfoSerializer; +import com.keuin.kbackupfabric.backup.incremental.serializer.SavedIncrementalBackup; +import com.keuin.kbackupfabric.backup.name.BackupFileNameEncoder; +import com.keuin.kbackupfabric.backup.name.IncrementalBackupFileNameEncoder; import com.keuin.kbackupfabric.operation.backup.feedback.IncrementalBackupFeedback; import com.keuin.kbackupfabric.util.FilesystemUtil; import com.keuin.kbackupfabric.util.PrintUtil; @@ -13,6 +17,7 @@ import com.keuin.kbackupfabric.util.ThreadingUtil; import java.io.File; import java.io.IOException; import java.nio.file.Paths; +import java.time.ZoneId; import java.util.Arrays; import java.util.HashSet; import java.util.logging.Logger; @@ -35,9 +40,7 @@ public class ConfiguredIncrementalBackupMethod implements ConfiguredBackupMethod @Override public IncrementalBackupFeedback backup() { - final int hashFactoryThreads = ThreadingUtil.getRecommendedThreadCount(); // how many threads do we use to generate the hash tree - LOGGER.info("Threads: " + hashFactoryThreads); IncrementalBackupFeedback feedback; @@ -46,24 +49,44 @@ public class ConfiguredIncrementalBackupMethod implements ConfiguredBackupMethod // construct incremental backup index PrintUtil.info("Hashing files..."); - ObjectCollection collection = new ObjectCollectionFactory<>(Sha256Identifier.getFactory(), hashFactoryThreads, 16) + // TODO + ObjectCollection2 collection = new ObjectCollectionFactory<>(Sha256Identifier.getFactory(), hashFactoryThreads, 16) .fromDirectory(levelPathFile, new HashSet<>(Arrays.asList("session.lock", "kbackup_metadata"))); // update storage PrintUtil.info("Copying files..."); IncrementalBackupStorageManager storageManager = new IncrementalBackupStorageManager(Paths.get(backupBaseDirectory)); - int filesAdded = storageManager.addObjectCollection(collection, levelPathFile); + IncCopyResult copyResult = storageManager.addObjectCollection(collection, levelPathFile); + if (copyResult == null) { + PrintUtil.info("Failed to backup. No further information."); + return new IncrementalBackupFeedback(false, null); + } // save index file PrintUtil.info("Saving index file..."); - ObjectCollectionSerializer.toFile(collection, new File(backupIndexFileSaveDirectory, backupIndexFileName)); + + // legacy index file +// ObjectCollectionSerializer.toFile(collection, new File(backupIndexFileSaveDirectory, backupIndexFileName)); + + // newer saved info (with metadata) + File indexFile = new File(backupIndexFileSaveDirectory, backupIndexFileName); + BackupFileNameEncoder.BackupBasicInformation info = new IncrementalBackupFileNameEncoder().decode(backupIndexFileName); + IncBackupInfoSerializer.toFile(indexFile, SavedIncrementalBackup.newLatest( + collection, + info.customName, + info.time.atZone(ZoneId.systemDefault()), + copyResult.getBytesTotal(), + copyResult.getBytesCopied(), + copyResult.getFilesCopied(), + copyResult.getTotalFiles() + )); // return result PrintUtil.info("Incremental backup finished."); - feedback = new IncrementalBackupFeedback(filesAdded >= 0, filesAdded); + feedback = new IncrementalBackupFeedback(true, copyResult); } catch (IOException e) { e.printStackTrace(); // at least we should print it out if we discard the exception... Better than doing nothing. - feedback = new IncrementalBackupFeedback(false, 0); + feedback = new IncrementalBackupFeedback(false, null); } if (!feedback.isSuccess()) { @@ -85,10 +108,12 @@ public class ConfiguredIncrementalBackupMethod implements ConfiguredBackupMethod public boolean restore() throws IOException { // load collection PrintUtil.info("Loading file list..."); - ObjectCollection collection = ObjectCollectionSerializer.fromFile( + SavedIncrementalBackup info = IncBackupInfoSerializer.fromFile( new File(backupIndexFileSaveDirectory, backupIndexFileName) ); + PrintUtil.info("Backup Info: " + info); + // delete old level File levelPathFile = new File(levelPath); PrintUtil.info("Deleting old level..."); @@ -100,7 +125,7 @@ public class ConfiguredIncrementalBackupMethod implements ConfiguredBackupMethod // restore file PrintUtil.info("Copying files..."); IncrementalBackupStorageManager storageManager = new IncrementalBackupStorageManager(Paths.get(backupBaseDirectory)); - int restoreObjectCount = storageManager.restoreObjectCollection(collection, levelPathFile); + int restoreObjectCount = storageManager.restoreObjectCollection(info.getObjectCollection(), levelPathFile); PrintUtil.info(String.format("%d file(s) restored.", restoreObjectCount)); return true; diff --git a/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollection.java b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/ObjectCollection.java index 2d07fb4..d36ff59 100644 --- a/src/main/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollection.java +++ b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/ObjectCollection.java @@ -1,9 +1,17 @@ -package com.keuin.kbackupfabric.backup.incremental; +package com.keuin.kbackupfabric.util.backup.incremental; import java.io.Serializable; import java.util.*; +/** + * This class must be in package `com.keuin.kbackupfabric.util.backup.incremental.ObjectCollection`, + * or it will not be compatible with old backups. + * It remains only to keep a backward compatibility, and should be converted to `ObjectCollection2` as soon as possible. + */ +@Deprecated public class ObjectCollection implements Serializable { + + private static final long serialVersionUID = -3098905094513096717L; private final String name; private final Map<String, ObjectElement> elements; private final Map<String, ObjectCollection> subCollections; diff --git a/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/ObjectElement.java b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/ObjectElement.java new file mode 100644 index 0000000..a101fd3 --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/ObjectElement.java @@ -0,0 +1,61 @@ +package com.keuin.kbackupfabric.util.backup.incremental; + +import com.keuin.kbackupfabric.util.backup.incremental.identifier.ObjectIdentifier; + +import java.io.Serializable; +import java.util.Objects; + +public class ObjectElement implements Serializable { + + private static final long serialVersionUID = 268304683651745899L; + private final String name; + private final ObjectIdentifier identifier; + + public ObjectElement(String name, ObjectIdentifier identifier) { + Objects.requireNonNull(name); + Objects.requireNonNull(identifier); + this.name = name; + this.identifier = identifier; + } + + /** + * Get file name. + * + * @return the file name. + */ + public String getName() { + return name; + } + + /** + * Get file identifier, which is considered to be different between files with different contents. + * + * @return the identifier. + */ + public ObjectIdentifier getIdentifier() { + return identifier; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ObjectElement that = (ObjectElement) o; + return name.equals(that.getName()) && + identifier.equals(that.getIdentifier()); + } + + @Override + public int hashCode() { + return Objects.hash(name, identifier); + } + + @Override + public String toString() { + return "ObjectElement{" + + "name='" + name + '\'' + + ", identifier=" + identifier + + '}'; + } + +}
\ No newline at end of file diff --git a/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/identifier/ObjectIdentifier.java b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/identifier/ObjectIdentifier.java new file mode 100644 index 0000000..aece07d --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/identifier/ObjectIdentifier.java @@ -0,0 +1,13 @@ +package com.keuin.kbackupfabric.util.backup.incremental.identifier; + +import java.io.Serializable; + +/** + * The identifier distinguishing files in the object collection. + * It should be based on cryptographic hash function in order to prevent possible attacks to the backup system. + * All identifiers should be immutable and implement their own equals method. + * Immutable. + */ +public interface ObjectIdentifier extends Serializable { + String getIdentification(); +} diff --git a/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/identifier/Sha256Identifier.java b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/identifier/Sha256Identifier.java new file mode 100644 index 0000000..31cde29 --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/identifier/Sha256Identifier.java @@ -0,0 +1,84 @@ +package com.keuin.kbackupfabric.util.backup.incremental.identifier; + +import com.keuin.kbackupfabric.util.BytesUtil; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.Objects; + +/** + * Identifier based on sha256. + * Immutable. + */ +public class Sha256Identifier extends SingleHashIdentifier { + + private static final long serialVersionUID = 968324214777435054L; + private static final int SHA256_LENGTH = 32; + private static final Sha256Identifier DUMMY = new Sha256Identifier(new byte[SHA256_LENGTH]); // only for using its hash method + private static final String marker = "S2"; + + public static Sha256Identifier fromFile(File file) throws IOException { + if (!file.isFile()) { + throw new IllegalArgumentException("file is not a file"); + } + return new Sha256Identifier(DUMMY.hash(file)); + } + + /** + * Load sha-256 from a named file. Only used in StorageObjectLoader. + * + * @param fileName the file name. + * @return identifier. + */ + static Sha256Identifier fromFileName(String fileName) { + if (!fileName.matches(marker + "-[0-9A-Fa-f]{32}")) + return null; + String hexString = fileName.substring(marker.length() + 1); + return new Sha256Identifier(BytesUtil.hexToBytes(hexString)); + } + + protected Sha256Identifier(byte[] hash) { + super(hash, marker); + Objects.requireNonNull(hash); + if (hash.length != SHA256_LENGTH) { + throw new IllegalStateException(String.format("SHA256 must be %d bytes", SHA256_LENGTH)); + } + } + + @Override + protected byte[] hash(File file) throws IOException { + try { + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + + try (FileInputStream inputStream = new FileInputStream(file)) { + // This does not work. I don't know why +// FileChannel channel = inputStream.getChannel(); +// ByteBuffer buffer = ByteBuffer.allocate(128); +// int readLength; +// while ((readLength = channel.read(buffer)) > 0) +// digest.update(buffer); + + // This also works, without warnings + byte[] readBuffer = new byte[1024 * 1024]; + int readLength; + while ((readLength = inputStream.read(readBuffer)) > 0) + digest.update(readBuffer, 0, readLength); + + // The below lines also works, but the IDE will complain about the while loop +// DigestInputStream digestInputStream = new DigestInputStream(inputStream, digest); +// while(digestInputStream.read() > 0) +// ; + + return digest.digest(); + } + + } catch (NoSuchAlgorithmException ignored) { + // this shouldn't happen + return new byte[SHA256_LENGTH]; + } + } + +}
\ No newline at end of file diff --git a/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/identifier/SingleHashIdentifier.java b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/identifier/SingleHashIdentifier.java new file mode 100644 index 0000000..6c67918 --- /dev/null +++ b/src/main/java/com/keuin/kbackupfabric/util/backup/incremental/identifier/SingleHashIdentifier.java @@ -0,0 +1,53 @@ +package com.keuin.kbackupfabric.util.backup.incremental.identifier; + +import com.keuin.kbackupfabric.util.BytesUtil; + +import java.io.File; +import java.io.IOException; +import java.util.Arrays; +import java.util.Objects; + +/** + * A simple identifier based on a single hash function. + * Immutable. + */ +public abstract class SingleHashIdentifier implements ObjectIdentifier { + + private final byte[] hash; + private final String type; + + protected SingleHashIdentifier(byte[] hash, String type) { + Objects.requireNonNull(hash); + Objects.requireNonNull(type); + this.hash = Arrays.copyOf(hash, hash.length); + this.type = type; + } + + /** + * The hash function. + * + * @param file the file to be hashed. + * @return the hash bytes. + */ + protected abstract byte[] hash(File file) throws IOException; + + @Override + public String getIdentification() { + return type + "-" + BytesUtil.bytesToHex(hash); + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof com.keuin.kbackupfabric.backup.incremental.identifier.SingleHashIdentifier)) { + return false; + } + return Arrays.equals(hash, ((SingleHashIdentifier) obj).hash); + } + + @Override + public int hashCode() { + int result = Objects.hash(type); + result = 31 * result + Arrays.hashCode(hash); + return result; + } +} diff --git a/src/test/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionFactoryTest.java b/src/test/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionFactoryTest.java index 5052a82..e686e30 100644 --- a/src/test/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionFactoryTest.java +++ b/src/test/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionFactoryTest.java @@ -11,10 +11,10 @@ import static org.junit.Assert.*; public class ObjectCollectionFactoryTest { - private void validate(ObjectCollection collection, List<String> subCollections, Map<String, String> subElements) { + private void validate(ObjectCollection2 collection, List<String> subCollections, Map<String, String> subElements) { assertEquals(subCollections.size(), collection.getSubCollectionMap().size()); assertEquals(subElements.size(), collection.getElementSet().size()); - for (Map.Entry<String, ObjectCollection> c : collection.getSubCollectionMap().entrySet()) { + for (Map.Entry<String, ObjectCollection2> c : collection.getSubCollectionMap().entrySet()) { assertEquals(c.getKey(), c.getValue().getName()); assertTrue(subCollections.contains(c.getKey())); } @@ -68,7 +68,7 @@ public class ObjectCollectionFactoryTest { try { ObjectCollectionFactory<Sha256Identifier> factory = new ObjectCollectionFactory<>(Sha256Identifier.getFactory(), threads, multiThreadThreshold); - ObjectCollection collection = + ObjectCollection2 collection = factory.fromDirectory(new File("./testfile/ObjectCollectionFactoryTest")); assertEquals("ObjectCollectionFactoryTest", collection.getName()); diff --git a/src/test/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionSerializerTest.java b/src/test/java/com/keuin/kbackupfabric/backup/incremental/serializer/IncBackupInfoSerializerTest.java index d21e5b3..e7f56b0 100644 --- a/src/test/java/com/keuin/kbackupfabric/backup/incremental/ObjectCollectionSerializerTest.java +++ b/src/test/java/com/keuin/kbackupfabric/backup/incremental/serializer/IncBackupInfoSerializerTest.java @@ -1,15 +1,18 @@ -package com.keuin.kbackupfabric.backup.incremental; +package com.keuin.kbackupfabric.backup.incremental.serializer; +import com.keuin.kbackupfabric.backup.incremental.ObjectCollection2; +import com.keuin.kbackupfabric.backup.incremental.ObjectCollectionFactory; import com.keuin.kbackupfabric.backup.incremental.identifier.Sha256Identifier; import org.junit.Test; import java.io.File; import java.io.IOException; import java.nio.file.Files; +import java.time.ZonedDateTime; import static org.junit.Assert.assertEquals; -public class ObjectCollectionSerializerTest { +public class IncBackupInfoSerializerTest { @Test public void testSerializationConsistency1() throws IOException { @@ -54,16 +57,17 @@ public class ObjectCollectionSerializerTest { public void testSerializationConsistency(int threads, int multiThreadThreshold) throws IOException { ObjectCollectionFactory<Sha256Identifier> factory = new ObjectCollectionFactory<>(Sha256Identifier.getFactory(), threads, multiThreadThreshold); - ObjectCollection collection = + ObjectCollection2 collection = factory.fromDirectory(new File("./testfile/ObjectCollectionFactoryTest")); File file = new File("./testfile/serialized"); if (file.exists()) { Files.delete(file.toPath()); } - ObjectCollectionSerializer.toFile(collection, file); - ObjectCollection collection2 = ObjectCollectionSerializer.fromFile(file); + SavedIncrementalBackup backup = SavedIncrementalBackup.newLatest(collection, ":name:", ZonedDateTime.now(), 10000, 2000, 10, 20); + IncBackupInfoSerializer.toFile(file, backup); + SavedIncrementalBackup info = IncBackupInfoSerializer.fromFile(file); Files.delete(file.toPath()); - assertEquals(collection, collection2); + assertEquals(backup, info); } }
\ No newline at end of file diff --git a/src/test/java/com/keuin/kbackupfabric/backup/incremental/serializer/IncBakupBackwardCompatibilityTest.java b/src/test/java/com/keuin/kbackupfabric/backup/incremental/serializer/IncBakupBackwardCompatibilityTest.java new file mode 100644 index 0000000..d50b264 --- /dev/null +++ b/src/test/java/com/keuin/kbackupfabric/backup/incremental/serializer/IncBakupBackwardCompatibilityTest.java @@ -0,0 +1,45 @@ +package com.keuin.kbackupfabric.backup.incremental.serializer; + +import com.keuin.kbackupfabric.backup.incremental.ObjectCollection2; +import com.keuin.kbackupfabric.backup.incremental.ObjectCollectionFactory; +import com.keuin.kbackupfabric.backup.incremental.ObjectCollectionSerializer; +import com.keuin.kbackupfabric.backup.incremental.identifier.Sha256Identifier; +import com.keuin.kbackupfabric.backup.name.IncrementalBackupFileNameEncoder; +import org.junit.Test; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.time.LocalDateTime; +import java.time.ZoneOffset; + +import static org.junit.Assert.*; + +public class IncBakupBackwardCompatibilityTest { + + private final String customName = "test_backup"; + private final LocalDateTime backupTime = LocalDateTime.of(2000, 1, 1, 1, 1, 1, 1); + + private final Path testRoot = Paths.get(".\\testfile\\IncBackupBackwardCompatibilityTest"); + private final File indexFile = new File(testRoot.toString(), new IncrementalBackupFileNameEncoder().encode(customName, backupTime)); + + @Test + public void testBackwardCompatibility() throws IOException { + + if (!testRoot.toFile().isDirectory()) { + if (!testRoot.toFile().mkdirs()) + fail("Cannot initialize test environment: cannot create path."); + } + + // now we make an old-style backup index file + ObjectCollectionFactory<Sha256Identifier> factory = + new ObjectCollectionFactory<>(Sha256Identifier.getFactory(), 1, 0); + ObjectCollection2 collection = factory.fromDirectory(testRoot.toFile()); + ObjectCollectionSerializer.toFile(collection, indexFile); + SavedIncrementalBackup info = IncBackupInfoSerializer.fromFile(indexFile); + assertEquals(collection, info.getObjectCollection()); + assertEquals(customName, info.getBackupName()); + assertTrue(backupTime.toEpochSecond(ZoneOffset.UTC) - info.getBackupTime().toLocalDateTime().toEpochSecond(ZoneOffset.UTC) <= 2); + } +} diff --git a/src/test/java/com/keuin/kbackupfabric/operation/backup/method/ConfiguredIncrementalBackupMethodTest.java b/src/test/java/com/keuin/kbackupfabric/operation/backup/method/ConfiguredIncrementalBackupMethodTest.java index badc744..80c643d 100644 --- a/src/test/java/com/keuin/kbackupfabric/operation/backup/method/ConfiguredIncrementalBackupMethodTest.java +++ b/src/test/java/com/keuin/kbackupfabric/operation/backup/method/ConfiguredIncrementalBackupMethodTest.java @@ -1,5 +1,6 @@ package com.keuin.kbackupfabric.operation.backup.method; +import com.keuin.kbackupfabric.backup.name.IncrementalBackupFileNameEncoder; import com.keuin.kbackupfabric.operation.backup.feedback.IncrementalBackupFeedback; import org.apache.commons.codec.digest.DigestUtils; import org.junit.Test; @@ -8,6 +9,7 @@ import java.io.*; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; +import java.time.LocalDateTime; import java.util.*; import java.util.function.Function; @@ -19,7 +21,8 @@ public class ConfiguredIncrementalBackupMethodTest { private final String testTempPath = (new File("R:\\").isDirectory()) ? "R:\\" : ".\\testfile\\ConfiguredIncrementalBackupMethodTest"; private final String sourceDirectoryName = "source"; private final String destDirectoryName = "destination"; - private final String indexFileName = "index"; + private final String customBackupName = "index"; + private final String indexFileName = new IncrementalBackupFileNameEncoder().encode(customBackupName, LocalDateTime.now()); private final double directoryFactor = 0.05; private final double fileFactor = 0.1; |