Refactor muzzle tasks to dedicated classes, make Muzzletask cacheable (#9544)

* refactor: Proper task for muzzle printReferences

* refactor: Proper tasks for muzzle reports

* refactor: Proper tasks for muzzle checks

* refactor: Makes MuzzleTask Cacheable

Note, this only caches the muzzle assertion, tasks are being still
registered depending on what is brought back from maven. I.e. if a new
dependency is discovered a new task will be registered and as such will
be executed.

* refactor: Makes muzzle printReferences Cacheable

* style: make google-java-format happy

* chore: PR reviews

* chore: Declare reports as inout / output

* chore: Use BuildEventsListenerRegistry to print task output even when cached

* chore: Extract end task output file

* chore: Use kotlin dsl extension function for newInstance

* chore: Use same single instance for the provider

* chore: Revert the BuildEventsListenerRegistry approach

* chore: Revert the declaration of versionReports as input files

* chore: touch

Author: bric3

buildSrc/src/main/kotlin/datadog/gradle/plugin/muzzle/MuzzleAction.kt

@@ -1,5 +1,6 @@
 package datadog.gradle.plugin.muzzle
 
+import org.gradle.api.GradleException
 import org.gradle.api.file.FileCollection
 import org.gradle.workers.WorkAction
 import java.lang.reflect.Method
@@ -42,6 +43,12 @@ abstract class MuzzleAction : WorkAction<MuzzleWorkParameters> {
               Boolean::class.java,
               String::class.java
             )
+      try {
         assertionMethod.invoke(null, instCL, testCL, assertPass, muzzleDirective)
+        parameters.resultFile.get().asFile.writeText("PASSING")
+      } catch (e: Exception) {
+        parameters.resultFile.get().asFile.writeText(e.stackTraceToString())
+        throw GradleException("Muzzle validation failed", e)
+      }
     }
 }

buildSrc/src/main/kotlin/datadog/gradle/plugin/muzzle/MuzzleDirective.kt

@@ -1,11 +1,12 @@
 package datadog.gradle.plugin.muzzle
 
 import org.eclipse.aether.repository.RemoteRepository
+import java.io.Serializable
 
 /**
  * A pass or fail directive for a single dependency.
  */
