Increase Gradle compatibility (#142)

Signed-off-by: Juan Manuel Leflet Estrada <jleflete@redhat.com>

Author: jmle

Dockerfile

@@ -39,6 +39,7 @@ ENV M2_HOME /usr/local/apache-maven-3.9.11
 # Copy "download sources" gradle task. This is needed to download project sources.
 RUN mkdir /root/.gradle
 COPY ./gradle/build.gradle /usr/local/etc/task.gradle
+COPY ./gradle/build-v9.gradle /usr/local/etc/task-v9.gradle
 
 COPY --from=jdtls-download /jdtls /jdtls/
 COPY --from=addon-build /root/.m2/repository/io/konveyor/tackle/java-analyzer-bundle.core/1.0.0-SNAPSHOT/java-analyzer-bundle.core-1.0.0-SNAPSHOT.jar /jdtls/java-analyzer-bundle/java-analyzer-bundle.core/target/

gradle/build-v9.gradle

@@ -0,0 +1,100 @@
+/**
+ * Configuration cache compatible sources download task - compatible with Gradle 8.14+
+ * All project iteration happens at configuration time
+ */
+
+// Collect all source files at configuration time
+def allProjectSourceFiles = []
+
+allprojects { proj ->
+    // Process each project during configuration phase
+    def targetConfigs = [
+        'compileClasspath',
+        'runtimeClasspath',
+        'implementation',
+        'api'
+    ].findAll { configName ->
+        def config = proj.configurations.findByName(configName)
+        return config != null && config.canBeResolved
+    }
+
+    targetConfigs.each { configName ->
+        try {
+            def config = proj.configurations.getByName(configName)
+
+            // Use modern incoming artifacts API
+            def artifacts = config.incoming.artifacts
+            def artifactResults = artifacts.artifacts
+
+            // Extract module identifiers for source resolution
+            def moduleIds = artifactResults.collect { artifactResult ->
+                def componentId = artifactResult.id.componentIdentifier
+                if (componentId instanceof ModuleComponentIdentifier) {
+                    return [
+                        group: componentId.group,
+                        name: componentId.module,
+                        version: componentId.version
+                    ]
+                }
+                return null
+            }.findAll { it != null }.unique()
+
+            if (!moduleIds.isEmpty()) {
+                // Create source dependencies
+                def sourceDependencies = moduleIds.collect { moduleId ->
+                    proj.dependencies.create(
+                        "${moduleId.group}:${moduleId.name}:${moduleId.version}:sources"
+                    )
+                }
+
+                if (!sourceDependencies.isEmpty()) {
+                    def sourcesConfig = proj.configurations.detachedConfiguration(
+                        sourceDependencies as Dependency[]
+                    )
+                    sourcesConfig.transitive = false
+
+                    try {
+                        // Resolve and collect source files
+                        def sourceFiles = sourcesConfig.incoming.artifactView { view ->
+                            view.lenient(true)
+                        }.artifacts.artifacts.collect { it.file }.findAll {
+                            it != null && it.exists()
+                        }
+
+                        if (!sourceFiles.isEmpty()) {
+                            allProjectSourceFiles.addAll(sourceFiles)
+                            println "Found ${sourceFiles.size()} source files for ${proj.name}:${configName}"
+                        }
+                    } catch (Exception e) {
+                        println "Error resolving sources for ${proj.name}:${configName}: ${e.message}"
+                    }
+                }
+            }
+        } catch (Exception e) {
+            println "Error processing ${proj.name}:${configName}: ${e.message}"
+        }
+    }
+}
+
+task konveyorDownloadSources {
+    // Store the collected files as task input
+    def sourceFiles = allProjectSourceFiles
+
+    doLast {
+        // Copy all found source files
+        if (!sourceFiles.isEmpty()) {
+            def downloadDir = new File(project.layout.buildDirectory.get().asFile, "downloaded-sources")
+            downloadDir.mkdirs()
+
+            copy {
+                from sourceFiles
+                into downloadDir
+                duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+            }
+
+            println "Downloaded ${sourceFiles.size()} source files to ${downloadDir}"
+        } else {
+            println "No source files found to download"
+        }
+    }
+}

gradle/build.gradle

@@ -1,35 +1,86 @@
 /**
- * Sources download task for Gradle, tested in versions 4+
+ * Conservative sources download task - targets main classpaths only
+ * Compatible with Gradle 4-8
  */
 task konveyorDownloadSources {
-    allprojects { project ->
-        project.getConfigurations().each { config ->
-            config.setCanBeResolved(true)
-
-            inputs.files config
-            outputs.dir "${buildDir}/download"
-            doLast {
-                def componentIds = config.incoming.resolutionResult.allDependencies.collect { it.selected.id }
-                ArtifactResolutionResult result = dependencies.createArtifactResolutionQuery()
-                        .forComponents(componentIds)
-                        .withArtifacts(JvmLibrary, SourcesArtifact)
-                        .execute()
-                def sourceArtifacts = []
-                result.resolvedComponents.each { ComponentArtifactsResult component ->
-                    Set<ArtifactResult> sources = component.getArtifacts(SourcesArtifact)
-                    println "Found ${sources.size()} sources for ${component.id}"
-                    sources.each { ArtifactResult ar ->
-                        if (ar instanceof ResolvedArtifactResult) {
-                            sourceArtifacts << ar.file
+    doLast {
+        def allSourceFiles = []
+
+        allprojects { project ->
+            println "Processing project: ${project.name}"
+
+            // Focus on main classpaths that are typically resolvable
+            def targetConfigs = [
+                    'compileClasspath',
+                    'runtimeClasspath',
+                    'implementation',
+                    'api'
+            ].findAll { configName ->
+                project.configurations.findByName(configName)?.canBeResolved ?: false
+            }
+
+            targetConfigs.each { configName ->
+                try {
+                    def config = project.configurations.getByName(configName)
+                    println "  Processing configuration: ${configName}"
+
+                    // Get resolved dependencies
+                    def resolvedConfig = config.resolvedConfiguration
+                    def dependencies = resolvedConfig.resolvedArtifacts
+
+                    // Extract module identifiers for source resolution
+                    def moduleIds = dependencies.collect { artifact ->
+                        artifact.moduleVersion.id
+                    }.unique()
+
+                    if (!moduleIds.isEmpty()) {
+                        println "    Found ${moduleIds.size()} unique modules"
+
+                        // Query for sources using the dependency notation
+                        moduleIds.each { moduleId ->
+                            try {
+                                def sourceDep = project.dependencies.create(
+                                        group: moduleId.group,
+                                        name: moduleId.name,
+                                        version: moduleId.version,
+                                        classifier: 'sources'
+                                )
+
+                                def sourceConfig = project.configurations.detachedConfiguration(sourceDep)
+                                sourceConfig.transitive = false
+
+                                def sourceFiles = sourceConfig.resolve()
+                                if (!sourceFiles.isEmpty()) {
+                                    allSourceFiles.addAll(sourceFiles)
+                                    println "      Found sources for ${moduleId}"
+                                }
+                            } catch (Exception e) {
+                                // Sources not available for this dependency, continue
+                                println "      No sources available for ${moduleId}"
+                            }
                         }
                     }
+                } catch (Exception e) {
+                    println "    Error processing ${configName}: ${e.message}"
                 }
+            }
+        }
 
-                copy {
-                    from sourceArtifacts
-                    into "${buildDir}/download"
-                }
+        // Copy all found source files
+        if (!allSourceFiles.isEmpty()) {
+            def downloadDir = new File(buildDir, "download")
+            downloadDir.mkdirs()
+
+            copy {
+                from allSourceFiles
+                into downloadDir
+                duplicatesStrategy = "exclude"
             }
+
+            println "Downloaded ${allSourceFiles.size()} source files to ${downloadDir}"
+        } else {
+            println "No source files found to download"
         }
     }
 }
+