Make cache prefix configurable, and garbage collect repository cache

Author: calebzulawski

README.md

@@ -85,32 +85,10 @@ Default `""`.
 
 ### `disk-cache`
 
-Enable [`disk_cache`][2] and store it on GitHub based on contents of `BUILD` files.
-
-You can also pass a string to use as a cache key to separate caches from different workflows.
+Enable [`disk_cache`][2] and store it on GitHub.
 
 Default `false`.
 
-<details>
-  <summary>Examples</summary>
-
-  #### Share a single disk cache
-
-  ```yaml
-  - uses: bazel-contrib/[email protected]
-    with:
-      disk-cache: true
-  ```
-
-  #### Separate disk caches between workflows
-
-  ```yaml
-  - uses: bazel-contrib/[email protected]
-    with:
-      disk-cache: ${{ github.workflow }}}
-  ```
-</details>
-
 ### `max-disk-cache-size`
 
 The maximum size, in GB, allowed for the disk cache.
@@ -213,31 +191,16 @@ Default is one of the following:
 
 ### `repository-cache`
 
-Enable [`repository_cache`][3] and store it on GitHub based on contents of `MODULE.bazel` and `WORKSPACE` files.
-
-You can also pass a file (or list of files) which contents are used to calculate cache key.
+Enable [`repository_cache`][3] and store it on GitHub.
 
 Default `false`.
 
-<details>
-  <summary>Examples</summary>
-
-  #### Store a single repository cache
-
-  ```yaml
-  - uses: bazel-contrib/[email protected]
-    with:
-      repository-cache: true
-  ```
+### `max-repository-cache-size`
 
-  #### Store a repository cache from a custom location
+The maximum size, in GB, allowed for the repository cache.
+Exceeding this size results in garbage collection.
 
-  ```yaml
-  - uses: bazel-contrib/[email protected]
-    with:
-      repository-cache: examples/gem/WORKSPACE
-  ```
-</details>
+Default `1`.
 
 ## Migrating from [`bazelbuild/setup-bazelisk`][6]
 

action.yml

@@ -13,6 +13,10 @@ inputs:
     description: Extra contents to write to user .bazelrc
     required: false
     default: ""
+  cache-prefix:
+    description: Key prefix for all caches
+    required: false
+    default: ${{ github.job }}-${{ runner.os }}
   cache-version:
     description: Version of all caches
     required: false
@@ -45,6 +49,10 @@ inputs:
     description: Cache repositories based on MODULE.bazel/WORKSPACE
     required: false
     default: "false"
+  max-repository-cache-size:
+    description: Maximum repository cache size, in GB
+    required: false
+    default: 1
   token:
     description: GitHub token to query Bazelisk releases
     required: false

config.js

@@ -5,10 +5,10 @@ const core = require('@actions/core')
 const github = require('@actions/github')
 
 const bazeliskVersion = core.getInput('bazelisk-version')
+const cachePrefix = core.getInput('cache-prefix')
 const cacheVersion = core.getInput('cache-version')
 const externalCacheConfig = yaml.parse(core.getInput('external-cache'))
 const moduleRoot = core.getInput('module-root')
-const maxDiskCacheSize = core.getInput('max-disk-cache-size')
 
 const homeDir = os.homedir()
 const arch = os.arch()
@@ -42,32 +42,19 @@ switch (platform) {
     break
 }
 
-const baseCacheKey = `setup-bazel-${cacheVersion}-${platform}`
+const baseCacheKey = `setup-bazel-${cacheVersion}-${cachePrefix}`
 const bazelrc = core.getMultilineInput('bazelrc')
 
-const diskCacheConfig = core.getInput('disk-cache')
-const diskCacheEnabled = diskCacheConfig !== 'false'
-let diskCacheName = 'disk'
+const diskCacheEnabled = core.getInput('disk-cache')
+const maxDiskCacheSize = core.getInput('max-disk-cache-size')
 if (diskCacheEnabled) {
   bazelrc.push(`common --disk_cache=${bazelDisk}`)
-  if (diskCacheName !== 'true') {
-    diskCacheName = `${diskCacheName}-${diskCacheConfig}`
-  }
 }
 
