Feature/installer backup api

core/archiver/build.gradle

@@ -0,0 +1,6 @@
+dependencies {
+    compile project(':core:base')
+    compile "net.lingala.zip4j:zip4j:2.5.0"
+
+    testCompile project(":core:base").sourceSets.test.output
+}

core/archiver/src/main/java/com/nubeiot/core/archiver/AbstractAsyncArchiver.java

@@ -0,0 +1,75 @@
+package com.nubeiot.core.archiver;
+
+import java.io.File;
+import java.nio.file.Path;
+
+import io.vertx.core.logging.Logger;
+import io.vertx.core.logging.LoggerFactory;
+
+import com.nubeiot.core.event.EventbusClient;
+
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+import net.lingala.zip4j.ZipFile;
+import net.lingala.zip4j.exception.ZipException;
+import net.lingala.zip4j.progress.ProgressMonitor;
+import net.lingala.zip4j.progress.ProgressMonitor.Result;
+import net.lingala.zip4j.progress.ProgressMonitor.State;
+
+@Getter
+@Accessors(fluent = true)
+@SuperBuilder
+public abstract class AbstractAsyncArchiver implements AsyncArchiver {
+
+    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @NonNull
+    private final EventbusClient transporter;
+    @NonNull
+    private final String notifiedAddress;
+
+    protected void execute(@NonNull ZipArgument argument, @NonNull File destFolder, @NonNull File originFile) {
+        try {
+            final ZipFile zipFile = createZipFile(argument, destFolder, originFile);
+            zipFile.setRunInThread(true);
+            run(argument, zipFile, destFolder, originFile);
+            transporter().getVertx()
+                         .setPeriodic(argument.watcherDelayInMilli(), id -> watch(id, argument, zipFile, originFile));
+        } catch (ZipException e) {
+            onError(argument, new IllegalArgumentException(e));
+        }
+    }
+
+    protected abstract ZipFile createZipFile(@NonNull ZipArgument argument, @NonNull File destination,
+                                             @NonNull File originFile);
+
+    protected abstract void run(@NonNull ZipArgument argument, @NonNull ZipFile zipFile, @NonNull File destination,
+                                @NonNull File originFile) throws ZipException;
+
+    protected void watch(long timerId, @NonNull ZipArgument argument, @NonNull ZipFile zipFile,
+                         @NonNull File originFile) {
+        final ProgressMonitor progressMonitor = zipFile.getProgressMonitor();
+        final Path path = zipFile.getFile().toPath();
+        if (progressMonitor.getState().equals(State.BUSY)) {
+            logger.debug("{} {} | Progress: {}% | Current file: {} | Current task: {}", action(), path,
+                         progressMonitor.getPercentDone(), progressMonitor.getFileName(),
+                         progressMonitor.getCurrentTask());
+            return;
+        }
+        transporter().getVertx().cancelTimer(timerId);
+        final Result result = progressMonitor.getResult();
+        if (result == Result.SUCCESS) {
+            onSuccess(createOutput(argument, zipFile, progressMonitor, originFile));
+            return;
+        }
+        onError(argument, new IllegalArgumentException(progressMonitor.getException()));
+    }
+
+    protected abstract String action();
+
+    protected abstract ZipOutput createOutput(@NonNull ZipArgument argument, @NonNull ZipFile zipFile,
+                                              @NonNull ProgressMonitor progressMonitor, @NonNull File originFile);
+
+}

core/archiver/src/main/java/com/nubeiot/core/archiver/AsyncArchiver.java

