Add release date for 1.0.4

Allow any command to support things like cargo-deb
Rename platform_name -> name in test matrix
2025-04-12 09:14:40 -05:00 · 2025-04-12 09:06:04 -05:00 · 2025-04-12 09:04:33 -05:00 · 2025-04-12 09:04:33 -05:00 · 2025-04-12 09:04:33 -05:00 · 2025-04-12 09:04:33 -05:00
15 changed files with 764 additions and 343 deletions
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -8,7 +8,7 @@ env:
 jobs:
  lint:
    name: Check that code is lint clean using precious
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@v4
      - name: Install mise
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,210 +11,278 @@ jobs:
      fail-fast: false
      matrix:
        platform:
-          - platform_name: FreeBSD-x86_64
-            runs-on: ubuntu-22.04
+          - name: FreeBSD-x86_64
+            runs-on: ubuntu-24.04
            target: x86_64-unknown-freebsd
            cache-cross-binary: true
-            expect_file_re: "x86-64.+FreeBSD"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: false
+            expect-file-re: "x86-64.+FreeBSD"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: false

-          - platform_name: Linux-x86_64
-            runs-on: ubuntu-22.04
+          - name: Linux-x86_64
+            runs-on: ubuntu-24.04
+            # It's important to use a musl target here to make sure that the step to install
+            # musl-tools works.
            target: x86_64-unknown-linux-musl
            cache-cross-binary: true
-            expect_file_re: "ELF.+x86-64"
-            expect_cross: ""
-            expect_stripped: "--expect-stripped"
-            can_execute: true
+            expect-file-re: "ELF.+x86-64"
+            expect-cross: ""
+            expect-stripped: "--expect-stripped"
+            can-execute: true

-          - platform_name: Linux-aarch64
-            runs-on: ubuntu-22.04
+          - name: Linux-x86_64 (beta)
+            runs-on: ubuntu-24.04
+            target: x86_64-unknown-linux-musl
+            toolchain: beta
+            cache-cross-binary: true
+            expect-file-re: "ELF.+x86-64"
+            expect-cross: ""
+            expect-stripped: "--expect-stripped"
+            can-execute: true
+
+          - name: Linux-x86_64 (nightly)
+            runs-on: ubuntu-24.04
+            target: x86_64-unknown-linux-musl
+            toolchain: nightly
+            cache-cross-binary: true
+            expect-file-re: "ELF.+x86-64"
+            expect-cross: ""
+            expect-stripped: "--expect-stripped"
+            can-execute: true
+
+          - name: Linux-x86_64 (force cross)
+            runs-on: ubuntu-24.04
+            target: x86_64-unknown-linux-gnu
+            force-use-cross: true
+            cache-cross-binary: true
+            expect-file-re: "ELF.+x86-64"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true
+
+          - name: Linux-x86_64 (stable 8 months ago)
+            runs-on: ubuntu-24.04
+            target: x86_64-unknown-linux-gnu
+            toolchain: "stable 8 months ago"
+            cache-cross-binary: true
+            expect-file-re: "ELF.+x86-64"
+            expect-cross: ""
+            expect-stripped: "--expect-stripped"
+            can-execute: true
+
+          - name: Linux-aarch64
+            runs-on: ubuntu-24.04
            target: aarch64-unknown-linux-musl
            cache-cross-binary: true
-            expect_file_re: "aarch64"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "aarch64"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-aarch64 (no cache)
-            runs-on: ubuntu-22.04
-            target: aarch64-unknown-linux-musl
+          - name: Linux-aarch64 (no cache)
+            runs-on: ubuntu-24.04
+            target: aarch64-unknown-linux-gnu
            cache-cross-binary: false
-            expect_file_re: "aarch64"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "aarch64"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-aarch64 with cross v0.2.3
-            runs-on: ubuntu-22.04
-            target: aarch64-unknown-linux-musl
+          - name: Linux-aarch64 with cross v0.2.3
+            runs-on: ubuntu-24.04
+            target: aarch64-unknown-linux-gnu
            cross-version: "v0.2.3"
            cache-cross-binary: true
-            expect_file_re: "aarch64"
-            expect_cross: "--expect-cross"
-            expect_cross_version: "0.2.3"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "aarch64"
+            expect-cross: "--expect-cross"
+            expect-cross-version: "0.2.3"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-aarch64 with cross v0.2.3 (no cache)
-            runs-on: ubuntu-22.04
-            target: aarch64-unknown-linux-musl
+          - name: Linux-aarch64 with cross v0.2.3 (no cache)
+            runs-on: ubuntu-24.04
+            target: aarch64-unknown-linux-gnu
            cross-version: "v0.2.3"
            cache-cross-binary: false
-            expect_file_re: "aarch64"
-            expect_cross: "--expect-cross"
-            expect_cross_version: "0.2.3"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "aarch64"
+            expect-cross: "--expect-cross"
+            expect-cross-version: "0.2.3"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-aarch64 with cross 19be834
-            runs-on: ubuntu-22.04
-            target: aarch64-unknown-linux-musl
+          - name: Linux-aarch64 with cross 19be834
+            runs-on: ubuntu-24.04
+            target: aarch64-unknown-linux-gnu
            cross-version: "19be834"
            cache-cross-binary: true
-            expect_file_re: "aarch64"
-            expect_cross: "--expect-cross"
-            expect_cross_version: "19be834"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "aarch64"
+            expect-cross: "--expect-cross"
+            expect-cross-version: "19be834"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-aarch64 with cross 19be834
-            runs-on: ubuntu-22.04
-            target: aarch64-unknown-linux-musl
+          - name: Linux-aarch64 with cross 19be834 (no cache)
+            runs-on: ubuntu-24.04
+            target: aarch64-unknown-linux-gnu
            cross-version: "19be834"
            cache-cross-binary: false
-            expect_file_re: "aarch64"
-            expect_cross: "--expect-cross"
-            expect_cross_version: "19be834"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "aarch64"
+            expect-cross: "--expect-cross"
+            expect-cross-version: "19be834"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-arm
-            runs-on: ubuntu-22.04
-            target: arm-unknown-linux-musleabi
+          - name: Linux-aarch64 with arm64 host
+            runs-on: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
            cache-cross-binary: true
-            expect_file_re: "32.+ARM"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "aarch64"
+            expect-cross: ""
+            expect-stripped: "--expect-stripped"
+            can-execute: true

-          - platform_name: Linux-i586
-            runs-on: ubuntu-22.04
-            target: i586-unknown-linux-musl
+          # This fails because of some sort of weird bug in cross. See
+          # https://github.com/cross-rs/cross/issues/1628 for more details. Until that's fixed
+          # cross-compiling on Linux ARM won't work without a custom Docker image, which I don't
+          # want to do just for the sake of testing this.
+          #
+          # - name: Linux-aarch64 with arm64 host compile to x86-64
+          #   runs-on: ubuntu-24.04-arm
+          #   target: x86_64-unknown-linux-gnu
+          #   # Until cross produces arm64 binary releases we _have_ to set this when running on
+          #   # arm64.
+          #   cross-version: "c7dee4d"
+          #   cache-cross-binary: true
+          #   expect-file-re: "ELF.+x86-64"
+          #   expect-cross: "--expect-cross"
+          #   expect-stripped: ""
+          #   can-execute: true
+
+          - name: Linux-arm
+            runs-on: ubuntu-24.04
+            target: arm-unknown-linux-gnueabi
            cache-cross-binary: true
