Merge pull request #139 from nebula-plugins/more-gradle-9-work

 Fix configuration resolution lock conflicts in parallel builds for Gradle 9

Author: rpalcolea

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

@@ -21,6 +21,8 @@
 import netflix.nebula.dependency.recommender.provider.RecommendationProviderContainer;
 import netflix.nebula.dependency.recommender.provider.RecommendationResolver;
 import netflix.nebula.dependency.recommender.publisher.MavenBomXmlGenerator;
+import netflix.nebula.dependency.recommender.service.BomResolverService;
+import netflix.nebula.dependency.recommender.util.BomResolutionUtil;
 import org.apache.commons.lang3.StringUtils;
 import org.codehaus.groovy.runtime.MethodClosure;
 import org.gradle.api.Action;
@@ -38,13 +40,16 @@
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
 import org.gradle.api.plugins.ExtraPropertiesExtension;
+import org.gradle.api.provider.Provider;
+import org.gradle.util.GradleVersion;
 
 import java.lang.reflect.Method;
 import java.util.*;
 
 public class DependencyRecommendationsPlugin implements Plugin<Project> {
     public static final String NEBULA_RECOMMENDER_BOM = "nebulaRecommenderBom";
     public static final boolean CORE_BOM_SUPPORT_ENABLED = Boolean.getBoolean("nebula.features.coreBomSupport");
+    private static final GradleVersion GRADLE_9_0 = GradleVersion.version("9.0");
     private Logger logger = Logging.getLogger(DependencyRecommendationsPlugin.class);
     private RecommendationProviderContainer recommendationProviderContainer;
     //TODO: remove this exclusion once https://github.com/gradle/gradle/issues/6750 is resolved
@@ -74,18 +79,39 @@ 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 if using build service approach
+                if (shouldUseBuildService(p) && BomResolutionUtil.shouldEagerlyResolveBoms(p, recommendationProviderContainer)) {
+                    BomResolutionUtil.eagerlyResolveBoms(p, recommendationProviderContainer, NEBULA_RECOMMENDER_BOM);
+                }
+                
                 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 if using build service
+                        if (shouldUseBuildService(sub) && BomResolutionUtil.shouldEagerlyResolveBoms(sub, recommendationProviderContainer)) {
+                            BomResolutionUtil.eagerlyResolveBoms(sub, recommendationProviderContainer, NEBULA_RECOMMENDER_BOM);
+                        }
                         sub.getConfigurations().all(new ExtendRecommenderConfigurationAction(bomConfiguration, sub, recommendationProviderContainer));
                     }
                 });
             }
         });
     }
+    
 
     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) {
+                if (shouldUseBuildService(p) && BomResolutionUtil.shouldEagerlyResolveBoms(p, recommendationProviderContainer)) {
+                    // Eagerly resolve and cache all BOMs after project evaluation
+                    BomResolutionUtil.eagerlyResolveBoms(p, recommendationProviderContainer, NEBULA_RECOMMENDER_BOM);
+                }
+            }
+        });
+        
         project.getConfigurations().all(new Action<Configuration>() {
             @Override
             public void execute(final Configuration conf) {
@@ -245,4 +271,60 @@ public Set<String> getReasonsRecursive(Project project) {
             return getReasonsRecursive(project.getParent());
         return Collections.emptySet();
     }
+
+    /**
+     * Determines whether to use the BomResolverService (build service) approach.
+     * 
+     * <p>The build service is used when:</p>
+     * <ul>
+     *   <li>Gradle version is 9.0 or higher, OR</li>
+     *   <li>The gradle property 'nebula.dependency-recommender.useBuildService' is set to true</li>
+     * </ul>
+     * 
+     * @param project the Gradle project to check
+     * @return true if build service should be used, false otherwise
+     */
+    private boolean shouldUseBuildService(Project project) {
+        // Check if explicitly enabled via gradle property
+        if (project.hasProperty("nebula.dependency-recommender.useBuildService")) {
+            Object property = project.property("nebula.dependency-recommender.useBuildService");
+            if (Boolean.parseBoolean(property.toString())) {
+                return true;
+            }
+        }
+        
+        // Default behavior: use build service for Gradle 9+
+        GradleVersion currentVersion = GradleVersion.current();
+        return currentVersion.compareTo(GRADLE_9_0) >= 0;
+    }
+    
+    /**
+     * Eagerly resolves BOM configurations during the configuration phase to prevent
+     * configuration resolution lock conflicts in parallel builds.
+     * 
+     * <p>This method delegates to {@link BomResolutionUtil#eagerlyResolveBoms} and is 
+     * provided for backward compatibility and convenience for external plugins.</p>
+     * 
+     * <p><strong>External Plugin Usage:</strong></p>
+     * <pre>{@code
+     * // Get the plugin instance and container
+     * DependencyRecommendationsPlugin plugin = project.plugins.getPlugin(DependencyRecommendationsPlugin)
+     * RecommendationProviderContainer container = project.extensions.getByType(RecommendationProviderContainer)
+     * 
+     * // Disable automatic resolution and add BOMs
+     * container.setEagerlyResolve(false)
+     * container.mavenBom(module: 'com.example:custom-bom:1.0.0')
+     * 
+     * // Manually trigger resolution
+     * plugin.eagerlyResolveBoms(project, container)
+     * }</pre>
+     * 
+     * @param project the Gradle project whose BOM configurations should be resolved
+     * @param container the recommendation provider container to check for additional BOM providers
+     * @since 12.7.0
+     * @see BomResolutionUtil#eagerlyResolveBoms(Project, RecommendationProviderContainer, String)
+     */
+    public void eagerlyResolveBoms(Project project, RecommendationProviderContainer container) {
+        BomResolutionUtil.eagerlyResolveBoms(project, container, NEBULA_RECOMMENDER_BOM);
+    }
 }

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);
     }
 }