Implementing incremental backup

4 files changed, 235 insertions, 6 deletions

diff --git a/src/main/java/com/keuin/kbackupfabric/operation/backup/BackupMethod.java b/src/main/java/com/keuin/kbackupfabric/operation/backup/BackupMethod.java
index b0b77cb..4e9eb6c 100644
--- a/src/main/java/com/keuin/kbackupfabric/operation/backup/BackupMethod.java
+++ b/src/main/java/com/keuin/kbackupfabric/operation/backup/BackupMethod.java
@@ -2,10 +2,12 @@ package com.keuin.kbackupfabric.operation.backup;
 
 import com.keuin.kbackupfabric.util.backup.builder.BackupFileNameBuilder;
 import com.keuin.kbackupfabric.util.backup.formatter.BackupFileNameFormatter;
-import com.sun.istack.internal.NotNull;
 
 import java.io.IOException;
 
+/**
+ * Provide specific backup method, which is implemented statelessly.
+ */
 public interface BackupMethod {
 
     /**
@@ -14,10 +16,29 @@ public interface BackupMethod {
      * @param backupName the backup name.
      * @return if the backup operation succeed.
      */
-    boolean backup(@NotNull String backupName, @NotNull String levelPath, @NotNull String backupSaveDirectory) throws IOException;
+    BackupResult backup(String backupName, String levelPath, String backupSaveDirectory) throws IOException;
+
+    boolean restore(String backupName, String levelPath, String backupSaveDirectory) throws IOException;
 
     BackupFileNameBuilder getBackupFileNameBuilder();
 
     BackupFileNameFormatter getBackupFileNameFormatter();
 
+    class BackupResult {
+        private final boolean success;
+        private final long backupSizeBytes;
+
+        public BackupResult(boolean success, long backupSizeBytes) {
+            this.success = success;
+            this.backupSizeBytes = backupSizeBytes;
+        }
+
+        public boolean isSuccess() {
+            return success;
+        }
+
+        public long getBackupSizeBytes() {
+            return backupSizeBytes;
+        }
+    }
 }
