Add release date for v1.0.0

This protects against changes to the Docker images that `cross` uses.

Changes.md

@@ -1,3 +1,24 @@
+## 1.0.0 - 2025-01-11
+
+The addition of caching is a significant behavior change for this action, so the version has been
+bumped to v1.0.0 because of this change.
+
+- This action will now configure and use `Swatinem/rust-cache` by default for you. It will include
+  the `target` parameter as part of the cache key automatically, as well as the OS version when
+  using `cargo` on Linux. Suggested by @jennydaman (Jennings Zhang). GH #23.
+- This action now validates its input and will exit early if they are not valid. GH #35.
+- When compiling for `musl` targets, this action will not try to reinstall the `musl-tools` package
+  if it's already installed.
+
+The following changes were made since the 1.0.0-beta1 release:
+
+- The cache key includes information that causes the cache to not be re-used when the system running
+  `cargo` or `cross` changes. When using `cargo` on Linux, this is the OS version, like "Ubuntu
+  22.04". When using `cross`, this is the hash of the `cross` binary itself. This is needed because
+  the Docker images that `cross` uses can change when the binary is updated. This can include
+  changing the underlying Docker image base OS, in which case it's quite likely the old cache
+  contents would be incompatible with the the new image.
+
 ## 1.0.0-beta1 - 2024-12-21
 
 The addition of caching is a significant behavior change for this action, so the version has been

README.md

@@ -106,6 +106,15 @@ value for crates without a `Cargo.lock` file. The `key` parameter passed to this
 include the value of the `target` input. If you specify a `key` parameter in
 `rust-cache-parameters`, then the `target` input will be appended to the value you specify.
 
+When running `cargo` on a Linux system, it will also include the output of running
+`lsb_release --short --description` in the cache key. This is important for crates that link against
+system libraries. If those library versions change across OS versions (e.g. Ubuntu 20.04 to 22.04),
+then the cache will be broken for these cases.
+
+When running `cross`, the hash of the `cross` binary will be included in the cache key. This is done
+because the Docker images that `cross` uses can change when `cross` is updated. We want to make sure
+that we do not re-use the cache across changes when these images change.
+
 Finally, it will run `strip` to strip the binaries it builds if the `strip` parameter is true. This
 is only possible for builds that are not done via `cross`. In addition, Windows builds for `aarch64`
 cannot be stripped either.

action.yml

@@ -53,6 +53,10 @@ inputs:
 runs:
   using: composite
   steps:
+    - name: Show inputs
+      shell: bash
+      run: |
+        echo '${{ toJSON(inputs) }}'
     - name: Add this action's path to PATH
       shell: bash
       run: echo "${{ github.action_path }}" >> $GITHUB_PATH
@@ -107,7 +111,12 @@ runs:
         GITHUB_TOKEN: ${{ inputs.GITHUB_TOKEN }}
     - name: Install musl-tools on Linux if target includes "musl"
       shell: bash
-      run: sudo apt-get update --yes && sudo apt-get install --yes musl-tools
+      run: |
+        if dpkg -l musl-tools | grep -q "^ii\s*musl-tools"; then
+            exit 0
+        fi
+        sudo apt-get update --yes && \
+            sudo apt-get install --yes musl-tools
       if: steps.determine-cross-compile.outputs.needs-cross != 'true' && contains(inputs.target, 'musl')
     - name: Set build command
       id: set-build-command
@@ -124,9 +133,14 @@ runs:
         set -e
         set -x
         set -o pipefail
+        OS_VERSION=""
+        if [ -x /usr/bin/lsb_release ]; then
+            # This will be something like "Ubuntu 22.04.5 LTS"
+            OS_VERSION="$( lsb_release --short --description )"
+        fi
         # This will get the inputs JSON from the `RUST_CACHE_PARAMETERS` env var. This avoids
         # any string interpolation issues, since the inputs will contain quotes.
-        parse-rust-cache-parameters.py "${{ inputs.target }}"
+        parse-and-set-rust-cache-parameters.py "${{ inputs.target }}" "${{ steps.set-build-command.outputs.build-command }}" "$OS_VERSION"
       env:
         RUST_CACHE_PARAMETERS: ${{ inputs.rust-cache-parameters }}
       if: inputs.use-rust-cache == 'true'

parse-and-set-rust-cache-parameters.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import sys
+import hashlib
+
+
+def main():
+    target = sys.argv[1]
+    build_command = sys.argv[2]
+
+    os_version = sys.argv[3]
+
+    parameters = json.loads(os.environ["RUST_CACHE_PARAMETERS"])
+    if "key" not in parameters:
+        parameters["key"] = target
+    else:
+        parameters["key"] += "-{}".format(target)
+
+    if build_command == "cargo":
+        # If we're running cargo, we need to add the OS version to the cache. Otherwise things that link
+        # against system packages, like openssl, can break when we use the same cache across different
+        # versions of the runner OS. For example, when going from Ubuntu 20.04 to 22.04, we move from
+        # OpenSSL 1.1.x to 3.x.
+        parameters["key"] += "-{}".format(os_version)
+    else:
+        # Otherwise we want to include the `cross` binary's hash. The Docker images that `cross`
+        # uses can change when the binary is updated. This protects us from using the same cache
+        # inside containers that have changed.
+        parameters["key"] += "-cross-binary-hash-{}".format(
+            get_file_hash(build_command)
+        )
+
+    file = os.environ["GITHUB_OUTPUT"]
+    with open(file, "w") as f:
+        for key, value in parameters.items():
+            f.write(f"{key}={value}")
+
+
+def get_file_hash(build_command):
+    with open(build_command, "rb") as f:
+        file_hash = hashlib.sha256()
+        while chunk := f.read(65536):
+            file_hash.update(chunk)
+            return file_hash.hexdigest()
+
+
+main()

parse-rust-cache-parameters.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-
-import json
-import os
-import sys
-
-parameters = json.loads(os.environ["RUST_CACHE_PARAMETERS"])
-if "key" not in parameters:
-    parameters["key"] = sys.argv[1]
-else:
-    parameters["key"] = "{}-{}".format(parameters["key"], sys.argv[1])
-
-file = os.environ["GITHUB_OUTPUT"]
-with open(file, "w") as f:
-    for key, value in parameters.items():
-        f.write(f"{key}={value}")