Merge pull request #123 from gradle/toward-setup-gradle

Avoid using command-line modification to enhance build execution. Instead, files are written to Gradle User Home to achieve the same functionality.

src/build-scan-capture.ts

@@ -1,50 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import * as core from '@actions/core'
-
-export function writeInitScript(): string {
-    const tmpDir = process.env['RUNNER_TEMP'] || ''
-    const initScript = path.resolve(tmpDir, 'build-scan-capture.init.gradle')
-    core.info(`Writing init script: ${initScript}`)
-    if (fs.existsSync(initScript)) {
-        return initScript
-    }
-    fs.writeFileSync(
-        initScript,
-        `
-import org.gradle.util.GradleVersion
-
-// Don't run against the included builds (if the main build has any).
-def isTopLevelBuild = gradle.getParent() == null
-if (isTopLevelBuild) {
-    def version = GradleVersion.current().baseVersion
-    def atLeastGradle4 = version >= GradleVersion.version("4.0")
-    def atLeastGradle6 = version >= GradleVersion.version("6.0")
-
-    if (atLeastGradle6) {
-        settingsEvaluated { settings ->
-            if (settings.pluginManager.hasPlugin("com.gradle.enterprise")) {
-                registerCallbacks(settings.extensions["gradleEnterprise"].buildScan, settings.rootProject.name)
-            }
-        }
-    } else if (atLeastGradle4) {
-        projectsEvaluated { gradle ->
-            if (gradle.rootProject.pluginManager.hasPlugin("com.gradle.build-scan")) {
-                registerCallbacks(gradle.rootProject.extensions["buildScan"], gradle.rootProject.name)
-            }
-        }
-    }
-}
-
-def registerCallbacks(buildScanExtension, rootProjectName) {
-    buildScanExtension.with {
-        def scanFile = new File("gradle-build-scan.txt")
-        buildScanPublished { buildScan ->
-            scanFile.text = buildScan.buildScanUri
-        }
-    }
-}
-`
-    )
-    return initScript
-}

src/cache-base.ts

