refactor: Proper tasks for muzzle checks

Author: bric3

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

@@ -3,6 +3,7 @@ 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.tasks.MuzzleEndTask
 import datadog.gradle.plugin.muzzle.tasks.MuzzleGenerateReportTask
 import datadog.gradle.plugin.muzzle.tasks.MuzzleMergeReportsTask
 import datadog.gradle.plugin.muzzle.tasks.MuzzlePrintReferencesTask
@@ -79,13 +80,15 @@ 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)
+      // 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)
+      //   }
+      // }
       dependsOn(compileMuzzle)
     }
 
@@ -144,7 +147,8 @@ class MuzzlePlugin : Plugin<Project> {
         project.logger.info("configured $directive")
       }
 
-      val timingTask = project.tasks.register("muzzle-end") {
+      val timingTask = project.tasks.register<MuzzleEndTask>("muzzle-end") {
+        startTimeMs.set(startTime)
         doLast {
           val endTime = System.currentTimeMillis()
           MuzzleReportUtils.generateResultsXML(project, endTime - startTime)
@@ -239,9 +243,12 @@ 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)
+        // doLast {
+        //   assertMuzzle(muzzleBootstrap, muzzleTooling, instrumentationProject, muzzleDirective)
+        // }
       }
 
       runAfterTask.configure {

buildSrc/src/main/kotlin/datadog/gradle/plugin/muzzle/tasks/MuzzleEndTask.kt

@@ -0,0 +1,17 @@
+package datadog.gradle.plugin.muzzle.tasks
+
+import datadog.gradle.plugin.muzzle.MuzzleReportUtils
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.TaskAction
+
+abstract class MuzzleEndTask : AbstractMuzzleTask() {
+  @get:Input
+  abstract val startTimeMs: Property<Long>
+
+  @TaskAction
+  fun generatesResultFile() {
+    val endTimeMs = System.currentTimeMillis()
+    MuzzleReportUtils.generateResultsXML(project, endTimeMs - startTimeMs.get())
+  }
+}

buildSrc/src/main/kotlin/datadog/gradle/plugin/muzzle/tasks/MuzzleTask.kt

@@ -2,18 +2,32 @@ package datadog.gradle.plugin.muzzle.tasks
 
 import datadog.gradle.plugin.muzzle.MuzzleAction
 import datadog.gradle.plugin.muzzle.MuzzleDirective
+import datadog.gradle.plugin.muzzle.MuzzleExtension
 import datadog.gradle.plugin.muzzle.allMainSourceSet
-import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.file.FileCollection
 import org.gradle.api.invocation.BuildInvocationDetails
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.TaskAction
 import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.jvm.toolchain.JavaToolchainService
+import org.gradle.kotlin.dsl.getByType
 import org.gradle.workers.WorkerExecutor
 import javax.inject.Inject
 
 abstract class MuzzleTask : AbstractMuzzleTask() {
+  override fun getDescription(): String {
+    return if (muzzleDirective.isPresent) {
+      "Run instrumentation muzzle on ${muzzleDirective.get().name} dependency"
+    } else {
+      "Run instrumentation muzzle on compile time dependencies"
+    }
+  }
+
   @get:Inject
   abstract val javaToolchainService: JavaToolchainService
 
@@ -23,12 +37,30 @@ abstract class MuzzleTask : AbstractMuzzleTask() {
   @get:Inject
   abstract val workerExecutor: WorkerExecutor
 
-  fun assertMuzzle(
-    muzzleBootstrap: NamedDomainObjectProvider<Configuration>,
-    muzzleTooling: NamedDomainObjectProvider<Configuration>,
-    instrumentationProject: Project,
-    muzzleDirective: MuzzleDirective? = null
-  ) {
+  @get:InputFiles
+  abstract val muzzleBootstrap: Property<Configuration>
+
+  @get:InputFiles
+  abstract val muzzleTooling: Property<Configuration>
+
+  @get:Input
+  @get:Optional
+  abstract val muzzleDirective : Property<MuzzleDirective>
+
+  @TaskAction
+  fun muzzle() {
+    when {
+        !project.extensions.getByType<MuzzleExtension>().directives.any { it.assertPass } -> {
+          project.logger.info("No muzzle pass directives configured. Asserting pass against instrumentation compile-time dependencies")
+          assertMuzzle()
+        }
+        muzzleDirective.isPresent -> {
+          assertMuzzle(muzzleDirective.get())
+        }
+    }
+  }
+
+  private fun assertMuzzle(muzzleDirective: MuzzleDirective? = null) {
     val workQueue = if (muzzleDirective?.javaVersion != null) {
       val javaLauncher = javaToolchainService.launcherFor {
         languageVersion.set(JavaLanguageVersion.of(muzzleDirective.javaVersion!!))
@@ -43,10 +75,10 @@ abstract class MuzzleTask : AbstractMuzzleTask() {
     }
     workQueue.submit(MuzzleAction::class.java) {
       buildStartedTime.set(invocationDetails.buildStartedTime)
-      bootstrapClassPath.setFrom(muzzleBootstrap.get())
-      toolingClassPath.setFrom(muzzleTooling.get())
-      instrumentationClassPath.setFrom(createAgentClassPath(instrumentationProject))
-      testApplicationClassPath.setFrom(createMuzzleClassPath(instrumentationProject, name))
+      bootstrapClassPath.setFrom(muzzleBootstrap)
+      toolingClassPath.setFrom(muzzleTooling)
+      instrumentationClassPath.setFrom(createAgentClassPath(project))
+      testApplicationClassPath.setFrom(createMuzzleClassPath(project, name))
       if (muzzleDirective != null) {
         assertPass.set(muzzleDirective.assertPass)
         this.muzzleDirective.set(muzzleDirective.name ?: muzzleDirective.module)