Easier baselines

[simantics/platform.git] / bundles / org.simantics / src / org / simantics / DatabaseBaselines.java

diff --git a/bundles/org.simantics/src/org/simantics/DatabaseBaselines.java b/bundles/org.simantics/src/org/simantics/DatabaseBaselines.java
index fe3393a2c0afd6f7abb7eb522eb22086b9ed4d51..c58cb508623026fbf5f054cc67645e6d87d1db1a 100644 (file)
--- a/bundles/org.simantics/src/org/simantics/DatabaseBaselines.java
+++ b/bundles/org.simantics/src/org/simantics/DatabaseBaselines.java
@@ -1,5 +1,6 @@
 package org.simantics;
 
+import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -13,6 +14,7 @@ import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 import java.util.zip.ZipOutputStream;
 
+import org.eclipse.core.runtime.Platform;
 import org.simantics.utils.FileUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -32,8 +34,114 @@ public class DatabaseBaselines {
 
        private static final DateTimeFormatter TIMESTAMP_FORMAT = DateTimeFormatter.ofPattern("d. MMM yyyy HH:mm:ss");
 
-       public static Path packageBaseline(Path fromWorkspace, Path packageFile) throws IOException {
-               return compressZip(fromWorkspace, collectBaselinePaths(fromWorkspace), packageFile);
+    public static boolean handleBaselineDatabase(Path installLocation, boolean databaseExists) throws PlatformException {
+        Path workspaceLocation = Platform.getLocation().toFile().toPath();
+        Path baselineIndicatorFile = workspaceLocation.resolve(".baselined");
+        if (Files.isRegularFile(baselineIndicatorFile)) {
+            // This means that the workspace has already been initialized from
+            // a database baseline and further initialization is not necessary.
+            return true;
+        }
+
+        Path baseline = resolveBaselineFile(installLocation);
+        if (baseline == null) {
+            baseline = getAutomaticBaselinePath();
+            if(baseline == null)
+                return false;
+            if(databaseExists)
+                return false;
+            if(!existsAutomaticBaseline())
+                return false;
+        }
+        
+        DatabaseBaselines.validateBaselineFile(baseline);
+        DatabaseBaselines.validateWorkspaceForBaselineInitialization(workspaceLocation);
+        DatabaseBaselines.initializeWorkspaceWithBaseline(baseline, workspaceLocation, baselineIndicatorFile);
+        return true;
+        
+    }
+
+    private static Path resolveBaselineFile(Path installLocation) throws PlatformException {
+        String dbBaselineArchive = System.getProperty("org.simantics.db.baseline", null);
+        if (dbBaselineArchive == null)
+            return null;
+
+        Path baseline = Paths.get(dbBaselineArchive);
+        if (baseline.isAbsolute()) {
+            if (!Files.isRegularFile(baseline))
+                throw new PlatformException("Specified database baseline archive " + baseline
+                        + " does not exist. Cannot initialize workspace database from baseline.");
+            return baseline;
+        }
+
+        // Relative path resolution order:
+        // 1. from the platform "install location"
+        // 2. from working directory
+        //Path installLocation = tryGetInstallLocation();
+        if (installLocation != null) {
+            Path installedBaseline = installLocation.resolve(dbBaselineArchive);
+            if (Files.isRegularFile(installedBaseline))
+                return installedBaseline;
+        }
+        if (!Files.isRegularFile(baseline))
+            throw new PlatformException("Specified database baseline archive " + baseline
+                    + " does not exist in either the install location (" + installLocation
+                    + ") or the working directory (" + Paths.get(".").toAbsolutePath()
+                    + "). Cannot initialize workspace database.");
+        return null;
+    }
+
+    private static boolean useAutomaticBaseline() {
+        return getAutomaticBaselinePath() != null;
+    }
+
+    private static Path getAutomaticBaselinePath() {
+        if("true".equals(System.getProperty("org.simantics.db.baseline.automatic")))
+            return Paths.get("automatic_baseline", "baseline.zip");
+        else
+            return null;
+    }
+    
+    private static boolean existsAutomaticBaseline() {
+        Path baselineFile = getAutomaticBaselinePath();
+        if(baselineFile == null)
+            return false;
+        return Files.exists(baselineFile);
+    }
+
+    public static boolean shouldCreateAutomaticBaseline(boolean existsDatabase) throws PlatformException {
+        if(!useAutomaticBaseline()) {
+            // Are we using this feature? 
+            return false;
+        }
+        if(existsDatabase) {
+            // Baseline can only be created after db initialization
+            return false;
+        }
+        if(existsAutomaticBaseline()) {
+            // Existing baselines should not be automatically overridden
+            return false;
+        }
+        return true;
+    }
+
+    public static void createAutomaticBaseline(Path dbLocation) throws PlatformException {
+
+        if(existsAutomaticBaseline())
+            return;
+
+        try {
+            DatabaseBaselines.packageBaseline(dbLocation.getParent(), getAutomaticBaselinePath());
+        } catch (IOException e) {
+            LOGGER.error("Error while creating automatic baseline", e);
+        }
+
+    }
+
+    public static Path packageBaseline(Path fromWorkspace, Path packageFilePath) throws IOException {
+           File packageFile = packageFilePath.toFile();
+           packageFile.getParentFile().mkdirs();
+               return compressZip(fromWorkspace, collectBaselinePaths(fromWorkspace), packageFilePath);
        }
 
        private static List<Path> collectBaselinePaths(Path workspace) throws IOException {