fix(gradle): Refactored init-script-gradle.ftl to add support for configuration cache in gradle projects. (IDETECT-4812)

documentation/src/main/markdown/currentreleasenotes.md

@@ -38,6 +38,8 @@
 * (IDETECT-4751) Prevent server-side parsing errors by normalizing IAC Scan `results.json` contents before uploading to Black Duck SCA.
 * (IDETECT-4799) When constructing the BDIO, ignore the Go toolchain directive, as it is the Go project's build-time configuration setting and not a module dependency.
 * (IDETECT-4813) Fix Gradle Native Inspector to correctly identify projects with only settings.gradle or settings.gradle.kts file in the root directory.
+* (IDETECT-4812) Refactored init-script-gradle.ftl to add support for configuration cache in Gradle projects.
+
 
 ### Dependency updates
 

src/main/resources/init-script-gradle.ftl

@@ -13,174 +13,235 @@ Set<String> projectNameIncludeFilter = convertStringToSet('${includedProjectName
 Set<String> projectPathExcludeFilter = convertStringToSet('${excludedProjectPaths}')
 Set<String> projectPathIncludeFilter = convertStringToSet('${includedProjectPaths}')
 Boolean rootOnly = Boolean.parseBoolean("${rootOnlyOption}")
+
 gradle.allprojects {
     // add a new task to each project to start the process of getting the dependencies
     task gatherDependencies(type: DefaultTask) {
+        // Store project name during configuration phase
+        def projectName = project.name
         doLast {
-            println "Gathering dependencies for " + project.name
+            try {
+                println "Gathering dependencies for " + projectName
+            } catch (Exception e) {
+                println "ERROR in gatherDependencies task: " + e.message
+                e.printStackTrace()
+            }
         }
     }
-    afterEvaluate { project ->
-        // after a project has been evaluated modify the dependencies task for that project to output to a specific file.
-        project.tasks.getByName('dependencies') {
-            ext {
-                excludedProjectNames = '${excludedProjectNames}'
-                includedProjectNames = '${includedProjectNames}'
-                excludedConfigurationNames = '${excludedConfigurationNames}'
-                includedConfigurationNames = '${includedConfigurationNames}'
-                outputDirectoryPath = System.getProperty('GRADLEEXTRACTIONDIR')
+
+    afterEvaluate { currentProject ->
+        // Capture all needed project properties during configuration
+        def projectPath = currentProject.path
+        def projectName = currentProject.name
+        def isRootProject = isRoot(currentProject)
+        def extractionDir = System.getProperty('GRADLEEXTRACTIONDIR')
+        def projectDir = currentProject.projectDir
+        def projectDirPath = projectDir.canonicalPath
+
+        // Root project properties
+        def rootProject = currentProject.gradle.rootProject
+        def rootProjectName = rootProject.name
+        def rootProjectPath = rootProject.path
+        def rootProjectGroup = rootProject.group.toString()
+        def rootProjectVersion = rootProject.version.toString()
+        def rootProjectDir = rootProject.projectDir
+        def rootProjectDirPath = rootProjectDir.canonicalPath
+
+        // Project metadata
+        def projectGroup = currentProject.group.toString()
+        def projectVersion = currentProject.version.toString()
+        def projectParent = currentProject.parent ? currentProject.parent.toString() : "none"
+
+        // Prepare configuration names
+        def configurationNames = getFilteredConfigurationNames(currentProject,
+            '${excludedConfigurationNames}', '${includedConfigurationNames}')
+
+        def selectedConfigs = []
+        configurationNames.each { name ->
+            try {
+                def config = currentProject.configurations.findByName(name)
+                if (config) {
+                    selectedConfigs.add(config)
+                }
+            } catch (Exception e) {
+                println "Could not process configuration: " + name
             }
-            doFirst {
-                generateRootProjectMetaData(project, outputDirectoryPath)
+        }
 
-                if((rootOnly && isRoot(project)) || (!rootOnly && shouldInclude(projectNameExcludeFilter, projectNameIncludeFilter, project.name) && shouldInclude(projectPathExcludeFilter, projectPathIncludeFilter, project.path)) ) {
-                    def dependencyTask = project.tasks.getByName('dependencies')
-                    File projectOutputFile = findProjectOutputFile(project, outputDirectoryPath)
-                    File projectFile = createProjectOutputFile(projectOutputFile)
+        // Check if the project should be included in results
+        def shouldIncludeProject = (rootOnly && isRootProject) ||
+            (!rootOnly && shouldInclude(projectNameExcludeFilter, projectNameIncludeFilter, projectName) &&
+             shouldInclude(projectPathExcludeFilter, projectPathIncludeFilter, projectPath))
 
-                    if(dependencyTask.metaClass.respondsTo(dependencyTask, "setConfigurations")) {
-                        println "Updating configurations for task"
-                        // modify the configurations for the dependency task
-                        setConfigurations(filterConfigurations(project, excludedConfigurationNames, includedConfigurationNames))
+        // Capture output file path during configuration
+        def projectFilePathConfig = computeProjectFilePath(projectPath, extractionDir)
 
-                    } else {
-                        println "Could not find method 'setConfigurations'"
-                    }
+        // Configure the dependencies task during configuration time
+        def dependenciesTask = currentProject.tasks.getByName('dependencies')
+
+        // Set the configurations at configuration time if possible
+        if (!selectedConfigs.isEmpty()) {
+            dependenciesTask.configurations = selectedConfigs
+        }
+
+        // Set the output file at configuration time if possible
+        if (shouldIncludeProject) {
+            // Create output file directly during configuration
+            File projectFile = new File(projectFilePathConfig)
+            if (projectFile.exists()) {
+                projectFile.delete()
+            }
+            projectFile.createNewFile()
+
+            // Set the output file during configuration phase
+            try {
+                dependenciesTask.outputFile = projectFile
+                println "Set output file during configuration to " + projectFile.getAbsolutePath()
+            } catch (Exception e) {
+                println "Could not set outputFile property during configuration: " + e.message
+                e.printStackTrace()
+            }
+        }
 
-                    if(dependencyTask.metaClass.respondsTo(dependencyTask,"setOutputFile")) {
-                        println "Updating output file for task to "+projectFile.getAbsolutePath()
-                        // modify the output file
-                        setOutputFile(projectFile)
-                    } else {
-                        println "Could not find method 'setOutputFile'"
+        dependenciesTask.doFirst {
+            try {
+                if (extractionDir == null) {
+                    throw new IllegalStateException("GRADLEEXTRACTIONDIR system property is not set")
+                }
+
+                // Create metadata file for root project
+                if (isRootProject) {
+                    try {
+                        File outputDirectory = new File(extractionDir)
+                        outputDirectory.mkdirs()
+                        File rootOutputFile = new File(outputDirectory, 'rootProjectMetadata.txt')
+
+                        def rootProjectMetadataPieces = []
+                        rootProjectMetadataPieces.add('DETECT META DATA START')
+                        rootProjectMetadataPieces.add("rootProjectDirectory:" + rootProjectDirPath)
+                        rootProjectMetadataPieces.add("rootProjectPath:" + rootProjectPath)
+                        rootProjectMetadataPieces.add("rootProjectGroup:" + rootProjectGroup)
+                        rootProjectMetadataPieces.add("rootProjectName:" + rootProjectName)
+                        rootProjectMetadataPieces.add("rootProjectVersion:" + rootProjectVersion)
+                        rootProjectMetadataPieces.add('DETECT META DATA END')
+
+                        rootOutputFile.text = rootProjectMetadataPieces.join('\n')
+                    } catch (Exception e) {
+                        println "ERROR while generating root project metadata: " + e.message
+                        e.printStackTrace()
                     }
-                } else {
-                    println "Excluding from results subproject: " + project.path
                 }
+            } catch (Exception e) {
+                println "ERROR in dependencies doFirst: " + e.message
+                e.printStackTrace()
             }
+        }
 
-            doLast {
-                if((rootOnly && isRoot(project)) || (!rootOnly && shouldInclude(projectNameExcludeFilter, projectNameIncludeFilter, project.name) && shouldInclude(projectPathExcludeFilter, projectPathIncludeFilter, project.path))) {
-                    File projectFile = findProjectOutputFile(project, outputDirectoryPath)
-                    appendProjectMetadata(project, projectFile)
+        dependenciesTask.doLast {
+            try {
+                if(shouldIncludeProject) {
+                    File projectFile = new File(projectFilePathConfig)
+
+                    // Add metadata at the end of the file
+                    def metaDataPieces = []
+                    metaDataPieces.add('')
+                    metaDataPieces.add('DETECT META DATA START')
+                    metaDataPieces.add("rootProjectDirectory:" + rootProjectDirPath)
+                    metaDataPieces.add("rootProjectGroup:" + rootProjectGroup)
+                    metaDataPieces.add("rootProjectPath:" + rootProjectPath)
+                    metaDataPieces.add("rootProjectName:" + rootProjectName)
+                    metaDataPieces.add("rootProjectVersion:" + rootProjectVersion)
+                    metaDataPieces.add("projectDirectory:" + projectDirPath)
+                    metaDataPieces.add("projectGroup:" + projectGroup)
+                    metaDataPieces.add("projectName:" + projectName)
+                    metaDataPieces.add("projectVersion:" + projectVersion)
+                    metaDataPieces.add("projectPath:" + projectPath)
+                    metaDataPieces.add("projectParent:" + projectParent)
+                    metaDataPieces.add('DETECT META DATA END')
+                    metaDataPieces.add('')
+
+                    // Append to file
+                    projectFile << metaDataPieces.join('\n')
                 }
+            } catch (Exception e) {
+                println "ERROR in dependencies doLast: " + e.message
+                e.printStackTrace()
             }
         }
-        // this forces the dependencies task to be run which will write the content to the modified output file
-        project.gatherDependencies.finalizedBy(project.tasks.getByName('dependencies'))
-        project.gatherDependencies
+
+        // This forces the dependencies task to be run
+        currentProject.gatherDependencies.finalizedBy(currentProject.tasks.getByName('dependencies'))
+        currentProject.gatherDependencies
     }
 }
 
 // ## START methods invoked by tasks above
 <#-- Do not parse with Freemarker because Groovy variable replacement in template strings is the same as Freemarker template syntax. -->
 <#noparse>
 def isRoot(Project project) {
-    Project rootProject = project.gradle.rootProject;
-    return project.name.equals(rootProject.name)
-}
-
-def generateRootProjectMetaData(Project project, String outputDirectoryPath) {
-    File outputDirectory = createTaskOutputDirectory(outputDirectoryPath)
-    outputDirectory.mkdirs()
-
-    Project rootProject = project.gradle.rootProject;
-    /* if the current project is the root project then generate the file containing
-       the meta data for the root project otherwise ignore.
-     */
-    if (project.name.equals(rootProject.name)) {
-        File rootOutputFile = new File(outputDirectory, 'rootProjectMetadata.txt');
-        String rootProjectDirectory = rootProject.getProjectDir().getCanonicalPath()
-        String rootProjectPath = rootProject.path.toString()
-        String rootProjectGroup = rootProject.group.toString()
-        String rootProjectName = rootProject.name.toString()
-        String rootProjectVersionName = rootProject.version.toString()
-
-        def rootProjectMetadataPieces = []
-        rootProjectMetadataPieces.add('DETECT META DATA START')
-        rootProjectMetadataPieces.add("rootProjectDirectory:${rootProjectDirectory}")
-        rootProjectMetadataPieces.add("rootProjectPath:${rootProjectPath}")
-        rootProjectMetadataPieces.add("rootProjectGroup:${rootProjectGroup}")
-        rootProjectMetadataPieces.add("rootProjectName:${rootProjectName}")
-        rootProjectMetadataPieces.add("rootProjectVersion:${rootProjectVersionName}")
-        rootProjectMetadataPieces.add('DETECT META DATA END')
-        rootOutputFile << rootProjectMetadataPieces.join('\n')
+    try {
+        Project rootProject = project.gradle.rootProject;
+        return project.name.equals(rootProject.name)
+    } catch (Exception e) {
+        println "ERROR in isRoot: " + e.message
+        e.printStackTrace()
+        return false
     }
 }
 
-def findProjectOutputFile(Project project, String outputDirectoryPath) {
-    File outputDirectory = createTaskOutputDirectory(outputDirectoryPath)
-    String name = project.toString()
 
-    int depthCount = 0
-    for(char c: name.toCharArray()) {
-        if (c == ':') {
-            depthCount++
-        }
-    }
-    String depth = String.valueOf(depthCount)
+// Get path for project file
+def computeProjectFilePath(String projectPath, String outputDirectoryPath) {
+    try {
+        File outputDirectory = createTaskOutputDirectory(outputDirectoryPath)
+        String name = projectPath ?: ""
 
-    String nameForFile = name?.replaceAll(/[^\p{IsAlphabetic}\p{Digit}]/, "_")
-    File outputFile = new File(outputDirectory, "${nameForFile}_depth${depth}_dependencyGraph.txt")
-
-    outputFile
-}
-
-def filterConfigurations(Project project, String excludedConfigurationNames, String includedConfigurationNames) {
-    Set<String> configurationExcludeFilter = convertStringToSet(excludedConfigurationNames)
-    Set<String> configurationIncludeFilter = convertStringToSet(includedConfigurationNames)
-    Set<Configuration> filteredConfigurationSet = new TreeSet<Configuration>(new Comparator<Configuration>() {
-        public int compare(Configuration conf1, Configuration conf2) {
-            return conf1.getName().compareTo(conf2.getName());
+        int depthCount = 0
+        for(char c: name.toCharArray()) {
+            if (c == ':') {
+                depthCount++
+            }
         }
-    })
-    for (Configuration configuration : project.configurations) {
-        if (shouldInclude(configurationExcludeFilter, configurationIncludeFilter, configuration.name)) {
-            filteredConfigurationSet.add(configuration)
+        String depth = String.valueOf(depthCount)
+        // Special case for root project
+        if (projectPath == ":") {
+            return new File(outputDirectory, "root_project_depth${depth}_dependencyGraph.txt").getAbsolutePath()
         }
-    }
+        // Replace all non-alphanumeric characters with underscores
 
-    filteredConfigurationSet
+        String nameForFile = name?.replaceAll(/[^\p{IsAlphabetic}\p{Digit}]/, "_")
+        nameForFile = "project_" + nameForFile
+        return new File(outputDirectory, "${nameForFile}_depth${depth}_dependencyGraph.txt").getAbsolutePath()
+    } catch (Exception e) {
+        println "ERROR in computeProjectFilePath: " + e.message
+        e.printStackTrace()
+        // Do nothing else
+    }
 }
 
-def appendProjectMetadata(Project project, File projectOutputFile) {
-    Project rootProject = project.gradle.rootProject;
-    String rootProjectGroup = rootProject.group.toString()
-    String rootProjectName = rootProject.name.toString()
-    String rootProjectVersionName = rootProject.version.toString()
-    String rootProjectPath = rootProject.path.toString()
-    String group = project.group.toString()
-    String name = project.name.toString()
-    String version = project.version.toString()
-    String path = project.path.toString()
-
-    def metaDataPieces = []
-    metaDataPieces.add('')
-    metaDataPieces.add('DETECT META DATA START')
-    metaDataPieces.add("rootProjectDirectory:${rootProject.getProjectDir().getCanonicalPath()}")
-    metaDataPieces.add("rootProjectGroup:${rootProjectGroup}")
-    metaDataPieces.add("rootProjectPath:${rootProjectPath}")
-    metaDataPieces.add("rootProjectName:${rootProjectName}")
-    metaDataPieces.add("rootProjectVersion:${rootProjectVersionName}")
-    metaDataPieces.add("projectDirectory:${project.getProjectDir().getCanonicalPath()}")
-    metaDataPieces.add("projectGroup:${group}")
-    metaDataPieces.add("projectName:${name}")
-    metaDataPieces.add("projectVersion:${version}")
-    metaDataPieces.add("projectPath:${path}")
-    metaDataPieces.add("projectParent:${project.parent}")
-    metaDataPieces.add('DETECT META DATA END')
-    metaDataPieces.add('')
-
-    projectOutputFile << metaDataPieces.join('\n')
-}
+// Get only configuration names to avoid serialization issues
+def getFilteredConfigurationNames(Project project, String excludedConfigurationNames, String includedConfigurationNames) {
+    try {
+        Set<String> configurationExcludeFilter = convertStringToSet(excludedConfigurationNames)
+        Set<String> configurationIncludeFilter = convertStringToSet(includedConfigurationNames)
+        Set<String> filteredNames = new TreeSet<String>()
 
-def createProjectOutputFile(File projectFile) {
-    if (projectFile.exists()) {
-        projectFile.delete()
-    }
+        for (def configuration : project.configurations) {
+            try {
+                if (shouldInclude(configurationExcludeFilter, configurationIncludeFilter, configuration.name)) {
+                    filteredNames.add(configuration.name)
+                }
+            } catch (Exception e) {
+                println "ERROR processing configuration " + configuration.name + ": " + e.message
+            }
+        }
 
-    projectFile.createNewFile()
-    projectFile
+        return filteredNames
+    } catch (Exception e) {
+        println "ERROR in getFilteredConfigurationNames: " + e.message
+        e.printStackTrace()
+        // Do nothing else
+    }
 }
 
 def createTaskOutputDirectory(String outputDirectoryPath) {
@@ -219,7 +280,7 @@ def wildCardTokenToRegexToken(String token) {
         if(matcher.group(1) != null) {
             matcher.appendReplacement(buffer, '.*')
         } else if (matcher.group(2) != null) {
-            matcher.appendReplacement(buffer, "."); 
+            matcher.appendReplacement(buffer, ".");
         } else {
             matcher.appendReplacement(buffer, '\\\\Q' + matcher.group(0) + '\\\\E')
         }
@@ -228,4 +289,4 @@ def wildCardTokenToRegexToken(String token) {
     return buffer.toString()
 }
 </#noparse>
-// ## END methods invoked by tasks above
+// ## END methods invoked by tasks above