Move initscripts into src/resources/init-scripts

src/resources/init-scripts/build-result-capture-service.plugin.groovy

@@ -0,0 +1,52 @@
+import org.gradle.tooling.events.*
+import org.gradle.tooling.events.task.*
+import org.gradle.util.GradleVersion
+
+// Can't use settingsEvaluated since this script is applied inside a settingsEvaluated handler
+// But projectsEvaluated is good enough, since the build service won't catch configuration failures anyway
+projectsEvaluated {
+    def projectTracker = gradle.sharedServices.registerIfAbsent("gradle-build-action-buildResultsRecorder", BuildResultsRecorder, { spec ->
+        spec.getParameters().getRootProjectName().set(gradle.rootProject.name)
+        spec.getParameters().getRootProjectDir().set(gradle.rootProject.rootDir.absolutePath)
+        spec.getParameters().getRequestedTasks().set(gradle.startParameter.taskNames.join(" "))
+        spec.getParameters().getGradleHomeDir().set(gradle.gradleHomeDir.absolutePath)
+        spec.getParameters().getInvocationId().set(gradle.ext.invocationId)
+    })
+
+    gradle.services.get(BuildEventsListenerRegistry).onTaskCompletion(projectTracker)
+}
+
+abstract class BuildResultsRecorder implements BuildService<BuildResultsRecorder.Params>, OperationCompletionListener, AutoCloseable {
+    private boolean buildFailed = false
+    interface Params extends BuildServiceParameters {
+        Property<String> getRootProjectName()
+        Property<String> getRootProjectDir()
+        Property<String> getRequestedTasks()
+        Property<String> getGradleHomeDir()
+        Property<String> getInvocationId()
+    }
+
+    public void onFinish(FinishEvent finishEvent) {
+        if (finishEvent instanceof TaskFinishEvent && finishEvent.result instanceof TaskFailureResult) {
+            buildFailed = true
+        }
+    }
+
+    @Override
+    public void close() {
+        def buildResults = [
+            rootProjectName: getParameters().getRootProjectName().get(),
+            rootProjectDir: getParameters().getRootProjectDir().get(),
+            requestedTasks: getParameters().getRequestedTasks().get(),
+            gradleVersion: GradleVersion.current().version,
+            gradleHomeDir: getParameters().getGradleHomeDir().get(),
+            buildFailed: buildFailed,
+            buildScanUri: null
+        ]
+
+        def buildResultsDir = new File(System.getenv("RUNNER_TEMP"), ".build-results")
+        buildResultsDir.mkdirs()
+        def buildResultsFile = new File(buildResultsDir, System.getenv("GITHUB_ACTION") + getParameters().getInvocationId().get() + ".json")
+        buildResultsFile << groovy.json.JsonOutput.toJson(buildResults)
+    }
+}

src/resources/init-scripts/build-result-capture.init.gradle

@@ -0,0 +1,108 @@
+/*
+ * Capture information for each executed Gradle build to display in the job summary.
+ */
+import org.gradle.util.GradleVersion
+
+// Only run against root build. Do not run against included builds.
+def isTopLevelBuild = gradle.getParent() == null
+if (isTopLevelBuild) {
+    def version = GradleVersion.current().baseVersion
+
+    def atLeastGradle3 = version >= GradleVersion.version("3.0")
+    def atLeastGradle6 = version >= GradleVersion.version("6.0")
+
+    def invocationId = "-${System.currentTimeMillis()}"
+
+    if (atLeastGradle6) {
+        def useBuildService = version >= GradleVersion.version("6.6")
+        settingsEvaluated { settings ->
+            // The `buildScanPublished` hook is the only way to capture the build scan URI.
+            if (settings.pluginManager.hasPlugin("com.gradle.enterprise")) {
+                captureUsingBuildScanPublished(settings.extensions["gradleEnterprise"].buildScan, settings.rootProject, invocationId)
+            }
+            // We also need to add hooks in case the plugin is applied but no build scan is published
+            if (useBuildService) {
+                captureUsingBuildService(settings, invocationId)
+            } else {
+                captureUsingBuildFinished(gradle, invocationId)
+            }
+        }
+    } else if (atLeastGradle3) {
+        projectsEvaluated { gradle ->
+            if (gradle.rootProject.pluginManager.hasPlugin("com.gradle.build-scan")) {
+                captureUsingBuildScanPublished(gradle.rootProject.extensions["buildScan"], gradle.rootProject, invocationId)
+            }
+            // We  need to capture in buildFinished in case the plugin is applied but no build scan is published
+            captureUsingBuildFinished(gradle, invocationId)
+        }
+    }
+}
+
+def captureUsingBuildScanPublished(buildScanExtension, rootProject, invocationId) {
+    buildScanExtension.with {
+        def requestedTasks = gradle.startParameter.taskNames.join(" ")
+        def rootProjectName = rootProject.name
+        def rootProjectDir = rootProject.projectDir.absolutePath
+        def gradleVersion = GradleVersion.current().version
+        def gradleHomeDir = gradle.gradleHomeDir.absolutePath
+        def buildFailed = false
+
+        buildFinished { result ->
+            buildFailed = (result.failure != null)
+        }
+
+        buildScanPublished { buildScan ->
+
+            def buildScanUri = buildScan.buildScanUri.toASCIIString()
+            def buildResults = [
+                rootProjectName: rootProjectName,
+                rootProjectDir: rootProjectDir,
+                requestedTasks: requestedTasks,
+                gradleVersion: gradleVersion,
+                gradleHomeDir: gradleHomeDir,
+                buildFailed: buildFailed,
+                buildScanUri: buildScanUri
+            ]
+
+            def buildResultsDir = new File(System.getenv("RUNNER_TEMP"), ".build-results")
+            buildResultsDir.mkdirs()
+            def buildResultsFile = new File(buildResultsDir, System.getenv("GITHUB_ACTION") + invocationId + ".json")
+
+            // Overwrite any contents written by buildFinished or build service, since this result is a superset.
+            if (buildResultsFile.exists()) {
+                buildResultsFile.text = groovy.json.JsonOutput.toJson(buildResults)
+            } else {
+                buildResultsFile << groovy.json.JsonOutput.toJson(buildResults)
+            }
+
+            println("::set-output name=build-scan-url::${buildScan.buildScanUri}")
+        }
+    }
+}
+
+def captureUsingBuildFinished(gradle, invocationId) {
+    gradle.buildFinished { result ->
+        def buildResults = [
+            rootProjectName: gradle.rootProject.name,
+            rootProjectDir: gradle.rootProject.rootDir.absolutePath,
+            requestedTasks: gradle.startParameter.taskNames.join(" "),
+            gradleVersion: GradleVersion.current().version,
+            gradleHomeDir: gradle.gradleHomeDir.absolutePath,
+            buildFailed: result.failure != null,
+            buildScanUri: null
+        ]
+
+        def buildResultsDir = new File(System.getenv("RUNNER_TEMP"), ".build-results")
+        buildResultsDir.mkdirs()
+        def buildResultsFile = new File(buildResultsDir, System.getenv("GITHUB_ACTION") + invocationId + ".json")
+        // Don't overwrite file generated by build-scan plugin if present (which has build-scan-uri)
+        if (!buildResultsFile.exists()) {
+            buildResultsFile << groovy.json.JsonOutput.toJson(buildResults)
+        }
+    }
+}
+
+def captureUsingBuildService(settings, invocationId) {
+    gradle.ext.invocationId = invocationId
+    apply from: 'build-result-capture-service.plugin.groovy'
+}