-open class MuzzleDirective {
+open class MuzzleDirective : Serializable {
   /**
    * Name is optional and is used to further define the scope of a directive. The motivation for this is that this
    * plugin creates a config for each of the dependencies under test with name '...-<group_id>-<artifact_id>-<version>'.
@@ -20,7 +21,7 @@ open class MuzzleDirective {
   var versions: String? = null
   var skipVersions: MutableSet<String> = HashSet()
   var additionalDependencies: MutableList<String> = ArrayList()
-  internal var additionalRepositories: MutableList<RemoteRepository> = ArrayList()
+  internal var additionalRepositories: MutableList<Triple<String, String, String>> = ArrayList()
   internal var excludedDependencies: MutableList<String> = ArrayList()
   var assertPass: Boolean = false
   var assertInverse: Boolean = false
@@ -51,7 +52,7 @@ open class MuzzleDirective {
    * @param type the type of repository, defaults to "default"
    */
   fun extraRepository(id: String, url: String, type: String = "default") {
-    additionalRepositories.add(RemoteRepository.Builder(id, type, url).build())
+    additionalRepositories.add(Triple(id, type, url))
   }
 
   /**
@@ -69,13 +70,15 @@ open class MuzzleDirective {
    * @param defaults the default repositories
    * @return a list of the default repositories followed by any additional repositories
    */
-  fun getRepositories(defaults: List<RemoteRepository>): List<RemoteRepository> {
+  internal fun getRepositories(defaults: List<RemoteRepository>): List<RemoteRepository> {
     return if (additionalRepositories.isEmpty()) {
       defaults
     } else {
       ArrayList<RemoteRepository>(defaults.size + additionalRepositories.size).apply {
         addAll(defaults)
-        addAll(additionalRepositories)
+        addAll(additionalRepositories.map { (id, type, url) ->
+          RemoteRepository.Builder(id, type, url).build()
+        })
       }
     }
   }

buildSrc/src/main/kotlin/datadog/gradle/plugin/muzzle/MuzzleExtension.kt

@@ -1,28 +1,28 @@
 package datadog.gradle.plugin.muzzle
 
-import org.eclipse.aether.repository.RemoteRepository
 import org.gradle.api.Action
 import org.gradle.api.model.ObjectFactory
+import org.gradle.kotlin.dsl.newInstance
 import javax.inject.Inject
 import java.util.Locale
 
 /**
  * Muzzle extension containing all pass and fail directives.
  */
-abstract class MuzzleExtension @Inject constructor(protected val objectFactory: ObjectFactory) {
+abstract class MuzzleExtension @Inject constructor(private val objectFactory: ObjectFactory) {
     val directives: MutableList<MuzzleDirective> = ArrayList()
-    private val additionalRepositories: MutableList<RemoteRepository> = ArrayList()
+    private val additionalRepositories: MutableList<Triple<String, String, String>> = ArrayList()
 
     fun pass(action: Action<in MuzzleDirective>) {
-        val pass = objectFactory.newInstance(MuzzleDirective::class.java)
+        val pass = objectFactory.newInstance<MuzzleDirective>()
         action.execute(pass)
         postConstruct(pass)
         pass.assertPass = true
         directives.add(pass)
     }
 
     fun fail(action: Action<in MuzzleDirective>) {
-        val fail = objectFactory.newInstance(MuzzleDirective::class.java)
+        val fail = objectFactory.newInstance<MuzzleDirective>()
         action.execute(fail)
         postConstruct(fail)
         fail.assertPass = false
@@ -39,7 +39,7 @@ abstract class MuzzleExtension @Inject constructor(protected val objectFactory:
      */
     @JvmOverloads
     fun extraRepository(id: String, url: String, type: String = "default") {
-        additionalRepositories.add(RemoteRepository.Builder(id, type, url).build())
+        additionalRepositories.add(Triple(id, type, url))
     }
 
     private fun postConstruct(directive: MuzzleDirective) {

buildSrc/src/main/kotlin/datadog/gradle/plugin/muzzle/MuzzlePlugin.kt

@@ -3,16 +3,17 @@ package datadog.gradle.plugin.muzzle
 import datadog.gradle.plugin.muzzle.MuzzleMavenRepoUtils.inverseOf
 import datadog.gradle.plugin.muzzle.MuzzleMavenRepoUtils.muzzleDirectiveToArtifacts
 import datadog.gradle.plugin.muzzle.MuzzleMavenRepoUtils.resolveVersionRange
-import datadog.gradle.plugin.muzzle.MuzzleReportUtils.dumpVersionRanges
-import datadog.gradle.plugin.muzzle.MuzzleReportUtils.mergeReports
+import datadog.gradle.plugin.muzzle.tasks.MuzzleEndTask
+import datadog.gradle.plugin.muzzle.tasks.MuzzleGenerateReportTask
+import datadog.gradle.plugin.muzzle.tasks.MuzzleMergeReportsTask
+import datadog.gradle.plugin.muzzle.tasks.MuzzleGetReferencesTask
+import datadog.gradle.plugin.muzzle.tasks.MuzzleTask
 import org.eclipse.aether.artifact.Artifact
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.artifacts.Configuration
-import org.gradle.api.plugins.JavaBasePlugin
-import org.gradle.api.plugins.JavaPlugin
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.exclude
@@ -79,38 +80,27 @@ class MuzzlePlugin : Plugin<Project> {
     }
 
     val muzzleTask = project.tasks.register<MuzzleTask>("muzzle") {
-      description = "Run instrumentation muzzle on compile time dependencies"
-      doLast {
-        if (!project.extensions.getByType<MuzzleExtension>().directives.any { it.assertPass }) {
-          project.logger.info("No muzzle pass directives configured. Asserting pass against instrumentation compile-time dependencies")
-          assertMuzzle(muzzleBootstrap, muzzleTooling, project)
-        }
-      }
+      this.muzzleBootstrap.set(muzzleBootstrap)
+      this.muzzleTooling.set(muzzleTooling)
       dependsOn(compileMuzzle)
     }
 
-    project.tasks.register<MuzzleTask>("printReferences") {
-      description = "Print references created by instrumentation muzzle"
-      doLast {
-        printMuzzle(project)
-      }
+    project.tasks.register<MuzzleGetReferencesTask>("printReferences") {
       dependsOn(compileMuzzle)
+    }.also {
+      val printReferencesTask = project.tasks.register("actuallyPrintReferences") {
+        doLast {
+          println(it.get().outputFile.get().asFile.readText())
+        }
+      }
+      it.configure { finalizedBy(printReferencesTask) }
     }
 
-    project.tasks.register<MuzzleTask>("generateMuzzleReport") {
-      description = "Print instrumentation version report"
-      doLast {
-        dumpVersionRanges(project)
-      }
+    project.tasks.register<MuzzleGenerateReportTask>("generateMuzzleReport") {
       dependsOn(compileMuzzle)
     }
 
-    project.tasks.register<MuzzleTask>("mergeMuzzleReports") {
-      description = "Merge generated version reports in one unique csv"
-      doLast {
-        mergeReports(project)
-      }
-    }
+    project.tasks.register<MuzzleMergeReportsTask>("mergeMuzzleReports")
 
     val hasRelevantTask = project.gradle.startParameter.taskNames.any { taskName ->
       // removing leading ':' if present
@@ -133,7 +123,7 @@ class MuzzlePlugin : Plugin<Project> {
       var runAfter: TaskProvider<MuzzleTask> = muzzleTask
 
       project.extensions.getByType<MuzzleExtension>().directives.forEach { directive ->
-        project.logger.debug("configuring $directive")
+        project.logger.debug("configuring {}", directive)
 
         if (directive.isCoreJdk) {
           runAfter = addMuzzleTask(directive, null, project, runAfter, muzzleBootstrap, muzzleTooling)
@@ -157,11 +147,8 @@ class MuzzlePlugin : Plugin<Project> {
         project.logger.info("configured $directive")
       }
 
-      val timingTask = project.tasks.register("muzzle-end") {
-        doLast {
-          val endTime = System.currentTimeMillis()
-          MuzzleReportUtils.generateResultsXML(project, endTime - startTime)
-        }
+      val timingTask = project.tasks.register<MuzzleEndTask>("muzzle-end") {
+        startTimeMs.set(startTime)
       }
       // last muzzle task to run
       runAfter.configure {
@@ -252,9 +239,9 @@ class MuzzlePlugin : Plugin<Project> {
       }
 
       val muzzleTask = instrumentationProject.tasks.register<MuzzleTask>(muzzleTaskName) {
-        doLast {
-          assertMuzzle(muzzleBootstrap, muzzleTooling, instrumentationProject, muzzleDirective)
-        }
+        this.muzzleDirective.set(muzzleDirective)
+        this.muzzleBootstrap.set(muzzleBootstrap)
+        this.muzzleTooling.set(muzzleTooling)
       }
 
       runAfterTask.configure {

buildSrc/src/main/kotlin/datadog/gradle/plugin/muzzle/MuzzlePluginUtils.kt

@@ -5,8 +5,13 @@ import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.SourceSet.MAIN_SOURCE_SET_NAME
 import org.gradle.api.tasks.SourceSetContainer
+import org.gradle.build.event.BuildEventsListenerRegistry
 import org.gradle.kotlin.dsl.findByType
 import org.gradle.kotlin.dsl.getByType
+import org.gradle.tooling.events.FinishEvent
+import org.gradle.tooling.events.OperationCompletionListener
+import org.gradle.tooling.events.task.TaskFinishEvent
+import org.gradle.tooling.events.task.TaskSuccessResult
 
 internal val Project.mainSourceSet: SourceSet
   get() = extensions.findByType<SourceSetContainer>()
@@ -17,3 +22,6 @@ internal val Project.allMainSourceSet: List<SourceSet>
   get() = extensions.findByType<SourceSetContainer>()
     ?.filter { it.name.startsWith(MAIN_SOURCE_SET_NAME) }
     .orEmpty()
+
+internal val Project.pathSlug: String
+  get() = path.removePrefix(":").replace(':', '_')