-            expect_file_re: "ELF.+80386"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "32.+ARM"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-i686
-            runs-on: ubuntu-22.04
-            target: i686-unknown-linux-musl
+          - name: Linux-i586
+            runs-on: ubuntu-24.04
+            target: i586-unknown-linux-gnu
            cache-cross-binary: true
-            expect_file_re: "ELF.+80386"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "ELF.+80386"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-powerpc
-            runs-on: ubuntu-22.04
+          - name: Linux-i686
+            runs-on: ubuntu-24.04
+            target: i686-unknown-linux-gnu
+            cache-cross-binary: true
+            expect-file-re: "ELF.+80386"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true
+
+          - name: Linux-powerpc
+            runs-on: ubuntu-24.04
            target: powerpc-unknown-linux-gnu
            cache-cross-binary: true
-            expect_file_re: "32.+PowerPC"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "32.+PowerPC"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-powerpc64
-            runs-on: ubuntu-22.04
+          - name: Linux-powerpc64
+            runs-on: ubuntu-24.04
            target: powerpc64-unknown-linux-gnu
            cache-cross-binary: true
-            expect_file_re: "64.+PowerPC"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "64.+PowerPC"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-powerpc64le
-            runs-on: ubuntu-22.04
+          - name: Linux-powerpc64le
+            runs-on: ubuntu-24.04
            target: powerpc64le-unknown-linux-gnu
            cache-cross-binary: true
-            expect_file_re: "64.+PowerPC"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "64.+PowerPC"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-riscv64
-            runs-on: ubuntu-22.04
+          - name: Linux-riscv64
+            runs-on: ubuntu-24.04
            target: riscv64gc-unknown-linux-gnu
            cache-cross-binary: true
-            expect_file_re: "64.+RISC-V"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "64.+RISC-V"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: Linux-s390x
-            runs-on: ubuntu-22.04
+          - name: Linux-s390x
+            runs-on: ubuntu-24.04
            target: s390x-unknown-linux-gnu
            cache-cross-binary: true
-            expect_file_re: "64.+S/390"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: true
+            expect-file-re: "64.+S/390"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: true

-          - platform_name: NetBSD-x86_64
-            runs-on: ubuntu-22.04
+          - name: NetBSD-x86_64
+            runs-on: ubuntu-24.04
            target: x86_64-unknown-netbsd
            cache-cross-binary: true
-            expect_file_re: "x86-64.+NetBSD"
-            expect_cross: "--expect-cross"
-            expect_stripped: ""
-            can_execute: false
+            expect-file-re: "x86-64.+NetBSD"
+            expect-cross: "--expect-cross"
+            expect-stripped: ""
+            can-execute: false

-          - platform_name: Windows-aarch64
+          - name: Windows-aarch64
            runs-on: windows-latest
            target: aarch64-pc-windows-msvc
            cache-cross-binary: true
-            expect_file_re: "Aarch64.+Windows"
-            expect_cross: ""
-            expect_stripped: ""
-            can_execute: false
+            expect-file-re: "Windows.+ARM64"
+            expect-cross: ""
+            expect-stripped: ""
+            can-execute: false

-          - platform_name: Windows-i686
+          - name: Windows-i686
            runs-on: windows-latest
            target: i686-pc-windows-msvc
            cache-cross-binary: true
-            expect_file_re: "80386.+Windows"
-            expect_cross: ""
-            expect_stripped: "--expect-stripped"
-            can_execute: true
+            expect-file-re: "Windows.+Intel i386"
+            expect-cross: ""
+            expect-stripped: "--expect-stripped"
+            can-execute: true

-          - platform_name: Windows-x86_64
+          - name: Windows-x86_64
            runs-on: windows-latest
            target: x86_64-pc-windows-msvc
            cache-cross-binary: true
-            expect_file_re: "x86-64.+Windows"
-            expect_stripped: "--expect-stripped"
-            can_execute: true
+            expect-file-re: "Windows.+x86-64"
+            expect-stripped: "--expect-stripped"
+            can-execute: true

-          - platform_name: macOS-x86_64
+          - name: macOS-x86_64
            runs-on: macOS-latest
            target: x86_64-apple-darwin
            cache-cross-binary: true
-            expect_file_re: "Mach-O.+x86_64"
-            expect_cross: ""
-            expect_stripped: "--expect-stripped"
-            can_execute: true
+            expect-file-re: "Mach-O.+x86_64"
+            expect-cross: ""
+            expect-stripped: "--expect-stripped"
+            can-execute: true

-          - platform_name: macOS-aarch64
+          - name: macOS-aarch64
            runs-on: macOS-latest
            target: aarch64-apple-darwin
            cache-cross-binary: true
-            expect_file_re: "Mach-O.+arm64"
-            expect_cross: ""
-            expect_stripped: "--expect-stripped"
-            can_execute: false
+            expect-file-re: "Mach-O.+arm64"
+            expect-cross: ""
+            expect-stripped: "--expect-stripped"
+            can-execute: false

    runs-on: ${{ matrix.platform.runs-on }}
    steps:
@@ -229,60 +297,48 @@ jobs:
        uses: ./
        with:
          command: both
+          force-use-cross: ${{ matrix.platform.force-use-cross || false }}
          cross-version: ${{ matrix.platform.cross-version }}
          cache-cross-binary: ${{ matrix.platform.cache-cross-binary }}
          target: ${{ matrix.platform.target }}