-const repositoryCacheConfig = core.getInput('repository-cache')
-const repositoryCacheEnabled = repositoryCacheConfig !== 'false'
-let repositoryCacheFiles = [
-  `${moduleRoot}/MODULE.bazel`,
-  `${moduleRoot}/WORKSPACE.bazel`,
-  `${moduleRoot}/WORKSPACE.bzlmod`,
-  `${moduleRoot}/WORKSPACE`
-]
+const repositoryCacheEnabled = core.getInput('repository-cache')
+const maxRepositoryCacheSize = core.getInput('max-repository-cache-size')
 if (repositoryCacheEnabled) {
   bazelrc.push(`common --repository_cache=${bazelRepository}`)
-  if (repositoryCacheConfig !== 'true') {
-    repositoryCacheFiles = Array(repositoryCacheConfig).flat()
-  }
 }
 
 const googleCredentials = core.getInput('google-credentials')
@@ -140,12 +127,8 @@ module.exports = {
   bazelrc,
   diskCache: {
     enabled: diskCacheEnabled,
-    files: [
-      ...repositoryCacheFiles,
-      `${moduleRoot}/**/BUILD.bazel`,
-      `${moduleRoot}/**/BUILD`
-    ],
-    name: diskCacheName,
+    maxSize: maxDiskCacheSize,
+    name: 'disk',
     paths: [bazelDisk]
   },
   maxDiskCacheSize,
@@ -161,7 +144,7 @@ module.exports = {
   },
   repositoryCache: {
     enabled: repositoryCacheEnabled,
-    files: repositoryCacheFiles,
+    maxSize: maxRepositoryCacheSize,
     name: 'repository',
     paths: [bazelRepository]
   },

gc.js

@@ -2,27 +2,23 @@ const crypto = require('crypto')
 const fs = require('fs')
 const path = require('path')
 const core = require('@actions/core')
-const config = require('./config')
 
-const diskCachePath = config.diskCache.paths[0]
-const diskCacheHash = diskCachePath + '.sha256'
-
-function init() {
-  if (!config.diskCache.enabled) {
+function init(cacheConfig) {
+  if (!cacheConfig.enabled) {
     return
   }
 
-  core.startGroup("Computing initial disk cache hash")
-  fs.writeFileSync(diskCacheHash, computeDiskCacheHash())
+  core.startGroup(`Computing initial ${cacheConfig.name} cache hash`)
+  fs.writeFileSync(cacheConfig.path + '.sha256', computeCacheHash(cacheConfig.path))
   core.endGroup()
 }
 
-function run() {
-  if (!fs.existsSync(diskCachePath)) {
+function run(cacheConfig) {
+  if (!fs.existsSync(cacheConfig.path)) {
     return
   }
 
-  const files = fs.readdirSync(diskCachePath, { withFileTypes: true, recursive: true })
+  const files = fs.readdirSync(cacheConfig.path, { withFileTypes: true, recursive: true })
     .filter(d => d.isFile())
     .map(d => {
       const file = path.join(d.path, d.name)
@@ -31,8 +27,8 @@ function run() {
     })
     .sort((a, b) => b.mtime - a.mtime)
 
-  core.startGroup(`Running disk cache garbage collection`)
-  const deleteThreshold = config.maxDiskCacheSize * 1024 ** 3
+  core.startGroup(`Running ${cacheConfig.name} cache garbage collection`)
+  const deleteThreshold = cacheConfig.maxSize * 1024 ** 3
   let cacheSize = 0
   let reclaimed = 0
   for (const { file, size } of files) {
@@ -44,21 +40,24 @@ function run() {
   }
   core.info(`Reclaimed ${reclaimed} files`)
   core.endGroup()
+
+  return cacheChanged(cacheConfig)
 }
 
-function cacheChanged() {
-  core.startGroup(`Checking disk cache for changes`)
-  const changed = fs.readFileSync(diskCacheHash) != computeDiskCacheHash()
+function cacheChanged(cacheConfig) {
+  core.startGroup(`Checking ${cacheConfig.name} cache for changes`)
+  const hash = computeCacheHash(cacheConfig.path)
+  const changed = fs.readFileSync(cacheConfig.path + '.sha256') != hash
   core.info(`Cache has changes: ${changed}`)
   core.endGroup()
-  return changed
+  return changed ? hash : undefined
 }
 
-function computeDiskCacheHash() {
+function computeCacheHash(path) {
   let hash = crypto.createHash('sha256')
 
-  if (fs.existsSync(diskCachePath)) {
-    const files = fs.readdirSync(diskCachePath, { withFileTypes: true, recursive: true })
+  if (fs.existsSync(path)) {
+    const files = fs.readdirSync(path, { withFileTypes: true, recursive: true })
       .filter(d => d.isFile())
       .map(d => d.path)
       .sort()
@@ -74,5 +73,4 @@ function computeDiskCacheHash() {
 module.exports = {
   init,
   run,
-  cacheChanged,
 }

index.js

@@ -26,11 +26,9 @@ async function setupBazel() {
 
   await setupBazelisk()
   await restoreCache(config.bazeliskCache)
-  await restoreDiskCache(config.diskCache)
-  await restoreCache(config.repositoryCache)
+  await restoreGcCache(config.diskCache)
+  await restoreGcCache(config.repositoryCache)
   await restoreExternalCaches(config.externalCache)
-
-  gc.init()
 }
 
 async function setupBazelisk() {
@@ -186,18 +184,17 @@ async function restoreCache(cacheConfig) {
   )
 }
 
-async function restoreDiskCache(cacheConfig) {
-  const hash = await glob.hashFiles(cacheConfig.files.join('\n'))
-
+async function restoreGcCache(cacheConfig) {
   // Since disk caches get updated on any change, each run has a unique key.
   // Therefore it can only be restored by prefix match, rather than exact key match.
   // When multiple prefix matches exist, the most recent is selected.
   const restoreKey = `${config.baseCacheKey}-${cacheConfig.name}-`
-  const hashedRestoreKey = `${restoreKey}${hash}-`
   await restoreCacheImpl(
-    cacheConfig, hashedRestoreKey, [hashedRestoreKey, restoreKey],
+    cacheConfig, restoreKey, [restoreKey],
     restoredKey => restoredKey.startsWith(hashedRestoreKey)
   )
+
+  gc.init(cacheConfig)
 }
 
 run()

post.js

@@ -15,8 +15,8 @@ async function run() {
 
 async function saveCaches() {
   await saveCache(config.bazeliskCache)
-  await saveDiskCache(config.diskCache)
-  await saveCache(config.repositoryCache)
+  await saveGcCache(config.diskCache)
+  await saveGcCache(config.repositoryCache)
   await saveExternalCaches(config.externalCache)
 }
 
@@ -61,26 +61,28 @@ async function saveExternalCaches(cacheConfig) {
   }
 }
 
-async function saveDiskCache(cacheConfig) {
+async function saveGcCache(cacheConfig) {
   if (!cacheConfig.enabled) {
     return
   }
 
-  gc.run()
-  if (!gc.cacheChanged()) {
+  const hash = gc.run(cacheConfig)
+
+  // cache is unchanged
+  if (!hash) {
+    return
+  }
+
+  const key = `${config.baseCacheKey}-${cacheConfig.name}-${hash}`
+  const paths = cacheConfig.paths
+
+  // cache already exists
+  if (await cache.restoreCache(paths, key, [], { lookupOnly: true })) {
     return
   }
 
   try {
     core.startGroup(`Save cache for ${cacheConfig.name}`)
-    const paths = cacheConfig.paths
-    const hash = await glob.hashFiles(
-      cacheConfig.files.join('\n'),
-      undefined,
-      // We don't want to follow symlinks as it's extremely slow on macOS.
-      { followSymbolicLinks: false }
-    )
-    const key = `${config.baseCacheKey}-${cacheConfig.name}-${hash}-${process.env.GITHUB_RUN_ID}.${process.env.GITHUB_RUN_ATTEMPT}`
     core.debug(`Attempting to save ${paths} cache to ${key}`)
     await cache.saveCache(paths, key)
     core.info('Successfully saved cache')