cf: copy files found in downloads that skipped download (#450)

Author: itzg

src/main/java/me/itzg/helpers/curseforge/CurseForgeInstaller.java

@@ -56,6 +56,7 @@
 import me.itzg.helpers.json.ObjectMappers;
 import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
 import org.apache.commons.compress.archivers.zip.ZipFile;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -800,17 +801,21 @@ private Mono<ResolveResult> downloadOrResolveFile(InstallContext context, CurseF
 
         // Will try to locate an existing file by alternate names that browser might create,
         // but only for non-world files of the modpack
-        final Path locatedFile = !isWorld ? locateFileIn(cfFile.getFileName(),
-            outputDir,
-            downloadsRepo
-        ) : null;
+        final Path locatedFile = !isWorld ?
+            locateFileIn(cfFile.getFileName(), outputDir)
+            : null;
 
         if (locatedFile != null) {
             log.info("Mod file {} already exists", locatedFile);
             return FileHashVerifier.verify(locatedFile, cfFile.getHashes())
                 .map(ResolveResult::new);
         }
         else {
+            final Path fileInRepo = locateModInRepo(cfFile.getFileName());
+            if (fileInRepo != null) {
+                return copyFromDownloadsRepo(outputFile, fileInRepo);
+            }
+
             return context.cfApi.download(cfFile, outputFile, modFileDownloadStatusHandler(this.outputDir, log))
                 .flatMap(path -> FileHashVerifier.verify(path, cfFile.getHashes()))
                 .map(ResolveResult::new)
@@ -837,22 +842,20 @@ private Mono<ResolveResult> handleFileNeedingManualDownload(CurseForgeMod modInf
             return Mono.just(new ResolveResult(outputFile).setDownloadNeeded(true));
         }
         else {
-            return Mono.just(resolved)
-                .publishOn(Schedulers.boundedElastic())
-                .flatMap(path -> {
-                    try {
-                        log.info("Mod file {} obtained from downloads repo",
-                            this.outputDir.relativize(outputFile)
-                        );
-                        //noinspection BlockingMethodInNonBlockingContext because IntelliJ is confused
-                        return Mono.just(Files.copy(resolved, outputFile));
-                    } catch (IOException e) {
-                        return Mono.error(new GenericException("Failed to copy file from downloads repo", e));
-                    }
+            return copyFromDownloadsRepo(outputFile, resolved);
+        }
+    }
 
+    private @NotNull Mono<ResolveResult> copyFromDownloadsRepo(Path outputFile, Path resolved) {
+        return
+            Mono.fromCallable(() -> {
+                    log.info("Mod file {} obtained from downloads repo",
+                        this.outputDir.relativize(outputFile)
+                    );
+                    return Files.copy(resolved, outputFile);
                 })
+                .subscribeOn(Schedulers.boundedElastic())
                 .map(ResolveResult::new);
-        }
     }
 
     private PathWithInfo extractWorldZip(CurseForgeMod modInfo, Path zipPath, Path worldsDir) {

src/main/java/me/itzg/helpers/files/Manifests.java

@@ -12,6 +12,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import lombok.extern.slf4j.Slf4j;
+import me.itzg.helpers.errors.GenericException;
 import me.itzg.helpers.json.ObjectMappers;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
@@ -90,9 +91,16 @@ public static List<String> relativizeAll(Path basePath, Path... paths) {
     public static List<String> relativizeAll(Path basePath, Stream<Path> pathStream) {
         return pathStream
             .filter(Objects::nonNull)
-            .map(p ->
-                basePath.relativize(p)
-                .toString()
+            .map(p -> {
+                    try {
+                        return basePath.relativize(p)
+                            .toString();
+                    } catch (IllegalArgumentException e) {
+                        throw new GenericException(String.format("Failed to relative %s against %s", p, basePath),
+                            e
+                        );
+                    }
+                }
             )
             .collect(Collectors.toList());
     }