Avoid failing build on distributions cache errors

- Warn and continue on failure to restore a Gradle distribution from cache
- Warn and continue on failure to save a Gradle distribution to cache
- Extract common functionality for consistent handling of cache failures

Fixes #116

src/cache-base.ts

@@ -1,7 +1,7 @@
 import * as core from '@actions/core'
 import * as cache from '@actions/cache'
 import * as github from '@actions/github'
-import {isCacheDebuggingEnabled, getCacheKeyPrefix, hashStrings} from './cache-utils'
+import {isCacheDebuggingEnabled, getCacheKeyPrefix, hashStrings, handleCacheFailure} from './cache-utils'
 
 const JOB_CONTEXT_PARAMETER = 'workflow-job-context'
 
@@ -176,12 +176,7 @@ export abstract class AbstractCache {
         try {
             return await cache.restoreCache(cachePath, cacheKey, cacheRestoreKeys)
         } catch (error) {
-            if (error instanceof cache.ValidationError) {
-                // Validation errors should fail the build action
-                throw error
-            }
-            // Warn about any other error and continue
-            core.warning(`Failed to restore ${cacheKey}: ${error}`)
+            handleCacheFailure(error, `Failed to restore ${cacheKey}`)
             return undefined
         }
     }
@@ -231,16 +226,7 @@ export abstract class AbstractCache {
         try {
             return await cache.saveCache(cachePath, cacheKey)
         } catch (error) {
-            if (error instanceof cache.ValidationError) {
-                // Validation errors should fail the build action
-                throw error
-            } else if (error instanceof cache.ReserveCacheError) {
-                // Reserve cache errors are expected if the artifact has been previously cached
-                this.debug(error.message)
-            } else {
-                // Warn about any other error and continue
-                core.warning(String(error))
-            }
+            handleCacheFailure(error, `Failed to save cache entry ${cacheKey}`)
         }
         return undefined
     }

src/cache-utils.ts

@@ -1,4 +1,5 @@
 import * as core from '@actions/core'
+import * as cache from '@actions/cache'
 import * as crypto from 'crypto'
 import * as path from 'path'
 import * as fs from 'fs'
@@ -39,6 +40,24 @@ export function hashFileNames(fileNames: string[]): string {
     return hashStrings(fileNames.map(x => x.replace(new RegExp(`\\${path.sep}`, 'g'), '/')))
 }
 
+export function handleCacheFailure(error: unknown, message: string): void {
+    if (error instanceof cache.ValidationError) {
+        // Fail on cache validation errors
+        throw error
+    }
+    if (error instanceof cache.ReserveCacheError) {
+        // Reserve cache errors are expected if the artifact has been previously cached
+        if (isCacheDebuggingEnabled()) {
+            core.info(message)
+        } else {
+            core.debug(message)
+        }
+    } else {
+        // Warn on all other errors
+        core.warning(`${message}: ${error}`)
+    }
+}
+
 /**
  * Attempt to delete a file or directory, waiting to allow locks to be released
  */

src/provision.ts

@@ -7,7 +7,7 @@ import * as cache from '@actions/cache'
 import * as toolCache from '@actions/tool-cache'
 
 import * as gradlew from './gradlew'
-import {isCacheDisabled, isCacheReadOnly} from './cache-utils'
+import {handleCacheFailure, isCacheDisabled, isCacheReadOnly} from './cache-utils'
 
 const gradleVersionsBaseUrl = 'https://services.gradle.org/versions'
 
@@ -109,23 +109,24 @@ async function downloadAndCacheGradleDistribution(versionInfo: GradleVersionInfo
     }
 
     const cacheKey = `gradle-${versionInfo.version}`
-    const restoreKey = await cache.restoreCache([downloadPath], cacheKey)
-    if (restoreKey) {
-        core.info(`Restored Gradle distribution ${cacheKey} from cache to ${downloadPath}`)
-        return downloadPath
+    try {
+        const restoreKey = await cache.restoreCache([downloadPath], cacheKey)
+        if (restoreKey) {
+            core.info(`Restored Gradle distribution ${cacheKey} from cache to ${downloadPath}`)
+            return downloadPath
+        }
+    } catch (error) {
+        handleCacheFailure(error, `Restore Gradle distribution ${versionInfo.version} failed`)
     }
+
     core.info(`Gradle distribution ${versionInfo.version} not found in cache. Will download.`)
     await downloadGradleDistribution(versionInfo, downloadPath)
 
     if (!isCacheReadOnly()) {
         try {
             await cache.saveCache([downloadPath], cacheKey)
         } catch (error) {
-            // Fail on validation errors or non-errors (the latter to keep Typescript happy)
-            if (error instanceof cache.ValidationError || !(error instanceof Error)) {
-                throw error
-            }
-            core.warning(error.message)
+            handleCacheFailure(error, `Save Gradle distribution ${versionInfo.version} failed`)
         }
     }
     return downloadPath