Merge pull request #140 from nebula-plugins/backport-buildservice-logic

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,7 @@
 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 org.apache.commons.lang3.StringUtils;
 import org.codehaus.groovy.runtime.MethodClosure;
 import org.gradle.api.Action;
@@ -38,14 +39,17 @@
 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.internal.deprecation.DeprecationLogger;
+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
@@ -75,10 +79,19 @@ 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)) {
+                    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 if using build service
+                        if (shouldUseBuildService(sub)) {
+                            eagerlyResolveBoms(sub, recommendationProviderContainer);
+                        }
                         sub.getConfigurations().all(new ExtendRecommenderConfigurationAction(bomConfiguration, sub, recommendationProviderContainer));
                     }
                 });
@@ -87,6 +100,17 @@ public void execute(Project sub) {
     }
 
     private void applyRecommendations(final Project project) {
+        // Add eager BOM resolution for regular (non-core) BOM support if using build service
+        project.afterEvaluate(new Action<Project>() {
+            @Override
+            public void execute(Project p) {
+                if (shouldUseBuildService(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) {
@@ -101,7 +125,7 @@ public Unit invoke(ResolvableDependencies resolvableDependencies) {
                             }
 
                             for (Dependency dependency : resolvableDependencies.getDependencies()) {
-                                applyRecommendationToDependency(rsFactory, dependency, new ArrayList<ProjectDependency>());
+                                applyRecommendationToDependency(rsFactory, dependency, new ArrayList<ProjectDependency>(), project);
 
                                 // if project dependency, pull all first orders and apply recommendations if missing dependency versions
                                 // dependency.getProjectConfiguration().allDependencies iterate and inspect them as well
@@ -160,7 +184,7 @@ private boolean isExcludedConfiguration(String confName) {
         return false;
     }
 
-    private void applyRecommendationToDependency(final RecommendationStrategyFactory factory, Dependency dependency, List<ProjectDependency> visited) {
+    private void applyRecommendationToDependency(final RecommendationStrategyFactory factory, Dependency dependency, List<ProjectDependency> visited, Project rootProject) {
         if (dependency instanceof ExternalModuleDependency) {
             factory.getRecommendationStrategy().inspectDependency(dependency);
         } else if (dependency instanceof ProjectDependency) {
@@ -171,10 +195,10 @@ private void applyRecommendationToDependency(final RecommendationStrategyFactory
                 try {
                     ProjectDependency.class.getMethod("getTargetConfiguration");
                     String targetConfiguration = projectDependency.getTargetConfiguration() == null ? Dependency.DEFAULT_CONFIGURATION : projectDependency.getTargetConfiguration();
-
-                    DeprecationLogger.whileDisabled(() -> {
-                        configuration[0] = projectDependency.getDependencyProject().getConfigurations().getByName(targetConfiguration);
-                    });
+                    Project dependencyProject = rootProject.findProject(projectDependency.getPath());
+                    if (dependencyProject != null) {
+                        configuration[0] = dependencyProject.getConfigurations().getByName(targetConfiguration);
+                    }
                 } catch (NoSuchMethodException ignore) {
                     try {
                         Method method = ProjectDependency.class.getMethod("getProjectConfiguration");
@@ -183,9 +207,11 @@ private void applyRecommendationToDependency(final RecommendationStrategyFactory
                         throw new RuntimeException("Unable to retrieve configuration for project dependency", e);
                     }
                 }
-                DependencySet dependencies = configuration[0].getAllDependencies();
-                for (Dependency dep : dependencies) {
-                    applyRecommendationToDependency(factory, dep, visited);
+                if (configuration[0] != null) {
+                    DependencySet dependencies = configuration[0].getAllDependencies();
+                    for (Dependency dep : dependencies) {
+                        applyRecommendationToDependency(factory, dep, visited, rootProject);
+                    }
                 }
             }
         }
@@ -243,4 +269,71 @@ 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 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
+            Provider<BomResolverService> bomResolverService =
+                project.getGradle().getSharedServices().registerIfAbsent(
+                    "bomResolver", 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);
+        }
+    }
 }

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

@@ -15,22 +15,82 @@
  */
 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 org.gradle.util.GradleVersion;
 
 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;
+    private static final GradleVersion GRADLE_9_0 = GradleVersion.version("9.0");
 
     ClasspathBasedRecommendationProvider(Project project, String configName) {
         this.project = project;
+        this.configName = configName;
         this.configuration = project.getConfigurations().getByName(configName);
+        
+        // Only initialize build service if we might use it
+        if (shouldUseBuildService()) {
+            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) {
+        if (bomResolverService == null) {
+            throw new RuntimeException("BomResolverService not available - build service approach not enabled");
+        }
+        return bomResolverService.get().getRecommendations(project, configName, reasons);
+    }
+    
+    /**
+     * 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>
+     * 
+     * @return true if build service should be used, false otherwise
+     */
+    private boolean shouldUseBuildService() {
+        // 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;
+    }
 }

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

@@ -31,6 +31,7 @@
 import org.codehaus.plexus.interpolation.ValueSource;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
+import org.gradle.util.GradleVersion;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -42,6 +43,7 @@
 public class MavenBomRecommendationProvider extends ClasspathBasedRecommendationProvider {
     private volatile Map<String, String> recommendations = null;
     private Set<String> reasons = new HashSet<>();
+    private static final GradleVersion GRADLE_9_0 = GradleVersion.version("9.0.0");
 
     public MavenBomRecommendationProvider(Project project, String configName) {
         super(project, configName);
@@ -88,9 +90,21 @@ public String getVersion(String org, String name) throws Exception {
     public Map<String, String> getRecommendations() {
         if (recommendations == null) {
             try {
-                recommendations = getMavenRecommendations();
+                // Try to get cached recommendations from build service if using Gradle 9+ or flag is enabled
+                if (shouldUseBuildService()) {
+                    recommendations = getBomRecommendations(reasons);
+                } else {
+                    // Fallback to original implementation for older Gradle versions
+                    recommendations = getMavenRecommendations();
+                }
             } catch (Exception e) {
-                throw new RuntimeException(e);
+                // Fallback to original implementation if build service fails
+                try {
+                    recommendations = getMavenRecommendations();
+                } catch (Exception fallbackException) {
+                    // If both approaches fail, return empty map to avoid failures
+                    recommendations = new HashMap<>();
+                }
             }
         }
         return recommendations;
@@ -187,4 +201,29 @@ public List<ValueSource> createValueSources(Model model, File projectDir, ModelB
             return sources;
         }
     }
+    
+    /**
+     * 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>
+     * 
+     * @return true if build service should be used, false otherwise
+     */
+    private boolean shouldUseBuildService() {
+        // 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;
+    }
 }

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

@@ -19,6 +19,7 @@
 import netflix.nebula.dependency.recommender.DependencyRecommendationsPlugin;
 import netflix.nebula.dependency.recommender.RecommendationStrategies;
 import org.gradle.api.*;
+import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.Dependency;
 import org.gradle.api.internal.ConfigureByMapAction;
 import org.gradle.api.internal.DefaultNamedDomainObjectList;
@@ -270,6 +271,26 @@ private static class CoreBomSupportProvider extends MavenBomRecommendationProvid
             super(project, configName, reasons);
         }
 
+        @Override
+        protected Map<String, String> getBomRecommendations(Set<String> reasons) {
+            // For core BOM support, we need to create detached configuration with regular dependencies
+            // instead of using the shared service that works with the main configuration
+            List<Dependency> rawPomDependencies = new ArrayList<>();
+            for(org.gradle.api.artifacts.Dependency dependency: configuration.getDependencies()) {
+                rawPomDependencies.add(project.getDependencies().create(dependency.getGroup() + ":" + dependency.getName() + ":" + dependency.getVersion() + "@pom"));
+            }
+            Configuration detachedConfig = project.getConfigurations().detachedConfiguration(
+                    rawPomDependencies.toArray(new org.gradle.api.artifacts.Dependency[0]));
+            
+            // Use the build service with cached data only (no resolution during dependency resolution)
+            if (bomResolverService != null) {
+                return bomResolverService.get().getCachedRecommendationsFromConfiguration(detachedConfig, reasons);
+            } else {
+                // Fallback - this shouldn't happen in normal usage but prevents errors
+                throw new RuntimeException("BOM not cached and no build service context available for resolution");
+            }
+        }
+        
         @Override
         Set<File> getFilesOnConfiguration() {
             List<Dependency> rawPomDependencies = new ArrayList<>();