+          toolchain: ${{ matrix.platform.toolchain || 'stable' }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        if: ${{ matrix.platform.can_execute }}
+        if: ${{ matrix.platform.can-execute }}
      - name: Run test command
        uses: ./
        with:
          command: test
+          force-use-cross: ${{ matrix.platform.force-use-cross || false }}
          cross-version: ${{ matrix.platform.cross-version }}
          cache-cross-binary: ${{ matrix.platform.cache-cross-binary }}
          target: ${{ matrix.platform.target }}
+          toolchain: ${{ matrix.platform.toolchain || 'stable' }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        if: ${{ matrix.platform.can_execute }}
+        if: ${{ matrix.platform.can-execute }}
      - name: Run test command with args
        uses: ./
        with:
          command: test
+          force-use-cross: ${{ matrix.platform.force-use-cross || false }}
          cross-version: ${{ matrix.platform.cross-version }}
          cache-cross-binary: ${{ matrix.platform.cache-cross-binary }}
          target: ${{ matrix.platform.target }}
+          toolchain: ${{ matrix.platform.toolchain || 'stable' }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          args: "-- --ignored"
-        if: ${{ matrix.platform.can_execute }}
+        if: ${{ matrix.platform.can-execute }}
      - name: Run build command
        uses: ./
        with:
          command: build
+          force-use-cross: ${{ matrix.platform.force-use-cross || false }}
          cross-version: ${{ matrix.platform.cross-version }}
          cache-cross-binary: ${{ matrix.platform.cache-cross-binary }}
          target: ${{ matrix.platform.target }}
+          toolchain: ${{ matrix.platform.toolchain || 'stable' }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          strip: true
-      - name: Run build command for subdir
-        uses: ./
-        with:
-          command: build
-          cross-version: ${{ matrix.platform.cross-version }}
-          cache-cross-binary: ${{ matrix.platform.cache-cross-binary }}
-          working-directory: subcrate
-          target: ${{ matrix.platform.target }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          strip: true
-      - name: Run bench command
-        uses: ./
-        with:
-          command: bench
-          cross-version: ${{ matrix.platform.cross-version }}
-          cache-cross-binary: ${{ matrix.platform.cache-cross-binary }}
-          target: ${{ matrix.platform.target }}
-          working-directory: bench
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        if: ${{ matrix.platform.can_execute }}
-      - name: Check binary and cross on ${{ matrix.platform.platform_name }}
+      - name: Check binary and cross for main crate on ${{ matrix.platform.name }}
        shell: bash
        run: |
          set -e
@@ -290,17 +346,95 @@ jobs:
          cargo run --manifest-path ./run-tests/Cargo.toml -- \
              --checkout-root "$PWD" \
              --target "${{ matrix.platform.target }}" \
-              --expect-file-re "${{ matrix.platform.expect_file_re }}" \
-              --expect-cross-version "${{ matrix.platform.expect_cross_version }}" \
-              ${{ matrix.platform.expect_cross }} \
-              ${{ matrix.platform.expect_stripped }}
+              --expect-file-re "${{ matrix.platform.expect-file-re }}" \
+              --expect-cross-version "${{ matrix.platform.expect-cross-version }}" \
+              ${{ matrix.platform.expect-cross }} \
+              ${{ matrix.platform.expect-stripped }}
+      - name: Run build command for subdir
+        uses: ./
+        with:
+          command: build
+          force-use-cross: ${{ matrix.platform.force-use-cross || false }}
+          cross-version: ${{ matrix.platform.cross-version }}
+          cache-cross-binary: ${{ matrix.platform.cache-cross-binary }}
+          working-directory: subcrate
+          target: ${{ matrix.platform.target }}
+          toolchain: ${{ matrix.platform.toolchain || 'stable' }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          strip: true
+      - name: Check binary and cross for subcrate on ${{ matrix.platform.name }}
+        shell: bash
+        run: |
+          set -e
+          set -x
+          cargo run --manifest-path ./run-tests/Cargo.toml -- \
+              --checkout-root "$PWD" \
+              --target "${{ matrix.platform.target }}" \
+              --expect-file-re "${{ matrix.platform.expect-file-re }}" \
+              --expect-cross-version "${{ matrix.platform.expect-cross-version }}" \
+              ${{ matrix.platform.expect-cross }} \
+              ${{ matrix.platform.expect-stripped }} \
+              --is-subcrate
+      - name: Run bench command
+        uses: ./
+        with:
+          command: bench
+          force-use-cross: ${{ matrix.platform.force-use-cross || false }}
+          cross-version: ${{ matrix.platform.cross-version }}
+          cache-cross-binary: ${{ matrix.platform.cache-cross-binary }}
+          target: ${{ matrix.platform.target }}
+          working-directory: bench
+          toolchain: ${{ matrix.platform.toolchain || 'stable' }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        if: ${{ matrix.platform.can-execute }}
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-artifacts-${{ matrix.platform.name }}
+          path: |
+            target/${{ matrix.platform.target }}/debug/bin*
+            subcrate/target/${{ matrix.platform.target }}/debug/subcrate

  test-validate-inputs:
    name: Test validate-inputs
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Run tests
        shell: bash
        run: ./validate-inputs.py --test
+
+  test-other-cargo-commands:
+    name: Test a "cargo foo" command
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Copy test project to root
+        shell: bash
+        run: |
+          cp -a test-project/* .
+          rm -fr test-project
+      - name: Create cargo-foo command
+        shell: bash
+        run: |
+          set -e
+          set -x
+
+          dir="${{ github.workspace }}/bin"
+          mkdir -p "$dir"
+
+          bin="$dir/cargo-foo"          
+
+          echo "#!/bin/bash" >> "$bin"
+          echo "echo 'This is cargo-foo!'" >> "$bin"
+          echo "exit 0" >> "$bin"
+          chmod 0755 "$bin"
+
+          echo "PATH=$dir:$PATH" >> "$GITHUB_ENV"
+      - name: Run cargo-foo command
+        uses: ./
+        with:
+          command: foo
+          target: x86_64-unknown-linux-gnu
--- a/Changes.md
+++ b/Changes.md
@@ -1,3 +1,53 @@
+## 1.0.4 - 2025-04-12
+
+- Removed validation for the `toolchain` input. The
+  [dtolnay/rust-toolchain](https://github.com/dtolnay/rust-toolchain) accepts a lot of different
+  options that this action wasn't allowing. It's simpler and more flexible to just let that action
+  handle validation. Requested by @axos88 (Akos Vandra-Meyer). GH #42.
+- Removed validation for the `command` input. This allows you to use this action with any `cargo`
+  extension command, like `cargo-deb`. Setting `command` to `both` is still supported and will run
+  the `build` and `test` commands. Requested by @bvaisvil (Benjamin Vaisvil). GH #43.
+
+## 1.0.3 - 2025-02-17
+
+- Fixed a bug when running with a Linux ARM host where the action would use a cached `cross`
+  download for x86-64 Linux (or vice versa). Now the cache key for the `cross` binary includes both
+  the runner's architecture in addition to its OS.
+- This release partially support running on Linxu ARM, but see the `README.md` file for details on
+  this.
+
+## 1.0.2 - 2025-02-16
+
+- Added a new `force-use-cross` input, which does what it says. It will force the use of `cross`
+  even when it is not required for given platform/target combination. Note that this only works on
+  Linux hosts.
+
+## 1.0.1 - 2025-01-20
+
+- Fixed a bug where this action would attempt to use `cross` when compiling for an ARM Linux target
+  on an ARM Linux host.
+
+## 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
@@ -6,7 +56,7 @@ 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. Suggested by @jennydaman (Jennings
  Zhang). GH #23.
- This action now validates its input and will exit early if they are not valid. GH #35.
+- This action now validates its inputs and will exit early if they are not valid. GH #35.

 ## 0.0.17 - 2024-11-23

--- a/README.md
+++ b/README.md
@@ -14,20 +14,19 @@ jobs:
      matrix:
        platform:
          - os-name: FreeBSD-x86_64
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-24.04
            target: x86_64-unknown-freebsd
-            skip_tests: true

          - os-name: Linux-x86_64
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-24.04
            target: x86_64-unknown-linux-musl

          - os-name: Linux-aarch64
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-24.04
            target: aarch64-unknown-linux-musl

          - os-name: Linux-riscv64
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-24.04
            target: riscv64gc-unknown-linux-gnu

          - os-name: Windows-x86_64
@@ -61,7 +60,7 @@ jobs:
 Note that for Linux or BSD targets, you should always set the `runs-on` key to a Linux x86-64
 architecture runner.

-If you _only_ want to do native ARM compilation, for example using the `ubuntu-latest-arm` runner,
+If you _only_ want to do native ARM compilation, for example using the `ubuntu-24.04-arm` runner,
 then there's no need to use this action. However, if you want to compile for _many_ platforms,
 including Linux ARM, using this action will simplify your config. This action is only tested on
 Ubuntu x86-64, Windows, and macOS runners.
@@ -70,18 +69,39 @@ Ubuntu x86-64, Windows, and macOS runners.

 This action takes the following parameters:

-| Key                     | Type                                                                 | Required? | Description                                                                                                                                                                                                                                                                                                                                   |
-| ----------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `command`               | string (one of `build`, `test`, `both` (build and test), or `bench`) | no        | The command(s) to run. The default is `build`. Running the `test` command will fail with \*BSD targets and non-x86 Windows.                                                                                                                                                                                                                   |
-| `target`                | string                                                               | yes       | The target triple to compile for. This should be one of the targets found by running `rustup target list`.                                                                                                                                                                                                                                    |
-| `working-directory`     | string                                                               | no        | The working directory in which to run the `cargo` or `cross` commands. Defaults to the current directory (`.`).                                                                                                                                                                                                                               |
-| `toolchain`             | string (one of `stable`, `beta`, or `nightly`)                       | no        | The Rust toolchain version to install. The default is `stable`.                                                                                                                                                                                                                                                                               |
-| `GITHUB_TOKEN`          | string                                                               | no        | Defaults to the value of `${{ github.token }}`.                                                                                                                                                                                                                                                                                               |
-| `args`                  | string                                                               | no        | A string-separated list of arguments to be passed to `cross build`, like `--release --locked`.                                                                                                                                                                                                                                                |
-| `strip`                 | boolean (`true` or `false`)                                          | no        | If this is true, then the resulting binaries will be stripped if possible. This is only possible for binaries which weren't cross-compiled.                                                                                                                                                                                                   |
-| `cross-version`         | string                                                               | no        | This can be used to set the version of `cross` to use. If specified, it should be a specific `cross` release tag (like `v0.2.3`) or a git ref (commit hash, `HEAD`, etc.). If this is not set then the latest released version will always be used. If this is set to a git ref then the version corresponding to that ref will be installed. |
-| `use-rust-cache`        | boolean                                                              | no        | Whether or not to use [the `Swatinem/rust-cache@v2` action](https://github.com/Swatinem/rust-cache). This defaults to true.                                                                                                                                                                                                                   |
-| `rust-cache-parameters` | string (containing JSON)                                             | no        | This must be a string containing valid JSON. The JSON should be an object where the keys are the parameters for [the `Swatinem/rust-cache@v2` action](https://github.com/Swatinem/rust-cache).                                                                                                                                                |
+| Key                     | Type                        | Required? | Description                                                                                                                                                                                                                                                                                                                                   |
+| ----------------------- | --------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `command`               | string                      | no        | The command(s) to run. The default is `build`. Running the `test` command will fail with \*BSD targets and non-x86 Windows. You can use any command supported by `cargo` and/or `cross`. For example, if you install `cargo-deb`, the command can be `deb`. Use the special string "both" to run both `build` and `test.                      |
+| `target`                | string                      | yes       | The target triple to compile for. This should be one of the targets found by running `rustup target list`.                                                                                                                                                                                                                                    |
+| `working-directory`     | string                      | no        | The working directory in which to run the `cargo` or `cross` commands. Defaults to the current directory (`.`).                                                                                                                                                                                                                               |
+| `toolchain`             | string)                     | no        | The Rust toolchain version to install. This is passed directly to [dtolnay/rust-toolchain](https://github.com/dtolnay/rust-toolchain), which accepts many different options. See its documentation for more details. The default is `stable`.                                                                                                 |
+| `GITHUB_TOKEN`          | string                      | no        | Defaults to the value of `${{ github.token }}`.                                                                                                                                                                                                                                                                                               |
+| `args`                  | string                      | no        | A string-separated list of arguments to be passed to `cross build`, like `--release --locked`.                                                                                                                                                                                                                                                |
+| `strip`                 | boolean (`true` or `false`) | no        | If this is true, then the resulting binaries will be stripped if possible. This is only possible for binaries which weren't cross-compiled.                                                                                                                                                                                                   |
+| `cross-version`         | string                      | no        | This can be used to set the version of `cross` to use. If specified, it should be a specific `cross` release tag (like `v0.2.3`) or a git ref (commit hash, `HEAD`, etc.). If this is not set then the latest released version will always be used. If this is set to a git ref then the version corresponding to that ref will be installed. |
+| `force-use-cross`       | boolean (`true` or `false`) | no        | If this is true, then the action will use `cross` even if it is not needed for the given target. If this is set to `true`, then the resulting binary will not be stripped, regardless of whether `strip` is `true` or not. This only works on Linux hosts. Forcing the use of `cross` on other hosts is not supported.                        |
+| `use-rust-cache`        | boolean                     | no        | Whether or not to use [the `Swatinem/rust-cache@v2` action](https://github.com/Swatinem/rust-cache). This defaults to true.                                                                                                                                                                                                                   |
+| `rust-cache-parameters` | string (containing JSON)    | no        | This must be a string containing valid JSON. The JSON should be an object where the keys are the parameters for [the `Swatinem/rust-cache@v2` action](https://github.com/Swatinem/rust-cache).                                                                                                                                                |
+
+### Setting Environment Variables
+
+By default, `cross` passes most rust-related environment variables through when it runs `cargo` in a
+Docker image. This means you can simply set an `env` key in the workflow step that uses this action.
+
+```
+- name: Run build command
+  uses: houseabsolute/actions-rust-cross@v1
+  env:
+    CARGO_LOG: debug
+    RUSTFLAGS: "-g"
+  with:
+    command: build
+```
+
+If you want to pass other environment variables through, you will need to configure `cross` to do
+see. See the
+[`cross` docs](https://github.com/cross-rs/cross/blob/main/docs/environment_variables.md#environment-variable-passthrough)
+for more details.

 ## How it Works

@@ -99,13 +119,85 @@ build `cross`.
 When compiling on Windows, it will do so in a Powershell environment, which can matter in some
 corner cases, like compiling the `openssl` crate with the `vendored` feature.

-By default, it will use
-[the `Swatinem/rust-cache@v2` action](https://github.com/Swatinem/rust-cache) to cache compiled
-dependencies for this crate. Note that per the documentation for this action, it has fairly limited
-value for crates without a `Cargo.lock` file. The `key` parameter passed to this action will always
-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.
+
+### Caching
+
+By default, this action will use
+[the `Swatinem/rust-cache@v2` action](https://github.com/Swatinem/rust-cache) to cache compiled
+dependencies for a crate. Note that per the documentation for the `rust-cache` action, it has fairly
+limited value for crates without a `Cargo.lock` file. The `key` parameter passed to this action will
+always 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.
+
+#### Weird Caching Issue with Multiple Crates
+
+In my testing, it seemed like in some cases restoring the cache would delete existing files in a
+`target` directory. This manifested with this sequence of actions:
+
+1. Run `actions-rust-cross` to compile a crate in a top-level directory.
+2. Run `actions-rust-cross` to compile a crate in a subdirectory.
+
+After step 2, the compiled binaries from step 1 were no longer present, _sometimes_. I'm not sure
+exactly what's going on here, but my recommendation is to structure your workflows so that this
+cannot affect you.
+
+For example, if you have multiple crates, each of which builds a binary you want to release, then
+you can avoid this issue by structuring your workflow as follows:
+
+1. Run `actions-rust-cross` to compile crate A.
+2. Run the release steps for crate A.
+3. Run `actions-rust-cross` to compile crate B.
+4. Run the release steps for crate B.
+
+When structured this way, it does not matter if the output of crate A is deleted in step 3.
+
+## Cross-Compiling from Linux ARM Runners
+
+In theory, this should work, and this action does implement some of the necessary work for this.
+However, there are a couple issues with this:
+
+1. As of 2025-02-17, the `cross` project does not publish Linux ARM binary releases. That means that
+   in order to use `cross` on a Linux ARM runner as part of this action, you must set
+   `cross-version` to a more recent commit from the `cross` repo.
+2. There is
+   [a bug in `cross` that means you must use a custom Docker image](https://github.com/cross-rs/cross/issues/1628)
+   when cross-compiling from a Linux ARM runner. See
+   [this other `cross` issue](https://github.com/cross-rs/cross/issues/751) for more details.
+
+## Linting and Tidying this Code
+
+The code in this repo is linted and tidied with
+[`precious`](https://github.com/houseabsolute/precious). This repo contains a `mise.toml` file.
+[Mise](https://mise.jdx.dev/) is a tool for managing dev tools with per-repo configuration. You can
+install `mise` and use it to run `precious` as follows:
+
+```
+# Installs mise
+curl https://mise.run | sh
+# Installs precious and other dev tools
+mise install
+```
+
+Once this is done, you can run `precious` via `mise`:
+
+```
+# Lints all code
+mise exec -- precious lint -a
+# Tidies all code
+mise exec -- precious tidy -a
+```
+
+If you want to use `mise` for other projects, see [its documentation](https://mise.jdx.dev/) for
+more details on how you can configure your shell to always activate `mise`.
--- a/action.yml
+++ b/action.yml
@@ -1,61 +1,86 @@
 name: "Build Rust Projects with Cross"
 author: "Dave Rolsky <autarch@urth.org>"
+
 branding:
  icon: home
  color: gray-dark
+
 description: |
  Cross compile your Rust projects with cross (https://github.com/cross-rs/cross).
+
 inputs:
  target:
    description: The target platform
    required: true
+
  command:
    description: |
-      The commands to run. This must be one of "build", "test", "both" (build and test), or "bench".
+      The commands to run. Use "both" to run both "build" and "test".
    default: build
+
  toolchain:
    description: |
-      The target toolchain to use (one of "stable", "beta", or "nightly").
+      The target toolchain to use.
    default: stable
+
  working-directory:
    description: The working directory for each step
    default: "."
+
  GITHUB_TOKEN:
    description: |
      A GitHub token, available in the secrets.GITHUB_TOKEN working-directory variable.
    default: ${{ github.token }}
+
  args:
    description: |
      The arguments to be passed to cross or cargo when building, as a
      space-separated string.
    default: ""
+
  strip:
    description: Strip the compiled binary
    default: false
+
  cross-version:
    description: |
      The version of cross to use. If not specified, then the latest version
      will be used.
+
  cache-cross-binary:
    description: |
      Cache the cross binary if one is installed. This is primarily for use in
      tests of this action.
    default: true
+
+  force-use-cross:
+    description: |
+      If this is true, the action will use cross even for targets where it is not needed.
+    default: false
+
  use-rust-cache:
    description: |
      Use `Swatinem/rust-cache@v2`. Defaults to true.
    default: true
+
  rust-cache-parameters:
    description: |
      A JSON string containing parameters to pass to `Swatinem/rust-cache@v2`. You can use the
      `toJSON()` function in your action to make passing this easier.
    default: "{}"
+
 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
+
    - name: Validate inputs
      shell: bash
      run: |
@@ -67,17 +92,30 @@ runs:
        INPUTS_working_directory: ${{ inputs.working-directory }}
        INPUTS_strip: ${{ inputs.strip }}
        INPUTS_cache_cross_binary: ${{ inputs.cache-cross-binary }}
+        INPUTS_force_use_cross: ${{ inputs.force-use-cross }}
        INPUTS_use_rust_cache: ${{ inputs.use-rust-cache }}
        INPUTS_rust_cache_parameters: ${{ inputs.rust-cache-parameters }}
+
    - name: Determine whether we need to cross-compile
      id: determine-cross-compile
      shell: bash
-      run: set-cross-compile.sh ${{ inputs.target }}
+      run: set-cross-compile.py ${{ inputs.target }} ${{ inputs.force-use-cross }}
+
    - name: Install toolchain
      uses: dtolnay/rust-toolchain@master
      with:
        targets: ${{ inputs.target }}
        toolchain: ${{ inputs.toolchain }}
+
+    - name: Install qemu-user emulator binaries if cross-compiling on arm64 host
+      shell: bash
+      run: |
+        set -e
+        set -x
+
+        docker run --privileged --rm tonistiigi/binfmt --install all
+      if: steps.determine-cross-compile.outputs.needs-cross == 'true' && runner.os == 'Linux' && contains(runner.arch, 'ARM')
+
    - name: Determine cross version
      id: determine-cross-version
      shell: bash
@@ -85,6 +123,7 @@ runs:
      env:
        GITHUB_TOKEN: ${{ inputs.GITHUB_TOKEN }}
      if: steps.determine-cross-compile.outputs.needs-cross == 'true'
+
    # We need to access this in both this YAML config and shell scripts. It
    # doesn't seem like using ${{ env.RUNNER_TEMP }} works in the YAML config.
    - name: Set directory for installing cross
@@ -92,31 +131,42 @@ runs:
      shell: bash
      run: set-cross-dir.sh
      if: steps.determine-cross-compile.outputs.needs-cross == 'true'
+
    - name: Cache cross
      id: cache-cross
      uses: actions/cache@v4
      with:
        path: ${{ steps.set-cross-dir.outputs.cross-dir }}/cross
-        key: ${{ runner.os }}-${{ steps.determine-cross-version.outputs.cross-version }}
+        key: ${{ runner.os }}-${{ runner.arch }}-${{ steps.determine-cross-version.outputs.cross-version }}
      if: steps.determine-cross-compile.outputs.needs-cross == 'true' && inputs.cache-cross-binary == 'true'
+
    - name: Install cross if cross-compiling (*nix)
      shell: bash
      run: install-cross-nix.sh ${{ steps.set-cross-dir.outputs.cross-dir }} ${{ steps.determine-cross-version.outputs.cross-version }}
      if: steps.determine-cross-compile.outputs.needs-cross == 'true' && steps.cache-cross.outputs.cache-hit != 'true'
      env:
        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
      shell: bash
      run: set-build-command.sh ${{ steps.set-cross-dir.outputs.cross-dir }}
+
    - name: Determine which cargo commands to run
      id: determine-cargo-commands
      shell: bash
      run: determine-cargo-commands.sh ${{ inputs.command }}
+
    - name: Parse `rust-cache-parameters` and set inputs for `Swatinem/rust-cache@v2`
      id: parse-rust-cache-parameters
      shell: bash
@@ -124,56 +174,53 @@ 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'
+
    - name: Cache cargo & target directories
      uses: Swatinem/rust-cache@v2
      with: ${{ steps.parse-rust-cache-parameters.outputs }}
      if: inputs.use-rust-cache == 'true'
-    - name: Run tests (*nix)
+
+    - name: Run cargo test
      working-directory: ${{ inputs.working-directory }}
-      shell: bash
+      # We want to run in Powershell on Windows to make sure we compile in a native Windows
+      # environment. Some things won't compile properly under msys, notably OpenSSL, which is
+      # compiled locally when using the `openssl` crate with the `vendored` feature.
+      shell: ${{ runner.os == 'Windows' && 'powershell' || 'bash' }}
      run: |
-        ${{ steps.set-build-command.outputs.build-command }} +${{inputs.toolchain}} test --target ${{ inputs.target }} ${{ inputs.args }}
-      if: steps.determine-cargo-commands.outputs.test == 'true' && runner.os != 'Windows'
-    # We want to run in Powershell on Windows to make sure we compile in a
-    # native Windows environment. Some things won't compile properly under
-    # msys, notably OpenSSL, which is compiled locally when using the
-    # `openssl` crate with the `vendored` feature.
-    - name: Run tests (Windows)
+        ${{ steps.set-build-command.outputs.build-command }} test --target ${{ inputs.target }} ${{ inputs.args }}
+      if: steps.determine-cargo-commands.outputs.test == 'true'
+
+    - name: Run cargo build
      working-directory: ${{ inputs.working-directory }}
-      shell: powershell
+      # We want to run in Powershell on Windows to make sure we compile in a native Windows
+      # environment. Some things won't compile properly under msys, notably OpenSSL, which is
+      # compiled locally when using the `openssl` crate with the `vendored` feature.
+      shell: ${{ runner.os == 'Windows' && 'powershell' || 'bash' }}
      run: |
-        & ${{ steps.set-build-command.outputs.build-command }} +${{inputs.toolchain}} test --target ${{ inputs.target }} ${{ inputs.args }}
-      if: steps.determine-cargo-commands.outputs.test == 'true' && runner.os == 'Windows'
-    - name: Run benchmarks (*nix)
+        ${{ steps.set-build-command.outputs.build-command }} build --target ${{ inputs.target }} ${{ inputs.args }}
+      if: steps.determine-cargo-commands.outputs.build == 'true'
+
+    - name: Run cargo ${{ steps.determine-cargo-commands.outputs.command }}
      working-directory: ${{ inputs.working-directory }}
-      shell: bash
+      # We want to run in Powershell on Windows to make sure we compile in a native Windows
+      # environment. Some things won't compile properly under msys, notably OpenSSL, which is
+      # compiled locally when using the `openssl` crate with the `vendored` feature.
+      shell: ${{ runner.os == 'Windows' && 'powershell' || 'bash' }}
      run: |
-        ${{ steps.set-build-command.outputs.build-command }} +${{inputs.toolchain}} bench --target ${{ inputs.target }} ${{ inputs.args }}
-      if: steps.determine-cargo-commands.outputs.bench == 'true' && runner.os != 'Windows'
-    - name: Run benchmarks (Windows)
-      working-directory: ${{ inputs.working-directory }}
-      shell: powershell
-      run: |
-        & ${{ steps.set-build-command.outputs.build-command }} +${{inputs.toolchain}} bench --target ${{ inputs.target }} ${{ inputs.args }}
-      if: steps.determine-cargo-commands.outputs.bench == 'true' && runner.os == 'Windows'
-    - name: Build binary (*nix)
-      working-directory: ${{ inputs.working-directory }}
-      shell: bash
-      run: |
-        ${{ steps.set-build-command.outputs.build-command }} +${{inputs.toolchain}} build ${{ inputs.args }} --target ${{ inputs.target }}
-      if: steps.determine-cargo-commands.outputs.build == 'true' && runner.os != 'Windows'
-    - name: Build binary (Windows)
-      working-directory: ${{ inputs.working-directory }}
-      shell: powershell
-      run: |
-        & ${{ steps.set-build-command.outputs.build-command }} +${{inputs.toolchain}} build ${{ inputs.args }} --target ${{ inputs.target }}
-      if: steps.determine-cargo-commands.outputs.build == 'true' && runner.os == 'Windows'
+        ${{ steps.set-build-command.outputs.build-command }} ${{ steps.determine-cargo-commands.outputs.command }} --target ${{ inputs.target }} ${{ inputs.args }}
+      if: steps.determine-cargo-commands.outputs.command != ''
+
    - name: Strip binary
      working-directory: ${{ inputs.working-directory }}
      shell: bash
--- a/determine-cargo-commands.sh
+++ b/determine-cargo-commands.sh
@@ -9,5 +9,5 @@ if [ "$COMMAND" == 'both' ]; then
    echo "build=true" >>"$GITHUB_OUTPUT"
    echo "test=true" >>"$GITHUB_OUTPUT"
 else
-    echo "$COMMAND=true" >>"$GITHUB_OUTPUT"
+    echo "command=$COMMAND" >>"$GITHUB_OUTPUT"
 fi
--- a/mise.toml
+++ b/mise.toml
@@ -2,7 +2,7 @@
 node = "22.11.0"
 "npm:prettier" = "3.4.1"
 ruff = "0.8.3"
-shellcheck = "v0.10.0"
+shellcheck = "0.10.0"
 shfmt = "v3.10.0"
 taplo = "0.9.3"
 typos = "1.28.1"
--- a/parse-and-set-rust-cache-parameters.py
+++ b/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()
--- a/parse-rust-cache-parameters.py
+++ b/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}")
--- a/run-tests/src/main.rs
+++ b/run-tests/src/main.rs
@@ -24,6 +24,8 @@ struct Args {
    expect_cross_version: Option<String>,
    #[arg(long)]
    expect_stripped: bool,
+    #[arg(long)]
+    is_subcrate: bool,
 }

 fn main() {
@@ -39,24 +41,27 @@ fn main() {
    );

    let checkout_root_path = PathBuf::from(args.checkout_root);
-    let bin_paths = vec![
-        checkout_root_path
-            .join("target")
-            .join(&args.target)
-            .join("debug")
-            .join("bin1"),
-        checkout_root_path
-            .join("target")
-            .join(&args.target)
-            .join("debug")
-            .join("bin2"),
-        checkout_root_path
+    let bin_paths = if args.is_subcrate {
+        vec![checkout_root_path
            .join("subcrate")
            .join("target")
            .join(&args.target)
            .join("debug")
-            .join("subcrate"),
-    ];
+            .join("subcrate")]
+    } else {
+        vec![
+            checkout_root_path
+                .join("target")
+                .join(&args.target)
+                .join("debug")
+                .join("bin1"),
+            checkout_root_path
+                .join("target")
+                .join(&args.target)
+                .join("debug")
+                .join("bin2"),
+        ]
+    };

    for mut bin_path in bin_paths {
        if cfg!(windows) {
@@ -74,7 +79,11 @@ fn check_cross(bin_dir: &Path, expect_cross: bool, expect_cross_version: Option<
    let cross_path = bin_dir.join("cross");

    if expect_cross {
-        assert!(cross_path.is_file(), "`cross` exists");
+        assert!(
+            cross_path.is_file(),
+            "`cross` exists at {}",
+            cross_path.display()
+        );

        if let Some(expected_version) = expect_cross_version {
            let output = Command::new(&cross_path)
@@ -85,7 +94,7 @@ fn check_cross(bin_dir: &Path, expect_cross: bool, expect_cross_version: Option<
                .expect("`cross --version` stdout was not valid UTF-8");
            assert!(
                version.contains(expected_version),
-                "`cross` version matches expected version"
+                "`cross` version matches expected version: {expected_version}",
            );
        }
    } else {
@@ -113,12 +122,16 @@ fn check_binary(bin_path: &PathBuf, expect_file_re: Option<&str>, expect_strippe
        .output()
        .expect("Failed to execute `file` command");
    let file_output = String::from_utf8_lossy(&output.stdout);
+    println!(
+        "output from `file` for {}: {file_output}",
+        bin_path.display(),
+    );

    if let Some(file_re) = expect_file_re {
        let re = Regex::new(file_re).expect("Invalid regex");
        assert!(
            re.is_match(&file_output),
-            "`file` output for {} matches expected output",
+            "`file` output for {} matches `{file_re}`: `{file_output}`",
            bin_path.display(),
        );
    }
@@ -131,24 +144,24 @@ fn check_binary(bin_path: &PathBuf, expect_file_re: Option<&str>, expect_strippe
    if expect_stripped {
        assert!(
            !file_output.contains("not stripped"),
-            "`file` does not report {} as not stripped",
+            "`file` does not report {} as 'not stripped': `{file_output}`",
            bin_path.display(),
        );
        assert!(
            file_output.contains("stripped"),
-            "`file` reports {} as stripped",
+            "`file` reports {} as 'stripped': `{file_output}`",
            bin_path.display(),
        );
    } else if cfg!(windows) {
        assert!(
            !file_output.contains("stripped"),
-            "`file` does not report {} as stripped",
+            "`file` does not report {} as 'stripped': `{file_output}`",
            bin_path.display(),
        );
    } else {
        assert!(
            file_output.contains("not stripped"),
-            "`file` reports {} as not stripped",
+            "`file` reports {} as 'not stripped': `{file_output}`",
            bin_path.display(),
        );
    }
--- a/set-cross-compile.py
+++ b/set-cross-compile.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+
+# Written mostly by Claude.ai based on my original bash script.
+
+import sys
+import platform
+import re
+import os
+from subprocess import run, PIPE, CalledProcessError
+
+
+def main() -> int:
+    """
+    Main function to determine cross-compilation requirements.
+
+    Returns:
+        Exit code (0 for success)
+    """
+    if len(sys.argv) < 3:
+        print(
+            "Error: Target architecture and force cross arguments are required",
+            file=sys.stderr,
+        )
+        return 1
+
+    target = sys.argv[1]
+    force_use_cross = sys.argv[2]
+    if force_use_cross == "true":
+        needs_cross = True
+    else:
+        needs_cross = check_needs_cross(target)
+
+    write_github_output(needs_cross)
+
+    return 0
+
+
+def check_needs_cross(target: str) -> bool:
+    """
+    Determine if cross-compilation is needed based on system and target.
+
+    Args:
+        target: Target architecture string
+
+    Returns:
+        Boolean indicating if cross-compilation is needed
+    """
+    system_info = get_uname_info().lower()
+
+    # Check if we're on macOS or Windows
+    if any(os in system_info for os in ["darwin", "msys", "windows"]):
+        return False
+
+    target = target.lower()
+
+    # Check for x86_64 Linux targets on x86_64 Linux host
+    if (
+        re.search(r"x86_64.+linux-(?:gnu|musl)", target)
+        and "x86_64" in system_info
+        and "linux" in system_info
+    ):
+        return False
+
+    # It's tempting to not use cross when the host is Linux x86-64 and we're compiling for Linux
+    # i586 or i686. This sort of works, but if there's any C being compiled, things get weird,
+    # because then we need 32-bit C headers, 32-bit C libs to link to, etc.
+
+    # Check if both host and target are ARM Linux. I'm assuming here that for things like
+    # "arm-linux-androideabi" or "armv7-unknown-linux-ohos" we'd still need cross.
+    if (
+        re.search(r"(?:aarch64|arm).+linux-(?:gnu|musl)", target)
+        and ("arm" in system_info or "aarch64" in system_info)
+        and "linux" in system_info
+    ):
+        return False
+
+    return True
+
+
+def get_uname_info() -> str:
+    """
+    Get system information using uname command.
+
+    Returns:
+        String containing system information
+    """
+    try:
+        result = run(["uname", "-a"], check=True, text=True, stdout=PIPE)
+        return result.stdout
+    except (CalledProcessError, FileNotFoundError):
+        # Fallback to platform.platform() if uname is not available
+        return platform.platform()
+
+
+def write_github_output(needs_cross: bool) -> None:
+    """
+    Write the needs-cross output to GITHUB_OUTPUT environment variable file.
+
+    Args:
+        needs_cross: Boolean indicating if cross-compilation is needed
+    """
+    github_output = os.getenv("GITHUB_OUTPUT")
+    if github_output:
+        with open(github_output, "a") as f:
+            f.write(f"needs-cross={str(needs_cross).lower()}\n")
+
+
+if __name__ == "__main__":
+    sys.exit(main())
--- a/set-cross-compile.sh
+++ b/set-cross-compile.sh
@@ -1,25 +0,0 @@
-#!/bin/bash
-
-set -e
-set -x
-set -o pipefail
-
-TARGET="$1"
-
-# On macOS and Windows, we can cross-compile to all possible targets without
-# using cross.
-if uname -a | grep --quiet --extended-regexp -i "darwin|msys|windows"; then
-    echo "needs-cross=false" >>"$GITHUB_OUTPUT"
-    exit 0
-fi
-
-# On Linux, we should be able to cross-compile to i586 and i686, but in
-# practice this fails with some crates, notably openssl with the "vendored"
-# feature. This feature makes it compile openssl itself, which fails without
-# cross.
-if echo "$TARGET" | grep --quiet --extended-regexp -i 'x86_64.+linux-(gnu|musl)'; then
-    echo "needs-cross=false" >>"$GITHUB_OUTPUT"
-    exit 0
-fi
-
-echo "needs-cross=true" >>"$GITHUB_OUTPUT"
--- a/test-project/Cargo.toml
+++ b/test-project/Cargo.toml
@@ -19,7 +19,7 @@ path = "src/bin2.rs"
 [package.metadata.cross.target.x86_64-unknown-netbsd]
 pre-build = [
    "mkdir -p /tmp/netbsd",
-    "curl https://cdn.netbsd.org/pub/NetBSD/NetBSD-9.2/amd64/binary/sets/base.tar.xz -O",
+    "curl https://archive.netbsd.org/pub/NetBSD-archive/NetBSD-9.2/amd64/binary/sets/base.tar.xz -O",
    "tar -C /tmp/netbsd -xJf base.tar.xz",
    "cp /tmp/netbsd/usr/lib/libexecinfo.so /usr/local/x86_64-unknown-netbsd/lib",
    "rm base.tar.xz",
--- a/test-project/subcrate/Cargo.toml
+++ b/test-project/subcrate/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2021"
 [package.metadata.cross.target.x86_64-unknown-netbsd]
 pre-build = [
    "mkdir -p /tmp/netbsd",
-    "curl https://cdn.netbsd.org/pub/NetBSD/NetBSD-9.2/amd64/binary/sets/base.tar.xz -O",
+    "curl https://archive.netbsd.org/pub/NetBSD-archive/NetBSD-9.2/amd64/binary/sets/base.tar.xz -O",
    "tar -C /tmp/netbsd -xJf base.tar.xz",
    "cp /tmp/netbsd/usr/lib/libexecinfo.so /usr/local/x86_64-unknown-netbsd/lib",
    "rm base.tar.xz",
--- a/validate-inputs.py
+++ b/validate-inputs.py
@@ -9,6 +9,8 @@ from typing import Dict, List, Union
 import tempfile
 import unittest

+boolean_flags = {"cache_cross_binary", "force_use_cross", "strip", "use_rust_cache"}
+

 class InputValidator:
    """Validate inputs for a GitHub Action."""
@@ -40,22 +42,6 @@ class InputValidator:
        if "target" not in self.inputs:
            validation_errors.append("'target' is a required parameter")

-        # Validate command if present
-        if "command" in self.inputs:
-            valid_commands = {"build", "test", "both", "bench"}
-            if self.inputs["command"] not in valid_commands:
-                validation_errors.append(
-                    f"Invalid 'command'. Must be one of {sorted(valid_commands)}"
-                )
-
-        # Validate toolchain if present
-        if "toolchain" in self.inputs:
-            valid_toolchains = {"stable", "beta", "nightly"}
-            if self.inputs["toolchain"] not in valid_toolchains:
-                validation_errors.append(
-                    f"Invalid 'toolchain'. Must be one of {sorted(valid_toolchains)}"
-                )
-
        # Validate working directory if present
        if "working_directory" in self.inputs:
            path = Path(self.inputs["working_directory"])
@@ -72,10 +58,11 @@ class InputValidator:
                )

        # Validate boolean flags
-        boolean_flags = {"cache_cross_binary", "strip", "use_rust_cache"}
        for flag in boolean_flags:
            if flag in self.inputs and self.inputs[flag] not in {"true", "false"}:
-                validation_errors.append(f"'{flag}' must be either 'true' or 'false'")
+                # Turn the underscores into dashes
+                dashes = flag.replace("_", "-")
+                validation_errors.append(f"'{dashes}' must be either 'true' or 'false'")

        # Validate rust-cache-parameters JSON if present
        if "rust_cache_parameters" in self.inputs:
@@ -140,26 +127,15 @@ class TestInputValidator(unittest.TestCase):
        errors = validator.validate()
        self.assertTrue(errors)

-    def test_validate_valid_command(self) -> None:
-        """Test validation of valid commands."""
-        valid_commands = ["build", "test", "both", "bench"]
-
-        for command in valid_commands:
-            self.setup_env({"target": "x86_64-unknown-linux-gnu", "command": command})
-            validator = InputValidator("/root")
-            errors = validator.validate()
-            self.assertFalse(errors, f"Command '{command}' should be valid")
-
-    def test_validate_invalid_command(self) -> None:
-        """Test validation of invalid command."""
-        self.setup_env({"target": "x86_64-unknown-linux-gnu", "command": "invalid"})
-        validator = InputValidator("/root")
-        errors = validator.validate()
-        self.assertTrue(errors)
-
    def test_validate_valid_toolchain(self) -> None:
        """Test validation of valid toolchains."""
-        valid_toolchains = ["stable", "beta", "nightly"]
+        valid_toolchains = [
+            "stable",
+            "beta",
+            "nightly",
+            "nightly-2025-03-17",
+            "stable 8 weeks ago",
+        ]

        for toolchain in valid_toolchains:
            self.setup_env(
@@ -169,13 +145,6 @@ class TestInputValidator(unittest.TestCase):
            errors = validator.validate()
            self.assertFalse(errors, f"Toolchain '{toolchain}' should be valid")

-    def test_validate_invalid_toolchain(self) -> None:
-        """Test validation of invalid toolchain."""
-        self.setup_env({"target": "x86_64-unknown-linux-gnu", "toolchain": "unknown"})
-        validator = InputValidator("/root")
-        errors = validator.validate()
-        self.assertTrue(errors)
-
    def test_validate_working_directory(self) -> None:
        """Test validation of working directory."""
        with tempfile.TemporaryDirectory() as temp_dir:
@@ -212,7 +181,6 @@ class TestInputValidator(unittest.TestCase):

    def test_validate_boolean_flags(self) -> None:
        """Test validation of boolean flags."""
-        boolean_flags = ["cache-cross-binary", "strip", "use-rust-cache"]

        # Test valid boolean values
        for flag in boolean_flags: