Fix configuration resolution lock conflicts in parallel builds for Gradle 9

Author: rpalcolea

src/main/groovy/netflix/nebula/dependency/recommender/DependencyRecommendationsPlugin.java

@@ -74,18 +74,73 @@ private void applyRecommendationsDirectly(final Project project, final Configura
         project.afterEvaluate(new Action<Project>() {
             @Override
             public void execute(Project p) {
+                // Eagerly resolve and cache all BOMs after project evaluation
+                eagerlyResolveBoms(p, recommendationProviderContainer);
+                
                 p.getConfigurations().all(new ExtendRecommenderConfigurationAction(bomConfiguration, p, recommendationProviderContainer));
                 p.subprojects(new Action<Project>() {
                     @Override
                     public void execute(Project sub) {
+                        // Also eagerly resolve BOMs for subprojects
+                        eagerlyResolveBoms(sub, recommendationProviderContainer);
                         sub.getConfigurations().all(new ExtendRecommenderConfigurationAction(bomConfiguration, sub, recommendationProviderContainer));
                     }
                 });
             }
         });
     }
+    
+    /**
+     * Eagerly resolves BOM configurations during the configuration phase to prevent
+     * configuration resolution lock conflicts in parallel builds.
+     * 
+     * <p>This method is called during {@code afterEvaluate} when exclusive locks are
+     * available. It instructs the {@link BomResolverService} to resolve all BOM
+     * configurations and cache the results for later use during dependency resolution.</p>
+     * 
+     * <p>The eager resolution prevents the need to resolve configurations during the
+     * dependency resolution phase, which would cause {@code IllegalResolutionException}
+     * in parallel builds with Gradle 9+.</p>
+     * 
+     * @param project the Gradle project whose BOM configurations should be resolved
+     * @param container the recommendation provider container to check for additional BOM providers
+     */
+    private void eagerlyResolveBoms(Project project, RecommendationProviderContainer container) {
+        try {
+            // Get the build service
+            org.gradle.api.provider.Provider<netflix.nebula.dependency.recommender.service.BomResolverService> bomResolverService = 
+                project.getGradle().getSharedServices().registerIfAbsent(
+                    "bomResolver", netflix.nebula.dependency.recommender.service.BomResolverService.class, spec -> {}
+                );
+            
+            // Resolve BOMs from the nebulaRecommenderBom configuration
+            bomResolverService.get().eagerlyResolveAndCacheBoms(project, NEBULA_RECOMMENDER_BOM);
+            
+            // Also trigger resolution for maven BOM provider if it exists
+            // This handles mavenBom providers configured in the extension
+            netflix.nebula.dependency.recommender.provider.MavenBomRecommendationProvider mavenBomProvider = container.getMavenBomProvider();
+            if (mavenBomProvider != null) {
+                try {
+                    mavenBomProvider.getVersion("dummy", "dummy");  // Trigger lazy initialization
+                } catch (Exception e) {
+                    // Expected - just needed to trigger BOM resolution
+                }
+            }
+        } catch (Exception e) {
+            logger.warn("Failed to eagerly resolve BOMs for project " + project.getPath(), e);
+        }
+    }
 
     private void applyRecommendations(final Project project) {
+        // Add eager BOM resolution for regular (non-core) BOM support
+        project.afterEvaluate(new Action<Project>() {
+            @Override
+            public void execute(Project p) {
+                // Eagerly resolve and cache all BOMs after project evaluation
+                eagerlyResolveBoms(p, recommendationProviderContainer);
+            }
+        });
+        
         project.getConfigurations().all(new Action<Configuration>() {
             @Override
             public void execute(final Configuration conf) {

src/main/groovy/netflix/nebula/dependency/recommender/provider/ClasspathBasedRecommendationProvider.java

@@ -15,22 +15,44 @@
  */
 package netflix.nebula.dependency.recommender.provider;
 
+import netflix.nebula.dependency.recommender.service.BomResolverService;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.provider.Provider;
 
 import java.io.File;
+import java.util.Map;
 import java.util.Set;
 
 public abstract class ClasspathBasedRecommendationProvider extends AbstractRecommendationProvider {
     protected Project project;
     protected Configuration configuration;
+    protected String configName;
+    protected Provider<BomResolverService> bomResolverService;
 
     ClasspathBasedRecommendationProvider(Project project, String configName) {
         this.project = project;
+        this.configName = configName;
         this.configuration = project.getConfigurations().getByName(configName);
+        this.bomResolverService = project.getGradle().getSharedServices().registerIfAbsent(
+            "bomResolver", BomResolverService.class, spec -> {}
+        );
     }
 
-    Set<File> getFilesOnConfiguration() {
-        return configuration.resolve();
+    /**
+     * Retrieves BOM recommendations using the shared {@link BomResolverService}.
+     * 
+     * <p>This method delegates to the build service to get cached BOM recommendations,
+     * avoiding direct configuration resolution that could cause lock conflicts in
+     * parallel builds. The build service ensures that all BOM resolution happens
+     * during the configuration phase when exclusive locks are available.</p>
+     * 
+     * @param reasons a mutable set that will be populated with reasons explaining
+     *                why specific recommendations were applied
+     * @return a map of dependency coordinates (groupId:artifactId) to recommended versions
+     * @throws RuntimeException if the build service is not available or BOM resolution fails
+     */
+    protected Map<String, String> getBomRecommendations(Set<String> reasons) {
+        return bomResolverService.get().getRecommendations(project, configName, reasons);
     }
 }