Fixed unzipping of SPLCommit-related variability data.

Author: AlexanderSchultheiss

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

@@ -116,7 +116,14 @@ private List<SPLCommit> initializeSPLCommits(final Path p, final List<String> co
         final List<SPLCommit> splCommits = new ArrayList<>(commitIds.size());
         for (final String id : commitIds) {
             // Initialize a SPLCommit object for each commit id by resolving all paths to files with data about the commit
-            final SPLCommit splCommit = new SPLCommit(id, resolvePathToLogFile(p, id), resolvePathToFeatureModel(p, id), resolvePathToPresenceConditions(p, id), resolvePathToMessageFile(p, id), resolvePathToFilterCountsFile(p, id));
+            final SPLCommit splCommit = new SPLCommit(
+                    id, 
+                    resolvePathToCommitOutputDir(p, id), 
+                    resolvePathToLogFile(p, id), 
+                    resolvePathToFeatureModel(p, id), 
+                    resolvePathToPresenceConditions(p, id), 
+                    resolvePathToMessageFile(p, id), 
+                    resolvePathToFilterCountsFile(p, id));
             splCommits.add(splCommit);
         }
         return splCommits;
@@ -128,59 +135,56 @@ private Path resolvePathToCommitOutputDir(final Path rootDir, final String commi
 
     private FeatureModelPath resolvePathToFeatureModel(final Path rootDir, final String commitId) {
         final Path p = resolvePathToCommitOutputDir(rootDir, commitId).resolve(FEATURE_MODEL_FILE);
-        return p.toFile().exists() ? new FeatureModelPath(p) : null;
+        return new FeatureModelPath(p);
     }
 
     private PresenceConditionPath resolvePathToPresenceConditions(final Path rootDir, final String commitId) {
         final Path p = resolvePathToCommitOutputDir(rootDir, commitId).resolve(PRESENCE_CONDITIONS_FILE);
-        return p.toFile().exists() ? new PresenceConditionPath(p) : null;
+        return new PresenceConditionPath(p);
     }
 
     private Path resolvePathToParentsFile(final Path rootDir, final String commitId) {
-        final Path p = resolvePathToCommitOutputDir(rootDir, commitId).resolve(PARENTS_FILE);
-        return p.toFile().exists() ? p : null;
+        return resolvePathToCommitOutputDir(rootDir, commitId).resolve(PARENTS_FILE);
     }
 
     private CommitMessagePath resolvePathToMessageFile(final Path rootDir, final String commitId) {
         final Path p = resolvePathToCommitOutputDir(rootDir, commitId).resolve(MESSAGE_FILE);
-        return p.toFile().exists() ? new CommitMessagePath(p) : null;
+        return new CommitMessagePath(p);
     }
 
     private KernelHavenLogPath resolvePathToLogFile(final Path rootDir, final String commitId) {
         final Path p = rootDir.resolve(LOG_DIR_NAME).resolve(commitId + ".log");
-        return p.toFile().exists() ? new KernelHavenLogPath(p) : null;
+        return new KernelHavenLogPath(p);
     }
 
     private FilterCountsPath resolvePathToFilterCountsFile(final Path rootDir, final String commitId) {
         final Path p = resolvePathToCommitOutputDir(rootDir, commitId).resolve(FILTER_COUNTS_FILE);
-        return p.toFile().exists() ? new FilterCountsPath(p) : null;
+        return new FilterCountsPath(p);
     }
 
     private String[] loadParentIds(final Path p, final String commitId) {
         final Path parentsFile = resolvePathToParentsFile(p, commitId);
-        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)) {
+        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 {
-                    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;
+                    Logger.info("Unzipping PARENTS.txt");
+                    new ZipFile(zipFile).extractFile(commitId + "/PARENTS.txt", String.valueOf(resolvePathToCommitOutputDir(p, commitId).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;
+            }
+        }
         return null;
     }
 }

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

@@ -3,8 +3,10 @@
 import de.ovgu.featureide.fm.core.base.IFeatureModel;
 import de.variantsync.evolution.io.Resources;
 import de.variantsync.evolution.repository.Commit;
+import de.variantsync.evolution.util.Logger;
 import de.variantsync.evolution.util.functional.Functional;
 import de.variantsync.evolution.util.functional.Lazy;
+import de.variantsync.evolution.util.functional.interfaces.FragileFunction;
 import de.variantsync.evolution.util.io.TypedPath;
 import de.variantsync.evolution.variability.pc.Artefact;
 import de.variantsync.evolution.variability.pc.EFilterOutcome;
@@ -23,6 +25,7 @@ public class SPLCommit extends Commit {
     private final Lazy<Optional<Artefact>> presenceConditions;
     private final Lazy<Optional<String>> message;
     private final Lazy<Optional<Map<EFilterOutcome, Integer>>> filterCounts;
+    private final Path dataDir;
     private final Path kernelHavenLogPath;
     private final Path featureModelPath;
     private final Path presenceConditionsPath;
@@ -36,48 +39,52 @@ public class SPLCommit extends Commit {
      * @param commitId The id of the commit
      */
     public SPLCommit(final String commitId) {
-        this(commitId, null, null, null, null, null);
+        this(commitId, null, null, null, null, null, null);
     }
 
     public SPLCommit(
             final String commitId,
+            final Path dataDir,
             final KernelHavenLogPath kernelHavenLog,
             final FeatureModelPath featureModel,
             final PresenceConditionPath presenceConditions,
             final CommitMessagePath commitMessage,
             final FilterCountsPath filterCounts) {
         super(commitId);
+        this.dataDir = dataDir;
 
         this.kernelHavenLogPath = TypedPath.unwrapNullable(kernelHavenLog);
         this.featureModelPath = TypedPath.unwrapNullable(featureModel);
         this.presenceConditionsPath = TypedPath.unwrapNullable(presenceConditions);
         this.commitMessagePath = TypedPath.unwrapNullable(commitMessage);
         this.filterCountsPath = TypedPath.unwrapNullable(filterCounts);
 
+        final FragileFunction<Path, Path, ZipException> tryUnzip = SPLCommit::tryUnzip;
+
         // Lazy loading of log file
         this.kernelHavenLog = Functional.mapFragileLazily(
                 kernelHavenLogPath,
-                Functional.chainFragile(SPLCommit::tryUnzip, Files::readString),
+                tryUnzip.andThen(Files::readString),
                 () -> "Was not able to load KernelHaven log for commit " + commitId);
         // Lazy loading of feature model
         this.featureModel = Functional.mapFragileLazily(
                 featureModelPath,
-                Functional.chainFragile(SPLCommit::tryUnzip, path -> Resources.Instance().load(IFeatureModel.class, path)),
+                tryUnzip.andThen(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,
-                Functional.chainFragile(SPLCommit::tryUnzip, path -> Resources.Instance().load(Artefact.class, path)),
+                tryUnzip.andThen(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,
-                Functional.chainFragile(SPLCommit::tryUnzip, Files::readString),
+                tryUnzip.andThen(Files::readString),
                 () -> "Was not able to load commit message for id " + commitId);
         // Lazy loading of filter counts
         this.filterCounts = Functional.mapFragileLazily(
                 filterCountsPath,
-                Functional.chainFragile(SPLCommit::tryUnzip, path -> {
+                tryUnzip.andThen(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;
@@ -87,10 +94,22 @@ public SPLCommit(
 
     private static Path tryUnzip(final Path path) throws ZipException {
         if (!Files.exists(path)) {
-            final Path zippedParent = Path.of(path.getParent().toString() + ".zip");
+            final Path zippedParent = Path.of(path.getParent() + ".zip");
+            Logger.debug("Checking whether there is an archive " + zippedParent);
             if (Files.exists(zippedParent)) {
-                new ZipFile(zippedParent.toFile()).extractAll(String.valueOf(path.getParent()));
+                Logger.debug("Archive " + zippedParent.getFileName() + " found.");
+                try {
+                    new ZipFile(zippedParent.toFile()).extractAll(String.valueOf(zippedParent.getParent()));
+                } catch (final ZipException e) {
+                    Logger.error("Was not able to unzip " + zippedParent, e);
+                    throw e;
+                }
+            } else {
+                Logger.warning("Path " + path + " does not exist and no ZIP file found.");
+                return null;
             }
+        } else {
+            Logger.debug("Path " + path + " exists. No unzip required.");
         }
         return path;
     }
@@ -144,6 +163,10 @@ public Lazy<Optional<Map<EFilterOutcome, Integer>>> filterCounts() {
         return filterCounts;
     }
 
+    public Path getCommitDataDirectory() {
+        return dataDir;
+    }
+
     public Path getKernelHavenLogPath() {
         return kernelHavenLogPath;
     }
@@ -165,17 +188,22 @@ public Path getFilterCountsPath() {
     }
 
     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 {
+
     }
 }