Unique cache-key for job matrix objects (#88)

* Unique cache-key for job matrix objects

* Update workflow to use object in job matrix

* Restore key should always match startswith

* fixup! Unique cache-key for job matrix objects

* Debug no-matrix

* Tests require overriding workflow/job

* Skip generating matrix_key when no matrix is used

* Install jq for self-hosted runners

* fixup! Install jq for self-hosted runners

* Skip install when not needed

* fixup! Skip install when not needed

* fixup! Skip install when not needed

* Improve `cache-name` description

Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>

* Update  description in README

* Use actions/checkout@v4 in example

* add missing period

---------

Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>

.github/workflows/CI.yml

@@ -6,12 +6,19 @@ on:
       - main
     paths:
       - 'action.yml'
+      - 'handle_caches.jl'
       - '.github/**'
   pull_request:
     paths:
       - 'action.yml'
+      - 'handle_caches.jl'
       - '.github/**'
 
+# needed to allow julia-actions/cache to delete old caches that it has created
+permissions:
+  actions: write
+  contents: read
+
 jobs:
   generate-key:
     runs-on: ubuntu-latest
@@ -29,11 +36,39 @@ jobs:
     needs: generate-key
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
+        dep:
+          - name: pandoc_jll
+            version: "3"
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macOS-latest
       fail-fast: false
     runs-on: ${{ matrix.os }}
+    env:
+      JULIA_DEPOT_PATH: /tmp/julia-depot
     steps:
-    - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
+    - name: Save cache
+      id: cache
+      uses: ./
+      with:
+        cache-name: ${{ needs.generate-key.outputs.cache-name }}
+    - name: Check no artifacts dir
+      shell: 'julia --color=yes {0}'
+      run: |
+        dir = joinpath(first(DEPOT_PATH), "artifacts")
+        @assert !isdir(dir)
+    - name: Install a small binary
+      shell: 'julia --color=yes {0}'
+      run: 'using Pkg; Pkg.add(PackageSpec(name="${{ matrix.dep.name }}", version="${{ matrix.dep.version }}"))'
+
+  # Do tests with no matrix also given the matrix is auto-included in cache key
+  test-save-nomatrix:
+    needs: generate-key
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
     - name: Save cache
       id: cache
       uses: ./
@@ -52,11 +87,19 @@ jobs:
     needs: [generate-key, test-save]
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
+        dep:
+          - name: pandoc_jll
+            version: "3"
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macOS-latest
       fail-fast: false
     runs-on: ${{ matrix.os }}
+    env:
+      JULIA_DEPOT_PATH: /tmp/julia-depot
     steps:
-    - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
     - name: Restore cache
       id: cache
       uses: ./
@@ -69,11 +112,50 @@ jobs:
         @assert ENV["cache-hit"] == "true"
       env:
         cache-hit: ${{ steps.cache.outputs.cache-hit }}
-    - name: Check non-empty artifacts and packages dir
+    - name: Check existance or emptiness of affected dirs
       shell: 'julia --color=yes {0}'
       run: |
+        # These dirs should exist as they've been cached
         artifacts_dir = joinpath(first(DEPOT_PATH), "artifacts")
         @assert !isempty(readdir(artifacts_dir))
         packages_dir = joinpath(first(DEPOT_PATH), "packages")
         @assert !isempty(readdir(packages_dir))
+        compiled_dir = joinpath(first(DEPOT_PATH), "compiled")
+        @assert !isempty(readdir(compiled_dir))
+        scratchspaces_dir = joinpath(first(DEPOT_PATH), "scratchspaces")
+        @assert !isempty(readdir(scratchspaces_dir))
+        logs_dir = joinpath(first(DEPOT_PATH), "logs")
+        @assert !isempty(readdir(logs_dir))
+
+  test-restore-nomatrix:
+    needs: [generate-key, test-save-nomatrix]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
+    - name: Restore cache
+      id: cache
+      uses: ./
+      with:
+        cache-name: ${{ needs.generate-key.outputs.cache-name }}
+    - name: Test cache-hit output
+      shell: 'julia --color=yes {0}'
+      run: |
+        @show ENV["cache-hit"]
+        @assert ENV["cache-hit"] == "true"
+      env:
+        cache-hit: ${{ steps.cache.outputs.cache-hit }}
+    - name: Check existance or emptiness of affected dirs
+      shell: 'julia --color=yes {0}'
+      run: |
+        # These dirs should exist as they've been cached
+        artifacts_dir = joinpath(first(DEPOT_PATH), "artifacts")
+        @assert !isempty(readdir(artifacts_dir))
+        packages_dir = joinpath(first(DEPOT_PATH), "packages")
+        @assert !isempty(readdir(packages_dir))
+        compiled_dir = joinpath(first(DEPOT_PATH), "compiled")
+        @assert !isempty(readdir(compiled_dir))
+        scratchspaces_dir = joinpath(first(DEPOT_PATH), "scratchspaces")
+        @assert !isempty(readdir(scratchspaces_dir))
+        logs_dir = joinpath(first(DEPOT_PATH), "logs")
+        @assert !isempty(readdir(logs_dir))
 

README.md

@@ -1,6 +1,6 @@
 # julia-actions/cache Action
 
-A shortcut action to cache Julia artifacts, packages and (optionally) registries to reduce GitHub Actions running time.
+A shortcut action to cache Julia depot contents to reduce GitHub Actions running time.
 
 ## Usage
 
@@ -11,46 +11,92 @@ name: CI
 
 on: [push, pull_request]
 
+# needed to allow julia-actions/cache to delete old caches that it has created
+permissions:
+  actions: write
+  contents: read
+
 jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - uses: julia-actions/setup-julia@v1
     - uses: julia-actions/cache@v1
     - uses: julia-actions/julia-buildpkg@v1
     - uses: julia-actions/julia-runtest@v1
 ```
 
-By default, this caches the files in `~/.julia/artifacts/` and `~/.julia/packages/`.
-To also cache `~/.julia/registries/`, use
+By default all depot directories called out below are cached.
 
-```yaml
-    - uses: julia-actions/cache@v1
-      with:
-        cache-registries: "true"
-```
+### Optional Inputs
 
-Note that caching the registries may actually slow down the workflow running time on Windows runners.
-That is why caching the registries is disabled by default.
-
-### Inputs
-
-- `cache-name` - Name used as part of the cache keys
-- `cache-artifacts` - Whether to cache `~/.julia/artifacts/`. Enabled by default.
-- `cache-packages` - Whether to cache `~/.julia/packages/`. Enabled by default.
-- `cache-registries` - Whether to cache `~/.julia/registries/`. Disabled by default.
+- `cache-name` - The cache key prefix. Defaults to `julia-cache;workflow=${{ github.workflow }};job=${{ github.job }}`. The key body automatically includes the OS and, unless disabled with `include-matrix`, the matrix vars. Include any other parameters/details in this prefix to ensure one unique cache key per concurrent job type.
+- `include-matrix` - Whether to include the matrix values when constructing the cache key. Defaults to `true`.
+- `depot` - Path to a Julia [depot](https://pkgdocs.julialang.org/v1/glossary/) directory where cached data will be saved to and restored from. Defaults to the first depot in [`JULIA_DEPOT_PATH`](https://docs.julialang.org/en/v1/manual/environment-variables/#JULIA_DEPOT_PATH) if specified. Otherwise, defaults to `~/.julia`.
+- `cache-artifacts` - Whether to cache the depot's `artifacts` directory. Defaults to `true`.
+- `cache-packages` - Whether to cache the depot's `packages` directory. Defaults to `true`.
+- `cache-registries` - Whether to cache the depot's `registries` directory. Defaults to `true`.
+- `cache-compiled` - Whether to cache the depot's `compiled` directory. Defaults to `true`.
+- `cache-scratchspaces` - Whether to cache the depot's `scratchspaces` directory. Defaults to `true`.
+- `cache-logs` - Whether to cache the depot's `logs` directory. Defaults to `true`. Helps auto-`Pkg.gc()` keep the cache small.
+- `delete-old-caches` - Whether to delete old caches for the given key. Defaults to `true`.
+- `token` - A [GitHub PAT](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens). Defaults to `github.token`. Requires `repo` scope to enable the deletion of old caches.
 
 ### Outputs
 
 - `cache-hit` - A boolean value to indicate an exact match was found for the primary key. Returns \"\" when the key is new. Forwarded from actions/cache.
 
-## How it works
+## How It Works
 
 This action is a wrapper around <https://github.com/actions/cache>.
 In summary, this action stores the files in the aforementioned paths in one compressed file when running for the first time.
-This cached file is then restored upon the second run.
-The benefit of this is that downloading one big file is quicker than downloading many different files from many different locations.
+This cached file is then restored upon the second run, and afterwards resaved under a new key, and the previous cache deleted.
+The benefit of caching is that downloading one big file is quicker than downloading many different files from many different locations
+and precompiling them.
+
+### Cache keys
+
+The cache key that the cache will be saved as is based on:
+- The `cache-name` input
+- All variables in the `matrix` (unless disabled via `include-matrix: 'false'`)
+- The `runner.os` (may be in the matrix too, but included for safety)
+- The run id
+- The run attempt number
+
+> [!NOTE]
+> If in your workflow if you do not use a matrix for concurrency you should make `cache-name` such that it is unique for
+> concurrent jobs, otherwise caching may not be effective.
+
+### Cache Retention
+
+This action automatically deletes old caches that match the first 4 fields of the above key:
+- The `cache-name` input
+- All variables in the `matrix` (unless disabled via `include-matrix: 'false'`)
+- The `runner.os` (may be in the matrix too, but included for safety)
+
+Which means your caches files will not grow needlessly. GitHub also deletes cache files after
+[90 days which can be increased in private repos to up to 400 days](https://docs.github.com/en/organizations/managing-organization-settings/configuring-the-retention-period-for-github-actions-artifacts-and-logs-in-your-organization)
+
+> [!NOTE]
+> To allow deletion of caches you will likely need to [grant the following permissions](https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs)
+> to the `GITHUB_TOKEN` by adding this to your GitHub actions workflow:
+> ```yaml
+> permissions:
+>   actions: write
+>   contents: read
+> ```
+> (Note this won't work for fork PRs but should once merged)
+> Or provide a token with `repo` scope via the `token` input option.
+> See https://cli.github.com/manual/gh_cache_delete
+
+To disable deletion set input `delete-old-caches: 'false'`.
+
+### Cache Garbage Collection
+
+Caches are restored and re-saved after every run, retaining the state of the depot throughout runs.
+Their size will be regulated like a local depot automatically by the automatic `Pkg.gc()` functionality that
+clears out old content, which is made possible because the `/log` contents are cached.
 
 ## Third Party Notice
 

action.yml

@@ -8,43 +8,142 @@ branding:
 
 inputs:
   cache-name:
-    description: 'Name used as part of the cache keys'
-    default: 'julia-cache'
+    description: >-
+      The cache key prefix. The key body automatically includes the OS and, unless disabled, the matrix vars.
+      Include any other parameters/details in this prefix to ensure one unique cache key per concurrent job type.
+    default: julia-cache;workflow=${{ github.workflow }};job=${{ github.job }}
+  include-matrix:
+    description: Whether to include the matrix values when constructing the cache key.
+    default: 'true'
+  depot:
+    description: Path to a Julia depot directory where cached data will be saved to and restored from.
+    default: ''
   cache-artifacts:
-    description: 'Whether to cache ~/.julia/artifacts/'
+    description: Whether to cache the depot's `artifacts` directory.
     default: 'true'
   cache-packages:
-    description: 'Whether to cache ~/.julia/packages/'
+    description: Whether to cache the depot's `packages` directory.
     default: 'true'
   cache-registries:
-    description: 'Whether to cache ~/.julia/registries/'
-    default: 'false'
+    description: Whether to cache the depot's `registries` directory.
+    default: 'true'
+  cache-compiled:
+    description: Whether to cache the depot's `compiled` directory.
+    default: 'true'
+  cache-scratchspaces:
+    description: Whether to cache the depot's `scratchspaces` directory.
+    default: 'true'
+  cache-logs:
+    description: Whether to cache the depot's `logs` directory. This helps automatic `Pkg.gc()` keep the cache size down.
+    default: 'true'
+  delete-old-caches:
+    description: Whether to delete old caches for the given key.
+    default: 'true'
+  token:
+    description: A GitHub PAT. Requires `repo` scope to enable the deletion of old caches.
+    default: ${{ github.token }}
 
 outputs:
   cache-hit:
-    description: 'A boolean value to indicate an exact match was found for the primary key. Returns \"\" when the key is new. Forwarded from actions/cache'
+    description: A boolean value to indicate an exact match was found for the primary key. Returns "" when the key is new. Forwarded from actions/cache.
     value: ${{ steps.hit.outputs.cache-hit }}
 
 runs:
   using: 'composite'
   steps:
+    - name: Install jq
+      # Skip installation on GitHub-hosted runners:
+      # https://github.com/orgs/community/discussions/48359#discussioncomment-5323864
+      if: ${{ !startsWith(runner.name, 'GitHub Actions') }}
+      uses: dcarbone/install-jq-action@v2.1.0
+      with:
+        force: false  # Skip install when an existing `jq` is present
+
     - id: paths
       run: |
-        [ "${{ inputs.cache-artifacts }}" = "true" ] && A_PATH="~/.julia/artifacts"
-        echo "ARTIFACTS_PATH=$A_PATH" >> $GITHUB_ENV
-        [ "${{ inputs.cache-packages }}" = "true" ] && P_PATH="~/.julia/packages"
-        echo "PACKAGES_PATH=$P_PATH" >> $GITHUB_ENV
-        [ "${{ inputs.cache-registries }}" = "true" ] && R_PATH="~/.julia/registries"
-        echo "REGISTRIES_PATH=$R_PATH" >> $GITHUB_ENV
+        if [ -n "${{ inputs.depot }}" ]; then
+            depot="${{ inputs.depot }}"
+        elif [ -n "$JULIA_DEPOT_PATH" ]; then
+            # Use the first depot path
+            depot=$(echo $JULIA_DEPOT_PATH | cut -d$PATH_DELIMITER -f1)
+        else
+            depot="~/.julia"
+        fi
+        echo "depot=$depot" >> $GITHUB_OUTPUT
+        [ "${{ inputs.cache-artifacts }}" = "true" ] && A_PATH="${depot}/artifacts"
+        echo "artifacts-path=$A_PATH" >> $GITHUB_OUTPUT
+        [ "${{ inputs.cache-packages }}" = "true" ] && P_PATH="${depot}/packages"
+        echo "packages-path=$P_PATH" >> $GITHUB_OUTPUT
+        [ "${{ inputs.cache-registries }}" = "true" ] && R_PATH="${depot}/registries"
+        echo "registries-path=$R_PATH" >> $GITHUB_OUTPUT
+        [ "${{ inputs.cache-compiled }}" = "true" ] && PCC_PATH="${depot}/compiled"
+        echo "compiled-path=$PCC_PATH" >> $GITHUB_OUTPUT
+        [ "${{ inputs.cache-scratchspaces }}" = "true" ] && S_PATH="${depot}/scratchspaces"
+        echo "scratchspaces-path=$S_PATH" >> $GITHUB_OUTPUT
+        [ "${{ inputs.cache-logs }}" = "true" ] && L_PATH="${depot}/logs"
+        echo "logs-path=$L_PATH" >> $GITHUB_OUTPUT
       shell: bash
+      env:
+        PATH_DELIMITER: ${{ runner.OS == 'Windows' && ';' || ':' }}
 
-    - uses: actions/cache@4723a57e26efda3a62cbde1812113b730952852d
+    - name: Generate Keys
+      id: keys
+      run: |
+        # `matrix_key` joins all of matrix keys/values (including nested objects) to ensure that concurrent runs each use a unique cache key.
+        # When `matrix` isn't set for the job then `MATRIX_JSON=null`.
+        if [ "${{ inputs.include-matrix }}" == "true" ] && [ "$MATRIX_JSON" != "null" ]; then
+          matrix_key=$(echo "$MATRIX_JSON" | jq 'paths(type != "object") as $p | ($p | join("-")) + "=" + (getpath($p) | tostring)' | jq -rs 'join(";") | . + ";"')
+        fi
+        restore_key="${{ inputs.cache-name }};os=${{ runner.os }};${matrix_key}"
+        key="${restore_key}run_id=${{ github.run_id }};run_attempt=${{ github.run_attempt }}"
+        echo "restore-key=${restore_key}" >> $GITHUB_OUTPUT
+        echo "key=${key}" >> $GITHUB_OUTPUT
+      shell: bash
+      env:
+        MATRIX_JSON: ${{ toJSON(matrix) }}
+
+    - uses: actions/cache@4d4ae6ae148a43d0fd1eda1800170683e9882738
       id: cache
       with:
-        path: "${{ format('{0}\n{1}\n{2}', env.ARTIFACTS_PATH, env.PACKAGES_PATH, env.REGISTRIES_PATH) }}"
-        key: ${{ runner.os }}-test-${{ inputs.cache-name }}-${{ hashFiles('**/Project.toml') }}
-        restore-keys: |
-          ${{ runner.os }}-test-${{ inputs.cache-name }}-
+        path: |
+          ${{ steps.paths.outputs.artifacts-path }}
+          ${{ steps.paths.outputs.packages-path }}
+          ${{ steps.paths.outputs.registries-path }}
+          ${{ steps.paths.outputs.scratchspaces-path }}
+          ${{ steps.paths.outputs.compiled-path }}
+          ${{ steps.paths.outputs.logs-path }}
+
+        key: ${{ steps.keys.outputs.key }}
+        restore-keys: ${{ steps.keys.outputs.restore-key }}
+        enableCrossOsArchive: false
+
+    - name: list restored depot directory sizes
+      if: ${{ steps.cache.outputs.cache-hit == 'true' }}
+      run: du -shc ${{ steps.paths.outputs.depot }}/* || true
+      shell: bash
+
+    # github and actions/cache doesn't provide a way to update a cache at a given key, so we delete any
+    # that match the restore key just before saving the new cache
+
+    # Not windows
+    - uses: pyTooling/Actions/with-post-step@adef08d3bdef092282614f3b683897cefae82ee3
+      if: ${{ inputs.delete-old-caches == 'true' && runner.OS != 'Windows' }}
+      with:
+        # seems like there has to be a `main` step in this action. Could list caches for info if we wanted
+        # main:  julia ${{ github.action_path }}/handle_caches.jl "${{ github.repository }}" "list"
+        main: echo ""
+        post: julia $GITHUB_ACTION_PATH/handle_caches.jl "${{ github.repository }}" "rm" "${{ steps.keys.outputs.restore-key }}"
+      env:
+        GH_TOKEN: ${{ inputs.token }}
+
+    # Windows (because this action uses command prompt on windows)
+    - uses: pyTooling/Actions/with-post-step@adef08d3bdef092282614f3b683897cefae82ee3
+      if: ${{ inputs.delete-old-caches == 'true' && runner.OS == 'Windows' }}
+      with:
+        main: echo ""
+        post: cd %GITHUB_ACTION_PATH% && julia handle_caches.jl "${{ github.repository }}" "rm" "${{ steps.keys.outputs.restore-key }}"
+      env:
+        GH_TOKEN: ${{ inputs.token }}
 
     - id: hit
       run: echo "cache-hit=$CACHE_HIT" >> $GITHUB_OUTPUT

handle_caches.jl

@@ -0,0 +1,65 @@
+using Pkg, Dates
+function handle_caches()
+    repo = ARGS[1]
+    func = ARGS[2]
+    restore_key = get(ARGS, 3, "")
+
+    if func == "list"
+        println("Listing existing caches")
+        run(`gh cache list --limit 100 --repo $repo`)
+    elseif func == "rm"
+        caches = String[]
+        failed = String[]
+        for _ in 1:5 # limit to avoid accidental rate limiting
+            hits = split(strip(read(`gh cache list --limit 100 --repo $repo`, String)), keepempty=false)
+            search_again = length(hits) == 100
+            filter!(startswith(restore_key), hits)
+            isempty(hits) && break
+            # We can delete everything that matches the restore key because the new cache is saved later.
+            for c in hits
+                try
+                    run(`gh cache delete $(split(c)[1]) --repo $repo`)
+                    push!(caches, c)
+                catch e
+                    @error e
+                    push!(failed, c)
+                end
+            end
+            search_again || break
+        end
+        if isempty(failed) && isempty(caches)
+            println("No existing caches found for restore key `$restore_key`")
+        else
+            if !isempty(failed)
+                println("Failed to delete $(length(failed)) existing caches for restore key `$restore_key`")
+                println.(failed)
+                @info """
+                    To delete caches you need to grant the following to the default `GITHUB_TOKEN` by adding
+                    this to your yml:
+                    ```
+                    permissions:
+                        actions: write
+                        contents: read
+                    ```
+                    (Note this won't work for fork PRs but should once merged)
+                    Or provide a token with `repo` scope via the `token` input option.
+                    See https://cli.github.com/manual/gh_cache_delete
+                    """
+            end
+            if !isempty(caches)
+                println("$(length(caches)) existing caches deleted that match restore key `$restore_key`:")
+                println.(caches)
+            end
+        end
+    else
+        throw(ArgumentError("Unexpected second argument: $func"))
+    end
+end
+
+try
+    # do a gc with the standard 7-day delay
+    Pkg.gc()
+    handle_caches()
+catch e
+    @error "An error occurred while managing existing caches" e
+end