update to actions/cache v4.0.2 commit

Co-authored-by: Curtis Vogt <curtis.vogt@gmail.com>

.github/dependabot.yml

@@ -1,10 +1,9 @@
 version: 2
+
 updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
+
+  # Keep dependencies for GitHub Actions up-to-date
+  - package-ecosystem: 'github-actions'
+    directory: '/'
     schedule:
-      interval: "monthly"
-    open-pull-requests-limit: 99
-    labels:
-      - "dependencies"
-      - "github-actions"
+      interval: 'daily'

.github/workflows/CI.yml

@@ -59,13 +59,13 @@ jobs:
     env:
       JULIA_DEPOT_PATH: /tmp/julia-depot
     steps:
-    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
     - name: Set cache-name
       id: cache-name
       shell: bash
       run: |
         echo "cache-name=${{ needs.generate-prefix.outputs.cache-prefix }}-${{ github.job }}" >>"$GITHUB_OUTPUT"
-    - uses: julia-actions/setup-julia@v2
+    - uses: julia-actions/setup-julia@v1
       with:
         version: ${{ matrix.version }}
     - name: Save cache
@@ -117,8 +117,8 @@ jobs:
     env:
       JULIA_DEPOT_PATH: /tmp/julia-depot
     steps:
-    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-    - uses: julia-actions/setup-julia@v2
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
+    - uses: julia-actions/setup-julia@v1
       with:
         version: ${{ matrix.version }}
     - name: Restore cache
@@ -161,7 +161,7 @@ jobs:
     outputs:
       cache-name: ${{ steps.cache-name.outputs.cache-name }}
     steps:
-    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
     - name: Set cache-name
       id: cache-name
       run: |
@@ -193,7 +193,7 @@ jobs:
     needs: test-save-nomatrix
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
     - name: Restore cache
       id: cache
       uses: ./
@@ -233,7 +233,7 @@ jobs:
     outputs:
       cache-name: ${{ steps.cache-name.outputs.cache-name }}
     steps:
-    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
     - name: Set cache-name
       id: cache-name
       run: |
@@ -259,7 +259,7 @@ jobs:
     needs: test-save-cloned-registry
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+    - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
     - name: Add General registry clone
       shell: julia --color=yes {0}
       run: |

README.md

@@ -21,8 +21,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
-    - uses: julia-actions/setup-julia@v2
-    - uses: julia-actions/cache@v2
+    - uses: julia-actions/setup-julia@v1
+    - uses: julia-actions/cache@v1
     - uses: julia-actions/julia-buildpkg@v1
     - uses: julia-actions/julia-runtest@v1
 ```
@@ -31,8 +31,10 @@ By default all depot directories called out below are cached.
 
 ### Requirements
 
-- `jq`: This action uses [`jq`](https://github.com/jqlang/jq) to parse JSON. For GitHub-hosted runners, `jq` is installed by default. On self-hosted runners and custom containers, if `jq` is not already available, this action will automatically use [`dcarbone/install-jq-action`](https://github.com/dcarbone/install-jq-action) to install `jq` (Note: `dcarbone/install-jq-action` requires that `curl` is installed; this may not always be the case in custom containers and self-hosted runners).
-- `bash`: This action requires `bash`. For GitHub-hosted runners `bash` is installed by default. Self-hosted runners will need to ensure that `bash` is installed and available on the `PATH`.
+This action uses [`jq`](https://github.com/jqlang/jq) to parse JSON.
+`jq` is installed by default in GitHub-hosted runners.
+[`dcarbone/install-jq-action`](https://github.com/dcarbone/install-jq-action) is used to check that `jq` is available and install it if not.
+**Note:** installing `jq` with `dcarbone/install-jq-action` requires that curl is available; this may not be the case in custom containers.
 
 ### Optional Inputs
 
@@ -45,14 +47,13 @@ By default all depot directories called out below are cached.
 - `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.
