Fix example in action.yml

Improves logging for caching, and adds 2 experimental cache options:

- `gradle-home-cache-strict-match`: Avoid re-using a Gradle Home cache entry written by a different job. Only cache entries written by the current Job will be used.
- `cache-write-only`: Do not restore existing cache entries, but still save cache entries in post-action.  Fixes #141.

.github/workflows/failure-cases.yml

@@ -4,7 +4,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
 
 jobs:
 

.github/workflows/integTest-action-inputs.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
 
 jobs:
   action-inputs:

.github/workflows/integTest-caching-config.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
   GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true
 
 jobs:
@@ -46,7 +46,7 @@ jobs:
     - name: Setup Gradle
       uses: ./
       with:
-        # Use the same configuration when restoring state from cache
+        # Use the same configuration as used in the seed build
         gradle-home-cache-includes: |
             caches
             enterprise
@@ -57,4 +57,86 @@ jobs:
       working-directory: __tests__/samples/groovy-dsl
       run: ./gradlew test --offline
 
+  # Test that build scans are captured when caching is explicitly disabled
+  cache-disabled:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout sources
+      uses: actions/checkout@v2
+    - name: Setup Gradle
+      uses: ./
+      with:
+        cache-disabled: true
+    - name: Run Gradle build
+      id: gradle
+      working-directory: __tests__/samples/no-wrapper${{ matrix.build-root-suffix }}
+      run: gradle help "-DgradleVersionCheck=${{matrix.gradle}}"
+    - name: Check build scan url is captured
+      if: ${{ !steps.gradle.outputs.build-scan-url }}
+      uses: actions/github-script@v3
+      with:
+        script: |
+          core.setFailed('No build scan detected')
+
+  # Test that build scans are captured when caching is disabled because Gradle User Home already exists
+  cache-disabled-pre-existing-gradle-home:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout sources
+      uses: actions/checkout@v2
+    - name: Create dummy Gradle User Home
+      run: mkdir -p ~/.gradle/caches
+    - name: Setup Gradle
+      uses: ./
+    - name: Run Gradle build
+      id: gradle
+      working-directory: __tests__/samples/no-wrapper${{ matrix.build-root-suffix }}
+      run: gradle help "-DgradleVersionCheck=${{matrix.gradle}}"
+    - name: Check build scan url is captured
+      if: ${{ !steps.gradle.outputs.build-scan-url }}
+      uses: actions/github-script@v3
+      with:
+        script: |
+          core.setFailed('No build scan detected')
+
+  # Test seed the cache with cache-write-only and verify with cache-read-only
+  seed-build-write-only:
+    env:
+      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-write-only-
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout sources
+      uses: actions/checkout@v2
+    - name: Setup Gradle
+      uses: ./
+      with:
+        cache-write-only: true
+    - name: Build using Gradle wrapper
+      working-directory: __tests__/samples/groovy-dsl
+      run: ./gradlew test
+
+  verify-write-only-build:
+    env:
+      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-write-only-
+    needs: seed-build-write-only
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout sources
+      uses: actions/checkout@v2
+    - name: Setup Gradle
+      uses: ./
+      with:
+        cache-read-only: true
+    - name: Execute Gradle build with --offline
+      working-directory: __tests__/samples/groovy-dsl
+      run: ./gradlew test --offline
 

.github/workflows/integTest-caching-configuration-cache.yml

@@ -14,7 +14,7 @@ jobs:
   # These builds should start fresh without cache hits, due to the seed injected into the cache key above.
   seed-build-groovy:
     env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-groovy-
+      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-groovy-
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest]
@@ -30,7 +30,7 @@ jobs:
 
   configuration-cache-groovy:
     env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-groovy-
+      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-groovy-
     needs: seed-build-groovy
     strategy:
       matrix:
@@ -52,7 +52,7 @@ jobs:
   # Check that the build can run when no extracted cache entries are restored
   no-extracted-cache-entries-restored:
     env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-groovy-
+      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-groovy-
     needs: seed-build-groovy
     strategy:
       matrix:
@@ -73,7 +73,7 @@ jobs:
 
   seed-build-kotlin:
     env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-kotlin-