diff --git a/src/main/java/com/keuin/kbackupfabric/operation/backup/IncrementalBackupMethod.java b/src/main/java/com/keuin/kbackupfabric/operation/backup/IncrementalBackupMethod.java
new file mode 100644
index 0000000..4a87bb3
--- /dev/null
+++ b/src/main/java/com/keuin/kbackupfabric/operation/backup/IncrementalBackupMethod.java
@@ -0,0 +1,62 @@
+package com.keuin.kbackupfabric.operation.backup;
+
+import com.google.gson.JsonObject;
+import com.keuin.kbackupfabric.util.PrintUtil;
+import com.keuin.kbackupfabric.util.backup.builder.BackupFileNameBuilder;
+import com.keuin.kbackupfabric.util.backup.builder.ObjectTreeBackupFileNameBuilder;
+import com.keuin.kbackupfabric.util.backup.formatter.BackupFileNameFormatter;
+import com.keuin.kbackupfabric.util.backup.formatter.ObjectTreeBackupFileNameFormatter;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+
+public class IncrementalBackupMethod implements BackupMethod {
+
+    private static final IncrementalBackupMethod INSTANCE = new IncrementalBackupMethod();
+
+    public static IncrementalBackupMethod getInstance() {
+        return INSTANCE;
+    }
+
+    @Override
+    public BackupResult backup(String backupName, String levelPath, String backupSaveDirectory) throws IOException {
+        /*
+        1. Analyze the save directory, to get a json containing md5 values of all files.
+        2. Copy new files which we do not have in our backup repository.
+        3. Save the above json as a backup file. When restoring from this,
+           what we have to do is just copy all files back from the repository,
+           based on their md5 digests.
+         */
+
+        boolean success = true;
+        // Generate JSON
+        JsonObject hashJson = IncrementalBackupUtil.generateDirectoryJsonObject(levelPath);
+        // Copy files
+        long newFilesSizeBytes = IncrementalBackupUtil.saveNewFiles(backupSaveDirectory, levelPath, hashJson);
+        if(newFilesSizeBytes < 0) {
+            success = false;
+            PrintUtil.error("Failed to copy new files to object tree.");
+        }
+        // Save JSON tree
+        File jsonFile = new File(String.valueOf(Paths.get(backupSaveDirectory, BackupFileNameBuilder.objectTreeBackup().build(LocalDateTime.now(), backupName))));
+        // TODO
+        return new BackupResult(success, newFilesSizeBytes);
+    }
+
+    @Override
+    public boolean restore(String backupName, String levelPath, String backupSaveDirectory) throws IOException {
+        return false;
+    }
+
+    @Override
+    public BackupFileNameBuilder getBackupFileNameBuilder() {
+        return null;
+    }
+
+    @Override
+    public BackupFileNameFormatter getBackupFileNameFormatter() {
+        return null;
+    }
+}
diff --git a/src/main/java/com/keuin/kbackupfabric/operation/backup/IncrementalBackupUtil.java b/src/main/java/com/keuin/kbackupfabric/operation/backup/IncrementalBackupUtil.java
new file mode 100644
index 0000000..f90aef1
--- /dev/null
+++ b/src/main/java/com/keuin/kbackupfabric/operation/backup/IncrementalBackupUtil.java
@@ -0,0 +1,90 @@
+package com.keuin.kbackupfabric.operation.backup;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.keuin.kbackupfabric.util.FilesystemUtil;
+import org.apache.commons.codec.digest.DigestUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.*;
+import java.util.Map;
+
+public class IncrementalBackupUtil {
+    /**
+     * Generate a json object representing a directory and its all sub files and directories.
+     * @param path path to the directory.
+     * @return a json object.
+     */
+    public static JsonObject generateDirectoryJsonObject(String path) throws IOException {
+        JsonObject json = new JsonObject();
+        File directory = new File(path);
+        if (!(directory.isDirectory() && directory.exists()))
+            throw new IOException(String.format("Path %s is not a valid directory.", path));
+
+        // Iterate all sub files using BFS.
+        try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(Paths.get(path))) {
+            for (Path sub : directoryStream) {
+                if (sub.toFile().isFile()) {
+                    // A sub file
+                    // Just hash and add it as a string
+                    try (InputStream is = Files.newInputStream(sub)) {
+                        String md5 = org.apache.commons.codec.digest.DigestUtils.md5Hex(is);
+                        json.addProperty(sub.getFileName().toString(), md5);
+                    }
+                } else {
+                    // A sub directory
+                    // Search into
+                    json.addProperty(String.valueOf(sub.getFileName()), sub.toString());
+                }
+            }
+        }
+
+        return json;
+    }
+
+    /**
+     * Save new (or modified) files to target path, based on hash json.
+     * @param targetSavePath where we should save new files.
+     * @param sourcePath where new files come from. This path must be the base directory of given hash json.
+     * @param hashJson the json object obtained by calling generateDirectoryJsonObject method.
+     * @return total size of new files. If failed, will return -1.
+     */
+    public static long saveNewFiles(String targetSavePath, String sourcePath, JsonObject hashJson) throws IOException {
+        long bytesCopied = 0;
+        for (Map.Entry<String, JsonElement> entry : hashJson.entrySet()) {
+            String key = entry.getKey();
+            JsonElement value = entry.getValue();
+            if (value.isJsonPrimitive() && value.getAsJsonPrimitive().isString()) {
+                // A sub file
+                // key is file name
+                // value is file md5
+                String md5 = value.getAsJsonPrimitive().getAsString();
+                File saveTarget = new File(targetSavePath, md5);
+                if (!saveTarget.exists()) {
+                    // Target file does not exist. We have to copy this to the target.
+                    File sourceFile = new File(sourcePath, key);
+                    Files.copy(sourceFile.toPath(), saveTarget.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES);
+                    try {
+                        bytesCopied += sourceFile.length();
+                    } catch (SecurityException ignored) {
+                        // failed to get the file size. Just ignore this.
+                    }
+                }
+            } else if (value.isJsonObject()) {
+                // A sub directory
+                // key is directory name
+                // value is directory json object
+                // Go into
+                if(!value.isJsonObject())
+                    throw new IllegalArgumentException(String.format("Hash json contains illegal argument of a directory item: %s -> %s.", key, value));
+                Path pathSource = Paths.get(sourcePath, key);
+                bytesCopied += saveNewFiles(targetSavePath, pathSource.toString(), value.getAsJsonObject());
+            } else {
+                throw new IllegalArgumentException(String.format("Hash json contains illegal element: %s -> %s.", key, value));
+            }
+        }
+        return bytesCopied;
+    }
+}
diff --git a/src/main/java/com/keuin/kbackupfabric/operation/backup/PrimitiveBackupMethod.java b/src/main/java/com/keuin/kbackupfabric/operation/backup/PrimitiveBackupMethod.java
index bb1c8cb..854355d 100644
--- a/src/main/java/com/keuin/kbackupfabric/operation/backup/PrimitiveBackupMethod.java
+++ b/src/main/java/com/keuin/kbackupfabric/operation/backup/PrimitiveBackupMethod.java
@@ -2,6 +2,7 @@ package com.keuin.kbackupfabric.operation.backup;
 
 import com.keuin.kbackupfabric.exception.ZipUtilException;
 import com.keuin.kbackupfabric.metadata.BackupMetadata;
