move prewarm to remotechecksumcalculator

Author: LogFlames

maven_plugin/src/main/java/io/github/chains_project/maven_lockfile/checksum/AbstractChecksumCalculator.java

@@ -5,6 +5,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.security.MessageDigest;
+import java.util.Collection;
 import java.util.Locale;
 import org.apache.maven.artifact.Artifact;
 
@@ -37,6 +38,14 @@ public String getChecksumAlgorithm() {
 
     public abstract RepositoryInformation getPluginResolvedField(Artifact artifact);
 
+    /**
+     * Pre-warm internal caches for the given artifacts. Implementations may use this
+     * to fetch checksums and repository information in parallel. The default is a no-op.
+     */
+    public void prewarmArtifactCache(Collection<Artifact> artifacts) {
+        // No-op by default; overridden by RemoteChecksumCalculator
+    }
+
     public String calculatePomChecksum(Path path) {
         try {
             MessageDigest messageDigest = MessageDigest.getInstance(checksumAlgorithm);

maven_plugin/src/main/java/io/github/chains_project/maven_lockfile/checksum/RemoteChecksumCalculator.java

@@ -9,10 +9,16 @@
 import java.net.http.HttpRequest;
 import java.net.http.HttpResponse;
 import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.repository.ArtifactRepository;
 import org.apache.maven.project.ProjectBuildingRequest;
@@ -223,6 +229,37 @@ private Optional<RepositoryInformation> getResolvedFieldInternal(
         }
     }
 
+    @Override
+    public void prewarmArtifactCache(Collection<Artifact> artifacts) {
+        if (artifacts.isEmpty()) {
+            return;
+        }
+        int poolSize = Math.min(16, Math.max(4, Runtime.getRuntime().availableProcessors() * 2));
+        PluginLogManager.getLog()
+                .info(String.format(
+                        "Pre-warming checksum cache for %d unique artifacts with %d threads",
+                        artifacts.size(), poolSize));
+        ExecutorService executor = Executors.newFixedThreadPool(poolSize);
+        try {
+            List<Future<?>> futures = new ArrayList<>();
+            for (var artifact : artifacts) {
+                futures.add(executor.submit(() -> {
+                    calculateArtifactChecksum(artifact);
+                    getArtifactResolvedField(artifact);
+                }));
+            }
+            for (var future : futures) {
+                try {
+                    future.get();
+                } catch (Exception e) {
+                    PluginLogManager.getLog().debug("Pre-warm task failed: " + e.getMessage());
+                }
+            }
+        } finally {
+            executor.shutdown();
+        }
+    }
+
     @Override
     public String calculateArtifactChecksum(Artifact artifact) {
         return calculateChecksumInternal(artifact, artifactBuildingRequest).orElse("");

maven_plugin/src/main/java/io/github/chains_project/maven_lockfile/graph/DependencyGraph.java

@@ -12,10 +12,8 @@
 import io.github.chains_project.maven_lockfile.data.VersionNumber;
 import io.github.chains_project.maven_lockfile.reporting.PluginLogManager;
 import java.util.*;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
 import java.util.stream.Collectors;
+import org.apache.maven.artifact.Artifact;
 import org.apache.maven.shared.dependency.graph.internal.SpyingDependencyNodeUtils;
 
 public class DependencyGraph {
@@ -67,43 +65,20 @@ public static DependencyGraph of(
                 .filter(it -> graph.predecessors(it).isEmpty())
                 .collect(Collectors.toList());
 
-        // Pre-warm checksum cache in parallel for I/O-bound remote fetching
-        var nonRootNodes = graph.nodes().stream()
-                .filter(it -> !graph.predecessors(it).isEmpty())
-                .collect(Collectors.toList());
+        // Collect unique non-root artifacts and let the calculator pre-warm its cache
         Set<String> seen = new HashSet<>();
-        List<org.apache.maven.shared.dependency.graph.DependencyNode> uniqueNodes = new ArrayList<>();
-        for (var node : nonRootNodes) {
-            var a = node.getArtifact();
-            String key = a.getGroupId() + ":" + a.getArtifactId() + ":" + a.getVersion() + ":"
-                    + (a.getClassifier() != null ? a.getClassifier() : "") + ":" + a.getType();
-            if (seen.add(key)) {
-                uniqueNodes.add(node);
-            }
-        }
-        if (!uniqueNodes.isEmpty()) {
-            int poolSize = Math.min(16, Math.max(4, Runtime.getRuntime().availableProcessors() * 2));
-            PluginLogManager.getLog()
-                    .info(String.format(
-                            "Pre-warming checksum cache for %d unique artifacts with %d threads",
-                            uniqueNodes.size(), poolSize));
-            ExecutorService executor = Executors.newFixedThreadPool(poolSize);
-            List<Future<?>> futures = new ArrayList<>();
-            for (var node : uniqueNodes) {
-                futures.add(executor.submit(() -> {
-                    calc.calculateArtifactChecksum(node.getArtifact());
-                    calc.getArtifactResolvedField(node.getArtifact());
-                }));
-            }
-            for (var future : futures) {
-                try {
-                    future.get();
-                } catch (Exception e) {
-                    PluginLogManager.getLog().debug("Pre-warm task failed: " + e.getMessage());
+        List<Artifact> uniqueArtifacts = new ArrayList<>();
+        for (var node : graph.nodes()) {
+            if (!graph.predecessors(node).isEmpty()) {
+                var a = node.getArtifact();
+                String key = a.getGroupId() + ":" + a.getArtifactId() + ":" + a.getVersion() + ":"
+                        + (a.getClassifier() != null ? a.getClassifier() : "") + ":" + a.getType();
+                if (seen.add(key)) {
+                    uniqueArtifacts.add(a);
                 }
             }
-            executor.shutdown();
         }
+        calc.prewarmArtifactCache(uniqueArtifacts);
 
         Set<DependencyNode> nodes = new TreeSet<>(Comparator.comparing(DependencyNode::getComparatorString));
         for (var artifact : roots) {