Working on implementation of parent retrieval on demand

Author: AlexanderSchultheiss

pom.xml

@@ -118,5 +118,10 @@
             <artifactId>kconfigreader</artifactId>
             <version>1.0.0</version>
         </dependency>
+        <dependency>
+            <groupId>net.lingala.zip4j</groupId>
+            <artifactId>zip4j</artifactId>
+            <version>2.9.0</version>
+        </dependency>
     </dependencies>
 </project>

src/main/java/de/variantsync/evolution/io/data/VariabilityDatasetLoader.java

@@ -7,7 +7,10 @@
 import de.variantsync.evolution.variability.SPLCommit;
 import de.variantsync.evolution.variability.SPLCommit.*;
 import de.variantsync.evolution.variability.VariabilityDataset;
+import net.lingala.zip4j.ZipFile;
+import net.lingala.zip4j.exception.ZipException;
 
+import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -104,6 +107,7 @@ public Result<VariabilityDataset, Exception> load(final Path p) {
             }
         }
         Logger.info("Done.");
+        Logger.info("Found a total of " + idToCommitMap.size() + " commits.");
         // Return the fully-loaded dataset
         return Result.Success(new VariabilityDataset(successCommits, errorCommits, partialSuccessCommits));
     }
@@ -154,15 +158,29 @@ private FilterCountsPath resolvePathToFilterCountsFile(final Path rootDir, final
 
     private String[] loadParentIds(final Path p, final String commitId) {
         final Path parentsFile = resolvePathToParentsFile(p, commitId);
-        if (parentsFile != null && Files.exists(parentsFile)) {
-            try {
-                return Files.readString(parentsFile).split("\\s");
-            } catch (final IOException e) {
-                Logger.error("Was not able to load PARENTS.txt " + parentsFile + " even though it exists:", e);
-                return null;
+        if (parentsFile != null) {
+            if (!Files.exists(parentsFile)) {
+                Logger.info("No PARENTS.txt found, checking archive....");
+                final File zipFile = new File(parentsFile.getParent() + ".zip");
+                Logger.info("Checking ZIP file " + zipFile);
+                if (zipFile.exists()) {
+                    try {
+                        Logger.info("Unzipping PARENTS.txt");
+                        new ZipFile(zipFile).extractFile("PARENTS.txt", String.valueOf(parentsFile.getParent()));
+                    } catch (final ZipException e) {
+                        Logger.error("Was not able to unzip commit data.", e);
+                    }
+                }
+            }
+            if (Files.exists(parentsFile)) {
+                try {
+                    return Files.readString(parentsFile).split("\\s");
+                } catch (final IOException e) {
+                    Logger.error("Was not able to load PARENTS.txt " + parentsFile + " even though it exists:", e);
+                    return null;
+                }
             }
-        } else {
-            return null;
         }
+        return null;
     }
 }

src/main/java/de/variantsync/evolution/util/functional/Functional.java

@@ -123,4 +123,20 @@ public static <Nullable, B, E extends Exception> Optional<B> mapFragile(final Nu
     public static <A, B, E extends Exception> Lazy<Optional<B>> mapFragileLazily(final A a, final FragileFunction<A, B, E> f, final Supplier<String> errorMessage) {
         return Lazy.of(() -> mapFragile(a, f, errorMessage));
     }
+
+    /**
+     * Chains two fragile functions. The chained function first applies f1 to a given input, and then applies f2 to the 
+     * output of f1 (i.e., given an input x the chained function corresponds to f2(f1(x)))
+     * @param f1 The inner function
+     * @param f2 The outer function
+     * @param <Input> The input type of the inner function
+     * @param <Intermediate> The input type of the outer function and the return type of the inner function
+     * @param <Output> The return type of the outer function
+     * @return A new FragileFunction f2(f1(x))
+     */
+    public static <Input, Intermediate, Output> FragileFunction<Input, Output, Exception> chainFragile(
+            final FragileFunction<Input, Intermediate, Exception> f1, 
+            final FragileFunction<Intermediate, Output, Exception> f2) {
+        return (Input input) -> f2.run(f1.run(input));
+    }
 }

src/main/java/de/variantsync/evolution/variability/SPLCommit.java

@@ -8,6 +8,8 @@
 import de.variantsync.evolution.util.io.TypedPath;
 import de.variantsync.evolution.variability.pc.Artefact;
 import de.variantsync.evolution.variability.pc.EFilterOutcome;
+import net.lingala.zip4j.ZipFile;
+import net.lingala.zip4j.exception.ZipException;
 
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -16,27 +18,18 @@
 import java.util.Optional;
 
 public class SPLCommit extends Commit {
-    public record KernelHavenLogPath(Path path) implements TypedPath {}
-    public record FeatureModelPath(Path path) implements TypedPath {}
-    public record PresenceConditionPath(Path path) implements TypedPath {}
-    public record CommitMessagePath(Path path) implements TypedPath {}
-    public record FilterCountsPath(Path path) implements TypedPath {}
-
     private final Lazy<Optional<String>> kernelHavenLog;
     private final Lazy<Optional<IFeatureModel>> featureModel;
     private final Lazy<Optional<Artefact>> presenceConditions;
     private final Lazy<Optional<String>> message;
     private final Lazy<Optional<Map<EFilterOutcome, Integer>>> filterCounts;
-
     private final Path kernelHavenLogPath;
     private final Path featureModelPath;
     private final Path presenceConditionsPath;
     private final Path commitMessagePath;
     private final Path filterCountsPath;
-
     private SPLCommit[] parents;
 
-
     /**
      * Constructor for commits that should only contain information about the commit id.
      *
@@ -52,8 +45,7 @@ public SPLCommit(
             final FeatureModelPath featureModel,
             final PresenceConditionPath presenceConditions,
             final CommitMessagePath commitMessage,
-            final FilterCountsPath filterCounts)
-    {
+            final FilterCountsPath filterCounts) {
         super(commitId);
 
         this.kernelHavenLogPath = TypedPath.unwrapNullable(kernelHavenLog);
@@ -65,34 +57,44 @@ public SPLCommit(
         // Lazy loading of log file
         this.kernelHavenLog = Functional.mapFragileLazily(
                 kernelHavenLogPath,
-                Files::readString,
+                Functional.chainFragile(SPLCommit::tryUnzip, Files::readString),
                 () -> "Was not able to load KernelHaven log for commit " + commitId);
         // Lazy loading of feature model
         this.featureModel = Functional.mapFragileLazily(
                 featureModelPath,
-                p -> Resources.Instance().load(IFeatureModel.class, p),
+                Functional.chainFragile(SPLCommit::tryUnzip, path -> Resources.Instance().load(IFeatureModel.class, path)),
                 () -> "Was not able to load feature model for id " + commitId);
         // Lazy loading of presence condition
         this.presenceConditions = Functional.mapFragileLazily(
                 presenceConditionsPath,
-                path -> Resources.Instance().load(Artefact.class, path),
+                Functional.chainFragile(SPLCommit::tryUnzip, path -> Resources.Instance().load(Artefact.class, path)),
                 () -> "Was not able to load presence conditions for id " + commitId);
         // Lazy loading of commit message
         this.message = Functional.mapFragileLazily(
                 commitMessagePath,
-                Files::readString,
+                Functional.chainFragile(SPLCommit::tryUnzip, Files::readString),
                 () -> "Was not able to load commit message for id " + commitId);
         // Lazy loading of filter counts
         this.filterCounts = Functional.mapFragileLazily(
                 filterCountsPath,
-                path -> {
+                Functional.chainFragile(SPLCommit::tryUnzip, path -> {
                     final Map<EFilterOutcome, Integer> countsMap = new HashMap<>();
                     Files.readAllLines(path).stream().map(l -> l.split(":")).forEach(parts -> countsMap.put(EFilterOutcome.valueOf(parts[0]), Integer.parseInt(parts[1].trim())));
                     return countsMap;
-                },
+                }),
                 () -> "Was not able to load filter counts for id " + commitId);
     }
 
+    private static Path tryUnzip(final Path path) throws ZipException {
+        if (!Files.exists(path)) {
+            final Path zippedParent = Path.of(path.getParent().toString() + ".zip");
+            if (Files.exists(zippedParent)) {
+                new ZipFile(zippedParent.toFile()).extractAll(String.valueOf(path.getParent()));
+            }
+        }
+        return path;
+    }
+
     /**
      * Return the parents of this commit. As the dataset only contains the data about non-error commits,
      * not all <code>SPLCommit</code> objects are associated with their parents. Therefore, an <code>Optional</code> is returned.
@@ -161,4 +163,19 @@ public Path getCommitMessagePath() {
     public Path getFilterCountsPath() {
         return filterCountsPath;
     }
+
+    public record KernelHavenLogPath(Path path) implements TypedPath {
+    }
+
+    public record FeatureModelPath(Path path) implements TypedPath {
+    }
+
+    public record PresenceConditionPath(Path path) implements TypedPath {
+    }
+
+    public record CommitMessagePath(Path path) implements TypedPath {
+    }
+
+    public record FilterCountsPath(Path path) implements TypedPath {
+    }
 }