+import com.keuin.kbackupfabric.util.FilesystemUtil;
 import com.keuin.kbackupfabric.util.PrintUtil;
 import com.keuin.kbackupfabric.util.ZipUtil;
 import com.keuin.kbackupfabric.util.backup.builder.BackupFileNameBuilder;
@@ -9,14 +10,23 @@ import com.keuin.kbackupfabric.util.backup.formatter.BackupFileNameFormatter;
 
 import java.io.File;
 import java.io.IOException;
-import java.time.LocalDate;
+import java.nio.file.Paths;
 import java.time.LocalDateTime;
 
+import static org.apache.commons.io.FileUtils.forceDelete;
+
 public class PrimitiveBackupMethod implements BackupMethod {
+
+    private static final PrimitiveBackupMethod INSTANCE = new PrimitiveBackupMethod();
+
+    public static PrimitiveBackupMethod getInstance() {
+        return INSTANCE;
+    }
+
     @Override
-    public boolean backup(String backupName, String levelPath, String backupSaveDirectory) throws IOException {
+    public BackupResult backup(String backupName, String levelPath, String backupSaveDirectory) throws IOException {
+        String backupFileName = BackupFileNameBuilder.primitiveZipBackup().build(LocalDateTime.now(),backupName);
         try {
-            String backupFileName = BackupFileNameBuilder.primitiveZipBackup().build(LocalDateTime.now(),backupName);
             BackupMetadata backupMetadata = new BackupMetadata(System.currentTimeMillis(), backupName);
 
             PrintUtil.info(String.format("zip(srcPath=%s, destPath=%s)", levelPath, backupSaveDirectory));
@@ -25,8 +35,54 @@ public class PrimitiveBackupMethod implements BackupMethod {
 
         } catch (ZipUtilException exception) {
             PrintUtil.info("Infinite recursive of directory tree detected, backup was aborted.");
+            return new BackupResult(false, 0);
+        }
+
+        // Get backup file size and return
+        return new BackupResult(true, FilesystemUtil.getFileSizeBytes(backupSaveDirectory, backupFileName));
+    }
+
+    @Override
+    public boolean restore(String backupName, String levelDirectory, String backupSaveDirectory) throws IOException {
+        // Delete old level
+        PrintUtil.info("Server stopped. Deleting old level ...");
+        File levelDirFile = new File(levelDirectory);
+        long startTime = System.currentTimeMillis();
+
+        int failedCounter = 0;
+        final int MAX_RETRY_TIMES = 20;
+        while (failedCounter < MAX_RETRY_TIMES) {
+            System.gc();
+            if (!levelDirFile.delete() && levelDirFile.exists()) {
+                System.gc();
+                forceDelete(levelDirFile); // Try to force delete.
+            }
+            if (!levelDirFile.exists())
+                break;
+            ++failedCounter;
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException ignored) {
+            }
+        }
+        if (levelDirFile.exists()) {
+            PrintUtil.error(String.format("Cannot restore: failed to delete old level %s .", levelDirFile.getName()));
             return false;
         }
+
+        // TODO: Refactor this to the concrete BackupMethod.
+        // Decompress archive
+        PrintUtil.info("Decompressing archived level ...");
+        ZipUtil.unzip(Paths.get(backupSaveDirectory, backupName).toString(), levelDirectory, false);
+        long endTime = System.currentTimeMillis();
+        PrintUtil.info(String.format("Restore complete! (%.2fs) Please restart the server manually.", (endTime - startTime) / 1000.0));
+        PrintUtil.info("If you want to restart automatically after restoring, please visit the project manual at: https://github.com/keuin/KBackup-Fabric/blob/master/README.md");
+
+//        try {
+//            Thread.sleep(1000);
+//        } catch (InterruptedException ignored) {
+//        }
+
         return true;
     }
 
@@ -37,6 +93,6 @@ public class PrimitiveBackupMethod implements BackupMethod {
 
     @Override
     public BackupFileNameFormatter getBackupFileNameFormatter() {
-        return BFNF;
+        return BackupFileNameFormatter.primitiveZipBackup();
     }
 }