+      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-kotlin-
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest]
@@ -83,13 +83,13 @@ jobs:
       uses: actions/checkout@v2
     - name: Setup Gradle
       uses: ./
-    - name: Kotlin build with configuration-cache enabled
+    - name: Execute 'help' with configuration-cache enabled
       working-directory: __tests__/samples/kotlin-dsl
       run: ./gradlew help --configuration-cache
 
   modify-build-kotlin:
     env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-kotlin-
+      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-kotlin-
     needs: seed-build-kotlin
     strategy:
       matrix:
@@ -100,14 +100,14 @@ jobs:
       uses: actions/checkout@v2
     - name: Setup Gradle
       uses: ./
-    - name: Kotlin build with configuration-cache enabled
+    - name: Execute 'test' with configuration-cache enabled
       working-directory: __tests__/samples/kotlin-dsl
       run: ./gradlew test --configuration-cache
 
  # Test restore configuration-cache from the third build invocation
   configuration-cache-kotlin:
     env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-kotlin-
+      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-kotlin-
     needs: modify-build-kotlin
     strategy:
       matrix:
@@ -120,7 +120,7 @@ jobs:
       uses: ./
       with:
         cache-read-only: true
-    - name: Execute Gradle build and verify cached configuration
+    - name: Execute 'test' again and verify cached configuration
       env: 
         VERIFY_CACHED_CONFIGURATION: true
       working-directory: __tests__/samples/kotlin-dsl

.github/workflows/integTest-caching-gradle-home.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
 
 jobs:
   seed-build:

.github/workflows/integTest-caching-java-toolchain.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
 
 jobs:
   seed-build:

.github/workflows/integTest-execution-with-caching.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
 
 jobs:
   seed-build:

.github/workflows/integTest-execution.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
 
 jobs:   
   # Tests for executing with different Gradle versions. 

.github/workflows/integTest-gradle-user-home.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
   GRADLE_USER_HOME: ${{github.workspace}}/custom/gradle/home
 
 jobs:

.github/workflows/integTest-gradle-versions.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
 
 jobs:   
   # Tests for executing with different Gradle versions. 

.github/workflows/integTest-sample-gradle-plugin.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
   GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true
 
 jobs:

.github/workflows/integTest-sample-kotlin-dsl.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}-
+  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
   GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true
 
 jobs:

.github/workflows/pr-build-scan-comment.yml

@@ -7,19 +7,20 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - uses: actions/setup-java@v1
+    - uses: actions/setup-java@v2
       with:
+        distribution: temurin
         java-version: 11
     - uses: ./
     - id: gradle
       working-directory: __tests__/samples/kotlin-dsl
       run: ./gradlew help
     - name: "Comment build scan url"
-      uses: actions/github-script@v3
+      uses: actions/github-script@v5
       with:
         github-token: ${{secrets.GITHUB_TOKEN}}
         script: |