@@ -0,0 +1,77 @@
+package com.nubeiot.core.archiver;
+
+import java.nio.file.Path;
+
+import com.nubeiot.core.component.EventClientProxy;
+import com.nubeiot.core.event.EventAction;
+import com.nubeiot.core.event.EventMessage;
+
+import lombok.NonNull;
+
+/**
+ * Represents Async archvier.
+ *
+ * @since 1.0.0
+ */
+public interface AsyncArchiver extends EventClientProxy {
+
+    /**
+     * The constant EXT_ZIP_FILE.
+     */
+    String EXT_ZIP_FILE = ".zip";
+
+    /**
+     * Appends {@code ext} in file name.
+     *
+     * @param fileName the file name
+     * @return the string
+     * @since 1.0.0
+     */
+    @NonNull
+    static String ext(@NonNull String fileName) {
+        return fileName + EXT_ZIP_FILE;
+    }
+
+    /**
+     * Appends {@code ext} in file name.
+     *
+     * @param fileName the file name
+     * @return the string
+     * @since 1.0.0
+     */
+    @NonNull
+    static String ext(@NonNull Path fileName) {
+        return ext(fileName.toString());
+    }
+
+    /**
+     * Notified address string.
+     *
+     * @return the string
+     * @since 1.0.0
+     */
+    @NonNull String notifiedAddress();
+
+    /**
+     * On success.
+     *
+     * @param information the information
+     * @since 1.0.0
+     */
+    default void onSuccess(@NonNull ZipOutput information) {
+        transporter().publish(notifiedAddress(), EventMessage.success(EventAction.NOTIFY, information.toJson()));
+    }
+
+    /**
+     * On error.
+     *
+     * @param argument  the argument
+     * @param throwable the throwable
+     * @since 1.0.0
+     */
+    default void onError(@NonNull ZipArgument argument, @NonNull Throwable throwable) {
+        transporter().publish(notifiedAddress(),
+                              EventMessage.error(EventAction.NOTIFY_ERROR, throwable, argument.trackingInfo()));
+    }
+
+}

core/archiver/src/main/java/com/nubeiot/core/archiver/AsyncUnzip.java

@@ -0,0 +1,31 @@
+package com.nubeiot.core.archiver;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import com.nubeiot.core.utils.FileUtils;
+import com.nubeiot.core.utils.Strings;
+
+import lombok.NonNull;
+
+public interface AsyncUnzip extends AsyncArchiver {
+
+    default void extract(@NonNull ZipArgument argument, @NonNull String destFolder, @NonNull String zipFile) {
+        extract(argument, Paths.get(destFolder), Paths.get(zipFile));
+    }
+
+    default void extract(@NonNull ZipArgument argument, @NonNull Path destFolder, @NonNull Path zipFile) {
+        extract(argument, destFolder.toFile(), zipFile.toFile());
+    }
+
+    void extract(@NonNull ZipArgument argument, @NonNull File destFolder, @NonNull File zipFile);
+
+    default String computeExtractedFolder(@NonNull ZipArgument argument, @NonNull File zippedFile) {
+        if (Strings.isNotBlank(argument.overriddenDestFileName())) {
+            return argument.overriddenDestFileName();
+        }
+        return FileUtils.withoutExtension(zippedFile.toPath().getFileName().toString());
+    }
+
+}

core/archiver/src/main/java/com/nubeiot/core/archiver/AsyncZip.java

@@ -0,0 +1,64 @@
+package com.nubeiot.core.archiver;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import com.nubeiot.core.utils.DateTimes;
+import com.nubeiot.core.utils.Strings;
+
+import lombok.NonNull;
+
+/**
+ * Represents Async zip.
+ *
+ * @since 1.0.0
+ */
+public interface AsyncZip extends AsyncArchiver {
+
+    /**
+     * Do zip folder.
+     *
+     * @param argument   the argument
+     * @param destFolder the dest folder
+     * @param tobeZipped the tobe zipped
+     * @see ZipArgument
+     * @since 1.0.0
+     */
+    default void zip(@NonNull ZipArgument argument, @NonNull String destFolder, @NonNull String tobeZipped) {
+        zip(argument, Paths.get(destFolder), Paths.get(tobeZipped));
+    }
+
+    /**
+     * Do zip folder.
+     *
+     * @param argument   the argument
+     * @param destFolder the dest folder
+     * @param tobeZipped the tobe zipped
+     * @see ZipArgument
+     * @since 1.0.0
+     */
+    default void zip(@NonNull ZipArgument argument, @NonNull Path destFolder, @NonNull Path tobeZipped) {
+        zip(argument, destFolder.toFile(), tobeZipped.toFile());
+    }
+
+    /**
+     * Do zip folder.
+     *
+     * @param argument   the argument
+     * @param destFolder the dest folder
+     * @param tobeZipped the tobe zipped
+     * @see ZipArgument
+     * @since 1.0.0
+     */
+    void zip(@NonNull ZipArgument argument, @NonNull File destFolder, @NonNull File tobeZipped);
+
+    default String computeZipName(@NonNull ZipArgument argument, @NonNull File toZippedFile) {
+        if (Strings.isNotBlank(argument.overriddenDestFileName())) {
+            return AsyncArchiver.ext(argument.overriddenDestFileName());
+        }
+        final String fileName = toZippedFile.toPath().getFileName().toString();
+        return AsyncArchiver.ext(fileName + (argument.appendTimestamp() ? "-" + DateTimes.nowMilli() : ""));
+    }
+
+}