@@ -146,7 +146,7 @@ export abstract class AbstractCache {
         const cacheResult = await this.restoreCache(this.getCachePath(), cacheKey.key, cacheKey.restoreKeys)
 
         if (!cacheResult) {
-            core.info(`${this.cacheDescription} cache not found. Will start with empty.`)
+            core.info(`${this.cacheDescription} cache not found. Will initialize empty.`)
             return
         }
 

src/cache-gradle-user-home.ts

@@ -22,6 +22,11 @@ export class GradleUserHomeCache extends AbstractCache {
         this.gradleUserHome = this.determineGradleUserHome(rootDir)
     }
 
+    init(): void {
+        this.debug(`Initializing Gradle User Home with properties and init script: ${this.gradleUserHome}`)
+        initializeGradleUserHome(this.gradleUserHome)
+    }
+
     async afterRestore(listener: CacheListener): Promise<void> {
         await this.reportGradleUserHomeSize('as restored from cache')
         await this.restoreArtifactBundles(listener)
@@ -254,3 +259,59 @@ export class GradleUserHomeCache extends AbstractCache {
         core.info('-----------------------')
     }
 }
+
+function initializeGradleUserHome(gradleUserHome: string): void {
+    fs.mkdirSync(gradleUserHome, {recursive: true})
+
+    const propertiesFile = path.resolve(gradleUserHome, 'gradle.properties')
+    fs.writeFileSync(propertiesFile, 'org.gradle.daemon=false')
+
+    const initScript = path.resolve(gradleUserHome, 'init.gradle')
+    fs.writeFileSync(
+        initScript,
+        `
+import org.gradle.util.GradleVersion
+
+// Don't run against the included builds (if the main build has any).
+def isTopLevelBuild = gradle.getParent() == null
+if (isTopLevelBuild) {
+    def version = GradleVersion.current().baseVersion
+    def atLeastGradle4 = version >= GradleVersion.version("4.0")
+    def atLeastGradle6 = version >= GradleVersion.version("6.0")
+
+    if (atLeastGradle6) {
+        settingsEvaluated { settings ->
+            if (settings.pluginManager.hasPlugin("com.gradle.enterprise")) {
+                registerCallbacks(settings.extensions["gradleEnterprise"].buildScan, settings.rootProject.name)
+            }
+        }
+    } else if (atLeastGradle4) {
+        projectsEvaluated { gradle ->
+            if (gradle.rootProject.pluginManager.hasPlugin("com.gradle.build-scan")) {
+                registerCallbacks(gradle.rootProject.extensions["buildScan"], gradle.rootProject.name)
+            }
+        }
+    }
+}
+
+def registerCallbacks(buildScanExtension, rootProjectName) {
+    buildScanExtension.with {
+        def buildOutcome = ""
+        def scanFile = new File("gradle-build-scan.txt")
+
+        buildFinished { result ->
+            buildOutcome = result.failure == null ? " succeeded" : " failed"
+        }
+
+        buildScanPublished { buildScan ->
+            scanFile.text = buildScan.buildScanUri
+
+            // Send commands directly to GitHub Actions via STDOUT.
+            println("::notice title=Build '\${rootProjectName}'\${buildOutcome}::\${buildScan.buildScanUri}")
+            println("::set-output name=build-scan-url::\${buildScan.buildScanUri}")
+        }
+    }
+}
+`
+    )
+}

src/caches.ts

@@ -8,6 +8,11 @@ const BUILD_ROOT_DIR = 'BUILD_ROOT_DIR'
 const CACHE_LISTENER = 'CACHE_LISTENER'
 
 export async function restore(buildRootDirectory: string): Promise<void> {
+    const gradleUserHomeCache = new GradleUserHomeCache(buildRootDirectory)
+    const projectDotGradleCache = new ProjectDotGradleCache(buildRootDirectory)
+
+    gradleUserHomeCache.init()
+
     if (isCacheDisabled()) {
         core.info('Cache is disabled: will not restore state from previous builds.')
         return
@@ -17,9 +22,8 @@ export async function restore(buildRootDirectory: string): Promise<void> {
         core.saveState(BUILD_ROOT_DIR, buildRootDirectory)
 
         const cacheListener = new CacheListener()
-        await new GradleUserHomeCache(buildRootDirectory).restore(cacheListener)
+        await gradleUserHomeCache.restore(cacheListener)
 
-        const projectDotGradleCache = new ProjectDotGradleCache(buildRootDirectory)
         if (cacheListener.fullyRestored) {
             // Only restore the configuration-cache if the Gradle Home is fully restored
             await projectDotGradleCache.restore(cacheListener)

src/execution.ts

@@ -1,18 +1,10 @@
 import * as exec from '@actions/exec'
 import fs from 'fs'
 import path from 'path'
-import {writeInitScript} from './build-scan-capture'
 
 export async function execute(executable: string, root: string, args: string[]): Promise<BuildResult> {
     let buildScanUrl: string | undefined
 
-    // TODO: instead of running with no-daemon, run `--stop` in post action.
-    args.push('--no-daemon')
-
-    const initScript = writeInitScript()
-    args.push('--init-script')
-    args.push(initScript)
-
     const buildScanFile = path.resolve(root, 'gradle-build-scan.txt')
     if (fs.existsSync(buildScanFile)) {
         fs.unlinkSync(buildScanFile)

src/main.ts

@@ -23,20 +23,12 @@ export async function run(): Promise<void> {
             args
         )
 
-        if (result.buildScanUrl) {
-            core.setOutput('build-scan-url', result.buildScanUrl)
-        }
-
         if (result.status !== 0) {
             if (result.buildScanUrl) {
                 core.setFailed(`Gradle build failed: ${result.buildScanUrl}`)
             } else {
                 core.setFailed(`Gradle build failed: process exited with status ${result.status}`)
             }
-        } else {
-            if (result.buildScanUrl) {
-                core.notice(`Gradle build succeeded: ${result.buildScanUrl}`)
-            }
         }
     } catch (error) {
         core.setFailed(String(error))