-          github.issues.createComment({
+          github.rest.issues.createComment({
             issue_number: context.issue.number,
             owner: context.repo.owner,
             repo: context.repo.repo,

README.md

@@ -20,8 +20,9 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v2
-    - uses: actions/setup-java@v1
+    - uses: actions/setup-java@v2
       with:
+        distribution: temurin
         java-version: 11
         
     - name: Setup Gradle
@@ -33,7 +34,7 @@ jobs:
 
 ## Why use the `gradle-build-action`?
 
-It is possible to directly invoke Gradle in your workflow, and the `setup-java` action provides a simple way to cache Gradle dependencies. 
+It is possible to directly invoke Gradle in your workflow, and the `actions/setup-java@v2` action provides a simple way to cache Gradle dependencies. 
 
 However, the `gradle-build-action` offers a number of advantages over this approach:
 
@@ -45,6 +46,8 @@ However, the `gradle-build-action` offers a number of advantages over this appro
 The `gradle-build-action` is designed to provide these benefits with minimal configuration. 
 These features work both when Gradle is executed via the `gradle-build-action` and for any Gradle execution in subsequent steps.
 
+When using `gradle-build-action` we recommend that you _not_ use `actions/cache` or `actions/setup-java@v2` to explicitly cache the Gradle User Home. Doing so may interfere with the caching provided by this action.
+
 ## Use a specific Gradle version
 
 The `gradle-build-action` can download and install a specified Gradle version, adding this installed version to the PATH.
@@ -80,7 +83,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - uses: actions/setup-java@v1
+    - uses: actions/setup-java@v2
       with:
         java-version: 11
     - uses: gradle/gradle-build-action@v2
@@ -106,7 +109,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v2
-    - uses: actions/setup-java@v1
+    - uses: actions/setup-java@v2
       with:
         java-version: 11
     
@@ -302,19 +305,20 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - uses: actions/setup-java@v1
+    - uses: actions/setup-java@v2
       with:
+        distribution: temurin
         java-version: 11
     - uses: gradle/gradle-build-action@v2
     - id: gradle
       run: ./gradlew build
     - name: "Comment build scan url"
-      uses: actions/github-script@v3
+      uses: actions/github-script@v5
       if: github.event_name == 'pull_request' && failure()
       with:
         github-token: ${{secrets.GITHUB_TOKEN}}
         script: |
-          github.issues.createComment({
+          github.rest.issues.createComment({
             issue_number: context.issue.number,
             owner: context.repo.owner,
             repo: context.repo.repo,

action.yml

@@ -32,7 +32,7 @@ inputs:
     required: false
   # e.g. Use the following setting to prevent the local build cache from being saved/restored
   #      gradle-home-cache-excludes: |
-  #           ["caches/build-cache-1"]
+  #           caches/build-cache-1
 
   arguments:
     description: Gradle command line arguments (supports multi-line input)
@@ -48,8 +48,16 @@ inputs:
 
   # EXPERIMENTAL & INTERNAL ACTION INPUTS
   # The following action properties allow fine-grained tweaking of the action caching behaviour.
-  # These properties are not designed for production use, and may change without notice in a subsequent release of `gradle-build-action`.
+  # These properties are experimental and not (yet) designed for production use, and may change without notice in a subsequent release of `gradle-build-action`.
   # Use at your own risk!
+  cache-write-only:
+    description: When 'true', entries will not be restored from the cache but will be saved at the end of the Job. This allows a 'clean' cache entry to be written.
+    required: false
+    default: false
+  gradle-home-cache-strict-match:
+    description: When 'true', the action will not attempt to restore the Gradle User Home entries from other Jobs.
+    required: false
+    default: false
   workflow-job-context:
     description: Used to uniquely identify the current job invocation. Defaults to the matrix values for this job; this should not be overridden by users (INTERNAL).
     required: false

src/cache-base.ts

@@ -15,12 +15,14 @@ import {
 } from './cache-utils'
 import {ConfigurationCacheEntryExtractor, GradleHomeEntryExtractor} from './cache-extract-entries'
 
-const CACHE_PROTOCOL_VERSION = 'v5-'
+const CACHE_PROTOCOL_VERSION = 'v6-'
+const RESTORED_CACHE_KEY_KEY = 'restored-cache-key'
 
 export const META_FILE_DIR = '.gradle-build-action'
 export const PROJECT_ROOTS_FILE = 'project-roots.txt'
 const INCLUDE_PATHS_PARAMETER = 'gradle-home-cache-includes'
 const EXCLUDE_PATHS_PARAMETER = 'gradle-home-cache-excludes'
+const STRICT_CACHE_MATCH_PARAMETER = 'gradle-home-cache-strict-match'
 
 /**
  * Represents a key used to restore a cache entry.
@@ -70,14 +72,16 @@ function generateCacheKey(cacheName: string): CacheKey {
     // Exact match on Git SHA
     const cacheKey = `${cacheKeyForJobContext}-${github.context.sha}`
 
+    if (core.getBooleanInput(STRICT_CACHE_MATCH_PARAMETER)) {
+        return new CacheKey(cacheKey, [cacheKeyForJobContext])
+    }
+
     return new CacheKey(cacheKey, [cacheKeyForJobContext, cacheKeyForJob, cacheKeyForOs])
 }
 
 export class GradleStateCache {
     private cacheName: string
     private cacheDescription: string
-    private cacheKeyStateKey: string
-    private cacheResultStateKey: string
 
     protected readonly gradleUserHome: string
 
@@ -85,8 +89,6 @@ export class GradleStateCache {
         this.gradleUserHome = gradleUserHome
         this.cacheName = 'gradle'
         this.cacheDescription = 'Gradle User Home'
-        this.cacheKeyStateKey = `CACHE_KEY_gradle`
-        this.cacheResultStateKey = `CACHE_RESULT_gradle`
     }
 
     init(): void {
@@ -99,6 +101,17 @@ export class GradleStateCache {
         this.initializeGradleUserHome(this.gradleUserHome, initScriptsDir)
     }
 
+    cacheOutputExists(): boolean {
+        const paths = this.getCachePath()
+        for (const p of paths) {
+            if (fs.existsSync(p)) {
+                cacheDebug(`Cache output exists at ${p}`)
+                return true
+            }
+        }
+        return false
+    }
+
     /**
      * Restores the cache entry, finding the closest match to the currently running job.
      */
@@ -106,7 +119,6 @@ export class GradleStateCache {
         const entryListener = listener.entry(this.cacheDescription)
 
         const cacheKey = generateCacheKey(this.cacheName)
-        core.saveState(this.cacheKeyStateKey, cacheKey.key)
 
         cacheDebug(
             `Requesting ${this.cacheDescription} with
@@ -114,16 +126,13 @@ export class GradleStateCache {
     restoreKeys:[${cacheKey.restoreKeys}]`
         )
 
-        const cacheResult = await restoreCache(this.getCachePath(), cacheKey.key, cacheKey.restoreKeys)
-        entryListener.markRequested(cacheKey.key, cacheKey.restoreKeys)
-
+        const cacheResult = await restoreCache(this.getCachePath(), cacheKey.key, cacheKey.restoreKeys, entryListener)
         if (!cacheResult) {
             core.info(`${this.cacheDescription} cache not found. Will initialize empty.`)
             return
         }
 
-        core.saveState(this.cacheResultStateKey, cacheResult.key)
-        entryListener.markRestored(cacheResult.key, cacheResult.size)
+        core.saveState(RESTORED_CACHE_KEY_KEY, cacheResult.key)
 
         core.info(`Restored ${this.cacheDescription} from cache key: ${cacheResult.key}`)
 
@@ -152,12 +161,11 @@ export class GradleStateCache {
      * it is saved with the exact key.
      */
     async save(listener: CacheListener): Promise<void> {
-        // Retrieve the state set in the previous 'restore' step.
-        const cacheKeyFromRestore = core.getState(this.cacheKeyStateKey)
-        const cacheResultFromRestore = core.getState(this.cacheResultStateKey)
+        const cacheKey = generateCacheKey(this.cacheName).key
+        const restoredCacheKey = core.getState(RESTORED_CACHE_KEY_KEY)
 
-        if (cacheResultFromRestore && cacheKeyFromRestore === cacheResultFromRestore) {
-            core.info(`Cache hit occurred on the cache key ${cacheKeyFromRestore}, not saving cache.`)
+        if (restoredCacheKey && cacheKey === restoredCacheKey) {
+            core.info(`Cache hit occurred on the cache key ${cacheKey}, not saving cache.`)
             return
         }
 
@@ -168,13 +176,10 @@ export class GradleStateCache {
             return
         }
 
-        core.info(`Caching ${this.cacheDescription} with cache key: ${cacheKeyFromRestore}`)
+        core.info(`Caching ${this.cacheDescription} with cache key: ${cacheKey}`)
         const cachePath = this.getCachePath()
-        const savedEntry = await saveCache(cachePath, cacheKeyFromRestore)
-
-        if (savedEntry) {
-            listener.entry(this.cacheDescription).markSaved(savedEntry.key, savedEntry.size)
-        }
+        const entryListener = listener.entry(this.cacheDescription)
+        await saveCache(cachePath, cacheKey, entryListener)
 
         return
     }
@@ -237,7 +242,7 @@ export class GradleStateCache {
             buildScanCapture,
             `import org.gradle.util.GradleVersion
 
-// Only run again root build. Do not run against included builds.
+// Only run against root build. Do not run against included builds.
 def isTopLevelBuild = gradle.getParent() == null
 if (isTopLevelBuild) {
     def version = GradleVersion.current().baseVersion
@@ -261,19 +266,23 @@ if (isTopLevelBuild) {
 
 def registerCallbacks(buildScanExtension, rootProjectName) {
     buildScanExtension.with {
-        def buildOutcome = ""
         def scanFile = new File("gradle-build-scan.txt")
+        def buildFailed = false
 
         buildFinished { result ->
-            buildOutcome = result.failure == null ? " succeeded" : " failed"
+            buildFailed = (result.failure != null)
         }
 
         buildScanPublished { buildScan ->
             scanFile.text = buildScan.buildScanUri
 
             // Send commands directly to GitHub Actions via STDOUT.
-            def message = "Build '\${rootProjectName}'\${buildOutcome} - \${buildScan.buildScanUri}"
-            println("::notice ::\${message}")
+            def gradleCommand = rootProjectName + " " + gradle.startParameter.taskNames.join(" ")
+            if (buildFailed) {
+                println("::warning ::Gradle build '\${gradleCommand}' FAILED - \${buildScan.buildScanUri}")
+            } else {
+                println("::notice ::Gradle build '\${gradleCommand}' - \${buildScan.buildScanUri}")
+            }
             println("::set-output name=build-scan-url::\${buildScan.buildScanUri}")
         }
     }
@@ -284,7 +293,7 @@ def registerCallbacks(buildScanExtension, rootProjectName) {
         fs.writeFileSync(
             projectRootCapture,
             `
-// Only run again root build. Do not run against included builds.
+// Only run against root build. Do not run against included builds.
 def isTopLevelBuild = gradle.getParent() == null
 if (isTopLevelBuild) {
     settingsEvaluated { settings ->

src/cache-extract-entries.ts

@@ -118,12 +118,9 @@ abstract class AbstractEntryExtractor {
         pattern: string,
         listener: CacheEntryListener
     ): Promise<ExtractedCacheEntry> {
-        listener.markRequested(cacheKey)
-
-        const restoredEntry = await restoreCache([pattern], cacheKey)
+        const restoredEntry = await restoreCache([pattern], cacheKey, [], listener)
         if (restoredEntry) {
             core.info(`Restored ${artifactType} with key ${cacheKey} to ${pattern}`)
-            listener.markRestored(restoredEntry.key, restoredEntry.size)
             return new ExtractedCacheEntry(artifactType, pattern, cacheKey)
         } else {
             core.info(`Did not restore ${artifactType} with key ${cacheKey} to ${pattern}`)
@@ -217,10 +214,7 @@ abstract class AbstractEntryExtractor {
             cacheDebug(`No change to previously restored ${artifactType}. Not saving.`)
         } else {
             core.info(`Caching ${artifactType} with path '${pattern}' and cache key: ${cacheKey}`)
-            const savedEntry = await saveCache([pattern], cacheKey)
-            if (savedEntry !== undefined) {
-                entryListener.markSaved(savedEntry.key, savedEntry.size)
-            }
+            await saveCache([pattern], cacheKey, entryListener)
         }
 
         for (const file of matchingFiles) {

src/cache-reporting.ts

@@ -28,6 +28,9 @@ export class CacheListener {
     }
 
     static rehydrate(stringRep: string): CacheListener {
+        if (stringRep === '') {
+            return new CacheListener()
+        }
         const rehydrated: CacheListener = Object.assign(new CacheListener(), JSON.parse(stringRep))
         const entries = rehydrated.cacheEntries
         for (let index = 0; index < entries.length; index++) {
@@ -76,6 +79,12 @@ export class CacheEntryListener {
         this.savedSize = size
         return this
     }
+
+    markAlreadyExists(key: string): CacheEntryListener {
+        this.savedKey = key
+        this.savedSize = 0
+        return this
+    }
 }
 
 export function logCachingReport(listener: CacheListener): void {
@@ -112,12 +121,18 @@ function getSum(
     cacheEntries: CacheEntryListener[],
     predicate: (value: CacheEntryListener) => number | undefined
 ): string {
+    if (cacheEntries.length === 0) {
+        return '0'
+    }
     return formatSize(cacheEntries.map(e => predicate(e) ?? 0).reduce((p, v) => p + v, 0))
 }
 
 function formatSize(bytes: number | undefined): string {
-    if (bytes === undefined || bytes === 0) {
+    if (bytes === undefined) {
         return ''
     }
+    if (bytes === 0) {
+        return '0 (Entry already exists)'
+    }
     return `${Math.round(bytes / (1024 * 1024))} MB (${bytes} B)`
 }

src/cache-utils.ts

@@ -4,9 +4,12 @@ import * as crypto from 'crypto'
 import * as path from 'path'
 import * as fs from 'fs'
 
+import {CacheEntryListener} from './cache-reporting'
+
 const JOB_CONTEXT_PARAMETER = 'workflow-job-context'
 const CACHE_DISABLED_PARAMETER = 'cache-disabled'
 const CACHE_READONLY_PARAMETER = 'cache-read-only'
+const CACHE_WRITEONLY_PARAMETER = 'cache-write-only'
 const CACHE_DEBUG_VAR = 'GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED'
 const CACHE_PREFIX_VAR = 'GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX'
 
@@ -18,6 +21,10 @@ export function isCacheReadOnly(): boolean {
     return core.getBooleanInput(CACHE_READONLY_PARAMETER)
 }
 
+export function isCacheWriteOnly(): boolean {
+    return core.getBooleanInput(CACHE_WRITEONLY_PARAMETER)
+}
+
 export function isCacheDebuggingEnabled(): boolean {
     return process.env[CACHE_DEBUG_VAR] ? true : false
 }
@@ -49,23 +56,32 @@ export function hashStrings(values: string[]): string {
 export async function restoreCache(
     cachePath: string[],
     cacheKey: string,
-    cacheRestoreKeys: string[] = []
+    cacheRestoreKeys: string[],
+    listener: CacheEntryListener
 ): Promise<cache.CacheEntry | undefined> {
+    listener.markRequested(cacheKey, cacheRestoreKeys)
     try {
-        return await cache.restoreCache(cachePath, cacheKey, cacheRestoreKeys)
+        const restoredEntry = await cache.restoreCache(cachePath, cacheKey, cacheRestoreKeys)
+        if (restoredEntry !== undefined) {
+            listener.markRestored(restoredEntry.key, restoredEntry.size)
+        }
+        return restoredEntry
     } catch (error) {
         handleCacheFailure(error, `Failed to restore ${cacheKey}`)
         return undefined
     }
 }
 
-export async function saveCache(cachePath: string[], cacheKey: string): Promise<cache.CacheEntry | undefined> {
+export async function saveCache(cachePath: string[], cacheKey: string, listener: CacheEntryListener): Promise<void> {
     try {
-        return await cache.saveCache(cachePath, cacheKey)
+        const savedEntry = await cache.saveCache(cachePath, cacheKey)
+        listener.markSaved(savedEntry.key, savedEntry.size)
     } catch (error) {
+        if (error instanceof cache.ReserveCacheError) {
+            listener.markAlreadyExists(cacheKey)
+        }
         handleCacheFailure(error, `Failed to save cache entry ${cacheKey}`)
     }
-    return undefined
 }
 
 export function cacheDebug(message: string): void {
@@ -83,11 +99,7 @@ export function handleCacheFailure(error: unknown, message: string): void {
     }
     if (error instanceof cache.ReserveCacheError) {
         // Reserve cache errors are expected if the artifact has been previously cached
-        if (isCacheDebuggingEnabled()) {
-            core.info(`${message}: ${error}`)
-        } else {
-            core.debug(`${message}: ${error}`)
-        }
+        core.info(`${message}: ${error}`)
     } else {
         // Warn on all other errors
         core.warning(`${message}: ${error}`)

src/caches.ts

@@ -1,5 +1,5 @@
 import * as core from '@actions/core'
-import {isCacheDisabled, isCacheReadOnly} from './cache-utils'
+import {isCacheDisabled, isCacheReadOnly, isCacheWriteOnly} from './cache-utils'
 import {logCachingReport, CacheListener} from './cache-reporting'
 import {GradleStateCache} from './cache-base'
 
@@ -8,26 +8,46 @@ const GRADLE_USER_HOME = 'GRADLE_USER_HOME'
 const CACHE_LISTENER = 'CACHE_LISTENER'
 
 export async function restore(gradleUserHome: string): Promise<void> {
-    if (!shouldRestoreCaches()) {
+    // Bypass restore cache on all but first action step in workflow.
+    if (process.env[CACHE_RESTORED_VAR]) {
+        core.info('Cache only restored on first action step.')
+        return
+    }
+    core.exportVariable(CACHE_RESTORED_VAR, true)
+
+    const gradleStateCache = new GradleStateCache(gradleUserHome)
+
+    if (isCacheDisabled()) {
+        core.info('Cache is disabled: will not restore state from previous builds.')
+        // Initialize the Gradle User Home even when caching is disabled.
+        gradleStateCache.init()
+        return
+    }
+
+    if (gradleStateCache.cacheOutputExists()) {
+        core.info('Gradle User Home already exists: will not restore from cache.')
+        // Initialize pre-existing Gradle User Home.
+        gradleStateCache.init()
         return
     }
 
-    const gradleStateCache = new GradleStateCache(gradleUserHome)
     gradleStateCache.init()
+    // Mark the state as restored so that post-action will perform save.
+    core.saveState(CACHE_RESTORED_VAR, true)
+    // Save the Gradle User Home for the post-action step.
+    core.saveState(GRADLE_USER_HOME, gradleUserHome)
+
+    if (isCacheWriteOnly()) {
+        core.info('Cache is write-only: will not restore from cache.')
+        return
+    }
 
     await core.group('Restore Gradle state from cache', async () => {
-        core.saveState(GRADLE_USER_HOME, gradleUserHome)
-
         const cacheListener = new CacheListener()
         await gradleStateCache.restore(cacheListener)
 
         core.saveState(CACHE_LISTENER, cacheListener.stringify())
     })
-
-    // Export var that is detected in all later restore steps
-    core.exportVariable(CACHE_RESTORED_VAR, true)
-    // Export state that is detected in corresponding post-action step
-    core.saveState(CACHE_RESTORED_VAR, true)
 }
 
 export async function save(): Promise<void> {
@@ -51,19 +71,6 @@ export async function save(): Promise<void> {
     logCachingReport(cacheListener)
 }
 
-function shouldRestoreCaches(): boolean {
-    if (isCacheDisabled()) {
-        core.info('Cache is disabled: will not restore state from previous builds.')
-        return false
-    }
-
-    if (process.env[CACHE_RESTORED_VAR]) {
-        core.info('Cache only restored on first action step.')
-        return false
-    }
-    return true
-}
-
 function shouldSaveCaches(): boolean {
     if (isCacheDisabled()) {
         core.info('Cache is disabled: will not save state for later builds.')
@@ -71,7 +78,7 @@ function shouldSaveCaches(): boolean {
     }
 
     if (!core.getState(CACHE_RESTORED_VAR)) {
-        core.info('Cache will only be saved in final post-action step.')
+        core.info('Cache will not be saved: not restored in main action step.')
         return false
     }
 

src/execution.ts

@@ -14,6 +14,7 @@ export async function executeGradleBuild(executable: string | undefined, root: s
 
     // Use the provided executable, or look for a Gradle wrapper script to run
     const toExecute = executable ?? gradlew.locateGradleWrapperScript(root)
+    verifyIsExecutableScript(toExecute)
     const status: number = await exec.exec(toExecute, args, {
         cwd: root,
         ignoreReturnCode: true
@@ -31,3 +32,11 @@ export async function executeGradleBuild(executable: string | undefined, root: s
         }
     }
 }
+
+function verifyIsExecutableScript(toExecute: string): void {
+    try {
+        fs.accessSync(toExecute, fs.constants.X_OK)
+    } catch (err) {
+        throw new Error(`Gradle script '${toExecute}' is not executable.`)
+    }
+}