core/archiver/src/main/java/com/nubeiot/core/archiver/AsyncZipFolder.java

@@ -0,0 +1,51 @@
+package com.nubeiot.core.archiver;
+
+import java.io.File;
+
+import com.nubeiot.core.utils.ExecutorHelpers;
+
+import lombok.NonNull;
+import lombok.experimental.SuperBuilder;
+import net.lingala.zip4j.ZipFile;
+import net.lingala.zip4j.exception.ZipException;
+import net.lingala.zip4j.progress.ProgressMonitor;
+
+@SuperBuilder
+public final class AsyncZipFolder extends AbstractAsyncArchiver implements AsyncZip {
+
+    @Override
+    public void zip(@NonNull ZipArgument argument, @NonNull File destFolder, @NonNull File tobeZipped) {
+        ExecutorHelpers.blocking(transporter().getVertx(), () -> execute(argument, destFolder, tobeZipped));
+    }
+
+    @Override
+    protected ZipFile createZipFile(@NonNull ZipArgument argument, @NonNull File destination,
+                                    @NonNull File originFile) {
+        return new ZipFile(destination.toPath().resolve(computeZipName(argument, originFile)).toString(),
+                           argument.toPassword());
+    }
+
+    @Override
+    protected void run(@NonNull ZipArgument argument, ZipFile zipFile, @NonNull File destination,
+                       @NonNull File originFile) throws ZipException {
+        zipFile.addFolder(originFile, argument.zipParameters());
+    }
+
+    @Override
+    protected String action() {
+        return "Compressing";
+    }
+
+    @Override
+    protected ZipOutput createOutput(@NonNull ZipArgument argument, @NonNull ZipFile zipFile,
+                                     @NonNull ProgressMonitor progressMonitor, @NonNull File originFile) {
+        return ZipOutput.builder()
+                        .inputPath(originFile.getPath())
+                        .outputPath(zipFile.getFile().toString())
+                        .size(zipFile.getFile().length())
+                        .lastModified(zipFile.getFile().lastModified())
+                        .trackingInfo(argument.trackingInfo())
+                        .build();
+    }
+
+}

core/archiver/src/main/java/com/nubeiot/core/archiver/DefaultAsyncUnzip.java

@@ -0,0 +1,51 @@
+package com.nubeiot.core.archiver;
+
+import java.io.File;
+import java.nio.file.Paths;
+
+import com.nubeiot.core.utils.ExecutorHelpers;
+
+import lombok.NonNull;
+import lombok.experimental.SuperBuilder;
+import net.lingala.zip4j.ZipFile;
+import net.lingala.zip4j.exception.ZipException;
+import net.lingala.zip4j.progress.ProgressMonitor;
+
+@SuperBuilder
+public final class DefaultAsyncUnzip extends AbstractAsyncArchiver implements AsyncUnzip {
+
+    @Override
+    public void extract(@NonNull ZipArgument argument, @NonNull File destFolder, @NonNull File zipFile) {
+        ExecutorHelpers.blocking(transporter().getVertx(), () -> execute(argument, destFolder, zipFile));
+    }
+
+    @Override
+    protected ZipFile createZipFile(@NonNull ZipArgument argument, @NonNull File destination,
+                                    @NonNull File originFile) {
+        return new ZipFile(originFile, argument.toPassword());
+    }
+
+    @Override
+    protected void run(@NonNull ZipArgument argument, @NonNull ZipFile zipFile, @NonNull File destination,
+                       @NonNull File originFile) throws ZipException {
+        zipFile.extractAll(destination.toPath().resolve(computeExtractedFolder(argument, originFile)).toString());
+    }
+
+    @Override
+    protected String action() {
+        return "Extracting";
+    }
+
+    @Override
+    protected ZipOutput createOutput(@NonNull ZipArgument argument, @NonNull ZipFile zipFile,
+                                     @NonNull ProgressMonitor progressMonitor, @NonNull File originFile) {
+        final File outputFile = Paths.get(progressMonitor.getFileName()).getParent().toFile();
+        return ZipOutput.builder()
+                        .inputPath(originFile.getPath())
+                        .outputPath(outputFile.getPath())
+                        .lastModified(outputFile.lastModified())
+                        .trackingInfo(argument.trackingInfo())
+                        .build();
+    }
+
+}