+- `save-always` - Whether to save the cache even when the job fails. Defaults to `true`. This is useful as the Julia depot should mostly be reusable from a failing job.
 - `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.
-- `cache-paths` - A list of paths (as a newline-separated string) that were cached.
-- `cache-key` - The cache key that was used for this run.
 
 ## How It Works
 
@@ -62,13 +63,6 @@ This cached file is then restored upon the second run, and afterwards resaved un
 The benefit of caching is that downloading one big file is quicker than downloading many different files from many different locations
 and precompiling them.
 
-By default, this action removes caches that were previously made by jobs on the same branch with the same restore key.
-GitHub automatically removes old caches after a certain period or when the repository cache allocation is full.
-It is, however, more efficient to explicitly remove old caches to improve caching for less frequently run jobs.
-
-For more information about GitHub caching generically, for example how to manually delete caches, see
-[this GitHub documentation page](https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/caching-dependencies-to-speed-up-workflows#managing-caches).
-
 ### Cache keys
 
 The cache key that the cache will be saved as is based on:
@@ -79,8 +73,8 @@ The cache key that the cache will be saved as is based on:
 - The run attempt number
 
 > [!NOTE]
-> If there is job concurrency that is not fully defined by a matrix you should ensure that `cache-name` is 
-> unique for each concurrent job, otherwise caching may not be effective.
+> 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
 
@@ -90,7 +84,7 @@ This action automatically deletes old caches that match the first 4 fields of th
 - 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
-[7 days of not being accessed](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#usage-limits-and-eviction-policy), and there is a limit of 10 GB for the total size of cache files associated to each repository.
+[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)
@@ -106,35 +100,6 @@ Which means your caches files will not grow needlessly. GitHub also deletes cach
 
 To disable deletion set input `delete-old-caches: 'false'`.
 
-### Caching even if an intermediate job fails
-
-Just like [the basic actions/cache workflow](https://github.com/actions/cache), this action has a cache restore step, and also a save step which runs after the workflow completes.
-By default, if any job in the workflow fails, the entire workflow will be stopped, and the cache will not be saved.
-
-Due to current limitations in GitHub Actions syntax, there is no built-in option for this action to save the cache even if the job fails.
-However, it does output information which you can feed into `actions/cache` yourself to achieve the same effect.
-For example, this workflow will ensure that the cache is saved if a step fails (but skipping it if the cache was hit, i.e. there's no need to cache it again).
-
-```yaml
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Load Julia packages from cache
-        id: julia-cache
-        uses: julia-actions/cache@v2
-
-      # do whatever you want here (that might fail)
-
-      - name: Save Julia depot cache on cancel or failure
-        id: julia-cache-save
-        if: cancelled() || failure()
-        uses: actions/cache/save@v4
-        with: 
-          path: |
-            ${{ steps.julia-cache.outputs.cache-paths }}
-          key: ${{ steps.julia-cache.outputs.cache-key }}
-```
-
 ### Cache Garbage Collection
 
 Caches are restored and re-saved after every run, retaining the state of the depot throughout runs.

action.yml

@@ -36,6 +36,9 @@ inputs:
   cache-logs:
     description: Whether to cache the depot's `logs` directory. This helps automatic `Pkg.gc()` keep the cache size down.
     default: 'true'
+  save-always:
+    description: Whether to save the cache even when the job fails. This is useful as the Julia depot should mostly be reusable from a failing job.
+    default: 'true'
   delete-old-caches:
     description: Whether to delete old caches for the given key.
     default: 'true'
@@ -47,18 +50,12 @@ 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.
     value: ${{ steps.hit.outputs.cache-hit }}
-  cache-paths:
-    description: The paths that were cached
-    value: ${{ steps.paths.outputs.cache-paths }}
-  cache-key:
-    description: The full cache key used
-    value: ${{ steps.keys.outputs.key }}
 
 runs:
   using: 'composite'
   steps:
     - name: Install jq
-      uses: dcarbone/install-jq-action@b7ef57d46ece78760b4019dbc4080a1ba2a40b45 # v3.2.0
+      uses: dcarbone/install-jq-action@8867ddb4788346d7c22b72ea2e2ffe4d514c7bcb # v2.1.0
       with:
         force: false  # Skip install when an existing `jq` is present
 
@@ -72,12 +69,6 @@ runs:
         else
             depot="~/.julia"
         fi
-        if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
-          depot="${depot/#\~/$USERPROFILE}"  # Windows paths
-          depot="${depot//\\//}"             # Replace backslashes with forward slashes
-        else
-          depot="${depot/#\~/$HOME}"  # Unix-like paths
-        fi
         echo "depot=$depot" | tee -a "$GITHUB_OUTPUT"
 
         cache_paths=()
@@ -87,7 +78,7 @@ runs:
         [ "${{ inputs.cache-packages }}" = "true" ] && cache_paths+=("$packages_path")
         registries_path="${depot}/registries"
         if [ "${{ inputs.cache-registries }}" = "true" ]; then
-            if [ ! -d "${registries_path}" ]; then
+            if [ ! -d "${registries_path/#\~/$HOME}" ]; then
                 cache_paths+=("$registries_path")
             else
                 echo "::warning::Julia depot registries already exist. Skipping restoring of cached registries to avoid potential merge conflicts when updating. Please ensure that \`julia-actions/cache\` precedes any workflow steps which add registries."
@@ -127,7 +118,7 @@ runs:
       env:
         MATRIX_JSON: ${{ toJSON(matrix) }}
 
-    - uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+    - uses: actions/cache@0c45773b623bea8c8e75f6c82b208c3cf94ea4f9 # v4.0.2
       id: cache
       with:
         path: |
@@ -135,6 +126,7 @@ runs:
         key: ${{ steps.keys.outputs.key }}
         restore-keys: ${{ steps.keys.outputs.restore-key }}
         enableCrossOsArchive: false
+        save-always: ${{ inputs.save-always }}
 
     # if it wasn't restored make the depot anyway as a signal that this action ran
     # for other julia actions to check, like https://github.com/julia-actions/julia-buildpkg/pull/41
@@ -144,44 +136,12 @@ runs:
         du -shc ${{ steps.paths.outputs.depot }}/* || true
       shell: bash
 
-    # issue https://github.com/julia-actions/cache/issues/110
-    # Pkg may not run `Registry.update()` if a manifest exists, which may exist because of a
-    # `Pkg.dev` call or because one is added to the repo. So be safe and update cached registries here.
-    # Older (~v1.0) versions of julia that don't have `Pkg.Registry.update()` seem to always update registries in
-    # Pkg operations. So this is only necessary for newer julia versions.
-    - name: Update any cached registries
-      if: ${{ inputs.cache-registries == 'true' }}
-      continue-on-error: true
-      run: |
-        if [ -d "${{ steps.paths.outputs.depot }}/registries" ] && [ -n "$(ls -A "${{ steps.paths.outputs.depot }}/registries")" ]; then
-          echo "Registries directory exists and is non-empty. Updating any registries"
-          julia -e "import Pkg; isdefined(Pkg, :Registry) && Pkg.Registry.update();"
-        else
-          echo "Registries directory does not exist or is empty. Skipping registry update"
-        fi
-      shell: bash
-
-    # GitHub actions cache entries are immutable and cannot be updated. In order to have both the Julia
-    # depot cache be up-to-date and avoid storing redundant cache entries we'll manually cleanup old
-    # cache entries before the new cache is saved. However, we need to be careful with our manual
-    # cleanup as otherwise we can cause cache misses for jobs which would have normally had a cache hit.
-    # Some scenarios to keep in mind include:
-    #
-    # - Job failures result in the post-action for `actions/cache` being skipped. If we delete all cache
-    #   entries for the branch we may have no cache entry available for the next run.
-    # - We should avoid deleting old cache entries for the default branch since these entries serve as
-    #   the fallback if no earlier cache entry exists on a branch. We can rely on GitHub's default cache
-    #   eviction policy here which will remove the oldest cache entry first.
-    #
-    # References:
-    # - https://github.com/actions/cache/blob/main/tips-and-workarounds.md#update-a-cache
-    # - https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#usage-limits-and-eviction-policy
+    # 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@d6342484cd335d4c9c63d4f52f267c54d5bc3b19 # v5.4.0
-      if: ${{ inputs.delete-old-caches != 'false' &&
-              github.ref != format('refs/heads/{0}', github.event.repository.default_branch) &&
-              runner.OS != 'Windows' }}
+    - uses: pyTooling/Actions/with-post-step@adef08d3bdef092282614f3b683897cefae82ee3
+      if: ${{ inputs.delete-old-caches != 'false' && 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"
@@ -191,10 +151,8 @@ runs:
         GH_TOKEN: ${{ inputs.token }}
 
     # Windows (because this action uses command prompt on windows)
-    - uses: pyTooling/Actions/with-post-step@d6342484cd335d4c9c63d4f52f267c54d5bc3b19 # v5.4.0
-      if: ${{ inputs.delete-old-caches != 'false' &&
-              github.ref != format('refs/heads/{0}', github.event.repository.default_branch) &&
-              runner.OS == 'Windows' }}
+    - uses: pyTooling/Actions/with-post-step@adef08d3bdef092282614f3b683897cefae82ee3
+      if: ${{ inputs.delete-old-caches != 'false' && runner.OS == 'Windows' }}
       with:
         main: echo ""
         post: cd %GITHUB_ACTION_PATH% && julia handle_caches.jl rm "${{ github.repository }}" "${{ steps.keys.outputs.restore-key }}" "${{ github.ref }}" "${{ inputs.delete-old-caches != 'required' }}"

devdocs/making_a_new_release.md

@@ -1,55 +0,0 @@
-# Making a new release
-
-In this guide, as an example, `v2.2.0` refers to the version number of the new release that you want to make.
-
-## Part 1: Use the Git CLI to create and push the Git tags
-
-Step 1: Clone the repository:
-
-```bash
-git clone git@github.com:julia-actions/cache.git
-cd cache
-```
-
-Step 2: Create a new lightweight tag of the form `vMAJOR.MINOR.PATCH`.
-
-```bash
-# Get the commit SHA of the latest pushed commit on the default branch
-git fetch origin --tags --force
-commit_sha="$(git rev-parse origin/HEAD)"
-
-# Validate this commit is the one you intend to release
-git --no-pager log -1 "${commit_sha:?}"
-
-# Now, create a new lightweight tag of the form `vMAJOR.MINOR.PATCH`.
-# Replace `v2.2.0` with the actual version number that you want to use.
-tag=v2.2.0
-git tag "${tag:?}" "${commit_sha:?}"
-```
-
-Step 3: Once you've created the new release, you need to update the major tag to point to the new release. For example, suppose that the previous release was `v2.1.0`, and suppose that you just created the new release `v2.2.0`. You need to update the major tag `v2` so that it points to `v2.2.0`. Here are the commands:
-
-```bash
-# Create/update the new major tag locally, where the new major tag will point to the
-# release that you created in the previous step.
-#
-# The `-f` flag forcibly overwrites the old major tag (if it exists).
-major_tag="$(echo ${tag:?} | grep -o '^v[0-9]*')"
-git tag --force "${major_tag:?}" "${tag:?}"
-```
-
-Step 4: Now you need to push the tags:
-
-```bash
-# Regular-push the new tag:
-git push origin tag "${tag:?}"
-
-# Force-push the new major tag:
-git push origin tag "${major_tag:?}" --force
-```
-
-## Part 2: Create the GitHub Release
-
-Go to the [Releases](https://github.com/julia-actions/cache/releases) section of this repo and create a new release (using the GitHub web interface).
-
-For the "choose a tag" drop-down field, select the new tag (e.g. `v2.2.0`) that you created and pushed in Part 1 of this guide.

handle_caches.jl

@@ -10,48 +10,37 @@ function handle_caches()
         repo, restore_key, ref = ARGS[2:4]
         allow_failure = ARGS[5] == "true"
 
+        endpoint = "/repos/$repo/actions/caches"
         page = 1
         per_page = 100
-        skipped = String[]
-        deleted = String[]
-        failed = String[]
+        escaped_restore_key = replace(restore_key, "\"" => "\\\"")
+        query = ".actions_caches[] | select(.key | startswith(\"$escaped_restore_key\")) | .id"
+
+        deletions = String[]
+        failures = String[]
         while 1 <= page <= 5 # limit to avoid accidental rate limiting
-            # https://docs.github.com/en/rest/actions/cache?apiVersion=2022-11-28#list-github-actions-caches-for-a-repository
-            # Note: The `key` field matches on the full key or a prefix.
-            cmd = ```
-                gh api -X GET /repos/$repo/actions/caches
-                    --field per_page=$per_page
-                    --field page=$page
-                    --field ref=$ref
-                    --field key=$restore_key
-                    --field sort=last_accessed_at
-                    --field direction=desc
-                    --jq '.actions_caches[].id'
-                ```
+            cmd = `gh api -X GET $endpoint -F ref=$ref -F per_page=$per_page -F page=$page --jq $query`
             ids = split(read(cmd, String); keepempty=false)
+            page = length(ids) == per_page ? page + 1 : -1
 
-            # Avoid deleting the latest used cache entry. This is particularly important for
-            # job failures where a new cache entry will not be saved after this.
-            page == 1 && !isempty(ids) && push!(skipped, popfirst!(ids))
-
+            # We can delete all cache entries on this branch that matches the restore key
+            # because the new cache is saved later.
             for id in ids
                 try
                     run(`gh cache delete $id --repo $repo`)
-                    push!(deleted, id)
+                    push!(deletions, id)
                 catch e
                     @error e
-                    push!(failed, id)
+                    push!(failures, id)
                 end
             end
-
-            page = length(ids) == per_page ? page + 1 : -1
         end
-        if isempty(skipped) && isempty(deleted) && isempty(failed)
+        if isempty(failures) && isempty(deletions)
             println("No existing caches found on ref `$ref` matching restore key `$restore_key`")
         else
-            if !isempty(failed)
-                println("Failed to delete $(length(failed)) existing caches on ref `$ref` matching restore key `$restore_key`")
-                println.(failed)
+            if !isempty(failures)
+                println("Failed to delete $(length(failures)) existing caches on ref `$ref` matching restore key `$restore_key`")
+                println.(failures)
                 @info """
                     To delete caches you need to grant the following to the default `GITHUB_TOKEN` by adding
                     this to your workflow:
@@ -66,9 +55,9 @@ function handle_caches()
                     """
                 allow_failure || exit(1)
             end
-            if !isempty(deleted)
-                println("Deleted $(length(deleted)) caches on ref `$ref` matching restore key `$restore_key`")
-                println.(deleted)
+            if !isempty(deletions)
+                println("Deleted $(length(deletions)) caches on ref `$ref` matching restore key `$restore_key`")
+                println.(deletions)
             end
         end
     else