Cache Gradle distributions downloaded for a particular version

- Cache is separate from (but similar to) the wrapper distribution cache
- Renamed the 'wrapper-cache-enabled' flag to 'distributions-cache-enabled': this flag
  now controls both wrapper and regular distribution caching

README.md

@@ -122,7 +122,7 @@ jobs:
 
 This action provides 3 levels of caching to help speed up your GitHub Actions:
 
-- `wrapper` caches the local [wrapper](https://docs.gradle.org/current/userguide/gradle_wrapper.html) installation, saving time downloading and unpacking Gradle distributions ;
+- `distributions` caches the any downloaded Gradle zips, including any downloaded [wrapper](https://docs.gradle.org/current/userguide/gradle_wrapper.html) versions, saving time downloading and unpacking Gradle distributions ;
 - `dependencies` caches the [dependencies](https://docs.gradle.org/current/userguide/dependency_resolution.html#sub:cache_copy), saving time downloading dependencies ;
 - `configuration` caches the [build configuration](https://docs.gradle.org/nightly/userguide/configuration_cache.html), saving time configuring the build.
 
@@ -132,12 +132,12 @@ Future versions of this action will enable all caching by default.
 You can control which level is enabled as follows:
 
 ```yaml
-wrapper-cache-enabled: true
+distributions-cache-enabled: true
 dependencies-cache-enabled: true
 configuration-cache-enabled: true
 ```
 
-The wrapper installation cache is simple and can't be configured further.
+The distributions cache is simple and can't be configured further.
 
 The dependencies and configuration cache will compute a cache key in a best effort manner.
 Keep reading to learn how to better control how they work.

action.yml

@@ -17,8 +17,8 @@ inputs:
   arguments:
     description: Gradle command line arguments, see gradle --help
     required: false
-  wrapper-cache-enabled:
-    description: Whether caching wrapper installation is enabled or not, default to 'true'
+  distributions-cache-enabled:
+    description: Whether caching downloaded Gradle distributions is enabled or not, default to 'true'
     required: false
   dependencies-cache-enabled:
     description: Whether caching dependencies is enabled or not, default to 'false'

src/cache-wrapper.ts

@@ -12,7 +12,7 @@ const WRAPPER_SLUG = 'WRAPPER_SLUG'
 export async function restoreCachedWrapperDist(
     gradlewDirectory: string | null
 ): Promise<void> {
-    if (isWrapperCacheDisabled()) return
+    if (isDistributionsCacheDisabled()) return
     if (gradlewDirectory == null) return
 
     const wrapperProperties = path.join(
@@ -56,7 +56,7 @@ export async function restoreCachedWrapperDist(
 }
 
 export async function cacheWrapperDist(): Promise<void> {
-    if (isWrapperCacheDisabled()) return
+    if (isDistributionsCacheDisabled()) return
 
     const wrapperSlug = core.getState(WRAPPER_SLUG)
     if (!wrapperSlug) return
@@ -106,8 +106,8 @@ export function extractGradleWrapperSlugFromDistUri(
     return match ? match[1] : null
 }
 
-function isWrapperCacheDisabled(): boolean {
-    return !github.inputBoolean('wrapper-cache-enabled', true)
+function isDistributionsCacheDisabled(): boolean {
+    return !github.inputBoolean('distributions-cache-enabled', true)
 }
 
 function getCacheKey(wrapperSlug: string): string {

src/provision.ts

@@ -3,9 +3,11 @@ import * as os from 'os'
 import * as path from 'path'
 import * as httpm from '@actions/http-client'
 import * as core from '@actions/core'
+import * as cache from '@actions/cache'
 import * as toolCache from '@actions/tool-cache'
 
 import * as gradlew from './gradlew'
+import * as github from './github-utils'
 
 const gradleVersionsBaseUrl = 'https://services.gradle.org/versions'
 
@@ -31,7 +33,7 @@ async function gradleCurrent(): Promise<string> {
     const versionInfo = await gradleVersionDeclaration(
         `${gradleVersionsBaseUrl}/current`
     )
-    return provisionGradle(versionInfo.version, versionInfo.downloadUrl)
+    return provisionGradle(versionInfo)
 }
 
 async function gradleReleaseCandidate(): Promise<string> {
@@ -39,7 +41,7 @@ async function gradleReleaseCandidate(): Promise<string> {
         `${gradleVersionsBaseUrl}/release-candidate`
     )
     if (versionInfo && versionInfo.version && versionInfo.downloadUrl) {
-        return provisionGradle(versionInfo.version, versionInfo.downloadUrl)
+        return provisionGradle(versionInfo)
     }
     core.info('No current release-candidate found, will fallback to current')
     return gradleCurrent()
@@ -49,14 +51,14 @@ async function gradleNightly(): Promise<string> {
     const versionInfo = await gradleVersionDeclaration(
         `${gradleVersionsBaseUrl}/nightly`
     )
-    return provisionGradle(versionInfo.version, versionInfo.downloadUrl)
+    return provisionGradle(versionInfo)
 }
 
 async function gradleReleaseNightly(): Promise<string> {
     const versionInfo = await gradleVersionDeclaration(
         `${gradleVersionsBaseUrl}/release-nightly`
     )
-    return provisionGradle(versionInfo.version, versionInfo.downloadUrl)
+    return provisionGradle(versionInfo)
 }
 
 async function gradle(version: string): Promise<string> {
@@ -64,7 +66,7 @@ async function gradle(version: string): Promise<string> {
     if (!versionInfo) {
         throw new Error(`Gradle version ${version} does not exists`)
     }
-    return provisionGradle(versionInfo.version, versionInfo.downloadUrl)
+    return provisionGradle(versionInfo)
 }
 
 async function gradleVersionDeclaration(
@@ -84,41 +86,77 @@ async function findGradleVersionDeclaration(
     })
 }
 
-async function provisionGradle(version: string, url: string): Promise<string> {
-    const cachedInstall: string = toolCache.find('gradle', version)
-    if (cachedInstall.length > 0) {
-        const cachedExecutable = executableFrom(cachedInstall)
-        core.info(`Provisioned Gradle executable ${cachedExecutable}`)
-        return cachedExecutable
+async function provisionGradle(
+    versionInfo: GradleVersionInfo
+): Promise<string> {
+    const installsDir = path.join(os.homedir(), 'gradle-installations/installs')
+    const installDir = path.join(installsDir, `gradle-${versionInfo.version}`)
+    if (fs.existsSync(installDir)) {
+        core.info(`Gradle installation already exists at ${installDir}`)
+        return executableFrom(installDir)
     }
 
-    const tmpdir = path.join(os.homedir(), 'gradle-provision-tmpdir')
-
-    core.info(`Downloading ${url}`)
-
-    const downloadPath = path.join(
-        tmpdir,
-        `downloads/gradle-${version}-bin.zip`
-    )
-    await toolCache.downloadTool(url, downloadPath)
-    core.info(
-        `Downloaded at ${downloadPath}, size ${fs.statSync(downloadPath).size}`
-    )
-
-    const installsDir = path.join(tmpdir, 'installs')
+    const downloadPath = await downloadAndCacheGradleDistribution(versionInfo)
     await toolCache.extractZip(downloadPath, installsDir)
-    const installDir = path.join(installsDir, `gradle-${version}`)
-    core.info(`Extracted in ${installDir}`)
+    core.info(`Extracted Gradle ${versionInfo.version} to ${installDir}`)
 
     const executable = executableFrom(installDir)
     fs.chmodSync(executable, '755')
     core.info(`Provisioned Gradle executable ${executable}`)
 
-    toolCache.cacheDir(installDir, 'gradle', version)
-
     return executable
 }
 
+async function downloadAndCacheGradleDistribution(
+    versionInfo: GradleVersionInfo
+): Promise<string> {
+    const downloadPath = path.join(
+        os.homedir(),
+        `gradle-installations/downloads/gradle-${versionInfo.version}-bin.zip`
+    )
+
+    if (isDistributionsCacheDisabled()) {
+        await downloadGradleDistribution(versionInfo, downloadPath)
+        return downloadPath
+    }
+
+    const cacheKey = `gradle-${versionInfo.version}`
+    const restoreKey = await cache.restoreCache([downloadPath], cacheKey)
+    if (restoreKey) {
+        core.info(`Restored Gradle distribution ${cacheKey} from cache`)
+    } else {
+        core.info(
+            `Gradle distribution ${versionInfo.version} not found in cache. Will download.`
+        )
+        await downloadGradleDistribution(versionInfo, downloadPath)
+
+        try {
+            await cache.saveCache([downloadPath], cacheKey)
+        } catch (error) {
+            if (error.name === cache.ValidationError.name) {
+                throw error
+            } else if (error.name === cache.ReserveCacheError.name) {
+                core.info(error.message)
+            } else {
+                core.info(`[warning] ${error.message}`)
+            }
+        }
+    }
+    return downloadPath
+}
+
+async function downloadGradleDistribution(
+    versionInfo: GradleVersionInfo,
+    downloadPath: string
+): Promise<void> {
+    await toolCache.downloadTool(versionInfo.downloadUrl, downloadPath)
+    core.info(
+        `Downloaded ${versionInfo.downloadUrl} to ${downloadPath} (size ${
+            fs.statSync(downloadPath).size
+        })`
+    )
+}
+
 function executableFrom(installDir: string): string {
     return path.join(installDir, 'bin', `${gradlew.installScriptFilename()}`)
 }
@@ -139,6 +177,10 @@ async function httpGetString(url: string): Promise<string> {
     return response.readBody()
 }
 
+function isDistributionsCacheDisabled(): boolean {
+    return !github.inputBoolean('distributions-cache-enabled', true)
+}
+
 interface GradleVersionInfo {
     version: string
     downloadUrl: string