setup-rust-toolchain/action.yml

name: Setup Rust Toolchain for GitHub CI
description: |
  Setup specific Rust versions with caching pre-configured.
  It provides problem matchers for cargo and rustfmt issues.

branding:
  icon: "play"
  color: "gray-dark"

# Add option to install directly from rust-toolchain file
# Blocked on rustup support: https://github.com/rust-lang/rustup/issues/2686
#
# The action is heavily inspired by https://github.com/dtolnay/rust-toolchain
inputs:
  toolchain:
    description: "Comma-separated list of Rust toolchain specifications. Last version becomes the default. -- see https://rust-lang.github.io/rustup/concepts/toolchains.html#toolchain-specification"
    required: false
  target:
    description: "Target triple to install for this toolchain"
    required: false
  components:
    description: "Comma-separated list of components to be additionally installed"
    required: false
  cache:
    description: "Automatically configure Rust cache"
    required: false
    default: "true"
  cache-workspaces:
    description: "Paths to multiple Cargo workspaces and their target directories, separated by newlines."
    required: false
  cache-directories:
    description: "Additional non workspace directories to be cached, separated by newlines."
    required: false
  cache-on-failure:
    description: "Also cache on workflow failures"
    default: "true"
    required: false
  cache-key:
    description: "An additional cache key that is added alongside the automatic `job`-based cache key and can be used to further differentiate jobs."
    required: false
  matcher:
    description: "Enable the Rust problem matcher"
    required: false
    default: "true"
  rustflags:
    description: "set RUSTFLAGS environment variable, set to empty string to avoid overwriting build.rustflags"
    required: false
    default: "-D warnings"
  override:
    description: "Setup the last installed toolchain as the default via `rustup override`"
    required: false
    default: "true"

outputs:
  rustc-version:
    description: "Version as reported by `rustc --version`"
    value: ${{steps.versions.outputs.rustc-version}}
  cargo-version:
    description: "Version as reported by `cargo --version`"
    value: ${{steps.versions.outputs.cargo-version}}
  rustup-version:
    description: "Version as reported by `rustup --version`"
    value: ${{steps.versions.outputs.rustup-version}}
  cachekey:
    description: A short hash of the rustc version, appropriate for use as a cache key. "20220627a831"
    value: ${{steps.versions.outputs.cachekey}}

runs:
  using: composite
  steps:
    # The later code uses "newer" bash features, which are not available in the ancient bash 3 (from 2014) of macOS
    - name: Unbork mac
      if: runner.os == 'macOS'
      run: |
        brew install bash
      shell: bash

    - id: flags
      env:
        targets: ${{inputs.target}}
        components: ${{inputs.components}}
      shell: bash
      run: |
        : construct rustup command line
        echo "targets=$(for t in ${targets//,/ }; do echo -n ' --target' $t; done)" >> $GITHUB_OUTPUT
        echo "components=$(for c in ${components//,/ }; do echo -n ' --component' $c; done)" >> $GITHUB_OUTPUT
        echo "downgrade=${{contains(inputs.toolchain, 'nightly') && inputs.components && ' --allow-downgrade' || ''}}" >> $GITHUB_OUTPUT

    # The environment variables always need to be set before the caching action
    - name: Setting Environment Variables
      env:
        NEW_RUSTFLAGS: ${{inputs.rustflags}}
      shell: bash
      run: |
        if [[ ! -v CARGO_INCREMENTAL ]]; then
          echo "CARGO_INCREMENTAL=0" >> $GITHUB_ENV
        fi
        if [[ ! -v CARGO_PROFILE_DEV_DEBUG ]]; then
          echo "CARGO_PROFILE_DEV_DEBUG=0" >> $GITHUB_ENV
        fi
        if [[ ! -v CARGO_TERM_COLOR ]]; then
          echo "CARGO_TERM_COLOR=always" >> $GITHUB_ENV
        fi
        if [[ ! -v RUST_BACKTRACE ]]; then
          echo "RUST_BACKTRACE=short" >> $GITHUB_ENV
        fi
        if [[ ( ! -v RUSTFLAGS ) && $NEW_RUSTFLAGS != "" ]]; then
          echo "RUSTFLAGS=$NEW_RUSTFLAGS" >> $GITHUB_ENV
        fi
        # Enable faster sparse index on nightly
        # The value is ignored on stable and causes no problems
        # https://internals.rust-lang.org/t/call-for-testing-cargo-sparse-registry/16862
        if [[ ! -v CARGO_UNSTABLE_SPARSE_REGISTRY ]]; then
          echo "CARGO_UNSTABLE_SPARSE_REGISTRY=true" >> $GITHUB_ENV
        fi
        if [[ ! -v CARGO_REGISTRIES_CRATES_IO_PROTOCOL ]]; then
          echo "CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse" >> $GITHUB_ENV
        fi

    - name: Install Rust Problem Matcher
      if: inputs.matcher == 'true'
      shell: bash
      run: echo "::add-matcher::${{ github.action_path }}/rust.json"

    - name: Install rustup, if needed
      if: runner.os != 'Windows'
      shell: bash
      run: |
        if ! command -v rustup &> /dev/null ; then
          curl --proto '=https' --tlsv1.2 --retry 10 --retry-connrefused -fsSL "https://sh.rustup.rs" | sh -s -- --default-toolchain none -y
          echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
        fi

    - name: rustup toolchain install ${{inputs.toolchain || 'stable'}}
      env:
        toolchain: ${{inputs.toolchain}}
        targets: ${{inputs.target}}
        components: ${{inputs.components}}
        override: ${{inputs.override}}
      shell: bash
      run: |
        if [[ -z "$toolchain" && ( -f "rust-toolchain" || -f "rust-toolchain.toml" ) ]]
        then
          # Install the toolchain as specified in the file
          # rustup show is the old way that implicitly installed a toolchain
          # rustup toolchain install is the new explicit way
          # https://github.com/rust-lang/rustup/issues/3635#issuecomment-2343511297
          rustup show active-toolchain || rustup toolchain install
          if [[ -n $components ]]; then
            rustup component add ${components//,/ }
          fi
          if [[ -n $targets ]]; then
            rustup target add ${targets//,/ }
          fi
        else
          if [[ -z "$toolchain" ]]
          then
            toolchain=stable
          fi
          rustup toolchain install ${toolchain//,/ } ${{steps.flags.outputs.targets}}${{steps.flags.outputs.components}} --profile minimal${{steps.flags.outputs.downgrade}} --no-self-update
          # Take the last element from the list
          if [[ "$override" == "true" ]]
          then
            rustup override set ${toolchain//*,/ }
          fi
        fi

    - id: versions
      name: Print installed versions
      shell: bash
      run: |
        echo "rustc-version=$(rustc --version)" >> $GITHUB_OUTPUT
        rustc --version --verbose
        echo "cargo-version=$(cargo --version)" >> $GITHUB_OUTPUT
        cargo --version --verbose
        echo "rustup-version=$(rustup --version)" >> $GITHUB_OUTPUT
        rustup --version

        DATE=$(rustc --version --verbose | sed -ne 's/^commit-date: \(20[0-9][0-9]\)-\([01][0-9]\)-\([0-3][0-9]\)$/\1\2\3/p')
        HASH=$(rustc --version --verbose | sed -ne 's/^commit-hash: //p')
        echo "cachekey=$(echo $DATE$HASH | head -c12)" >> $GITHUB_OUTPUT

    - name: Downgrade registry access protocol when needed
      shell: bash
      run: |
        # Not all versions support setting CARGO_REGISTRIES_CRATES_IO_PROTOCOL
        # On versions 1.66, 1.67, and 1.68.0-nightly the value "sparse" is still unstable.
        # https://github.com/dtolnay/rust-toolchain/pull/69#discussion_r1107268108
        # If we detect an incompatible value, set it to "git" which is always supported.
        if [[ "${{steps.versions.outputs.rustc-version}}" =~ ^rustc\ (1\.6[67]\.|1\.68\.0-nightly) && "${CARGO_REGISTRIES_CRATES_IO_PROTOCOL}" == "sparse" ]]; then
          echo "Downgrade cargo registry protocol to git"
          echo "CARGO_REGISTRIES_CRATES_IO_PROTOCOL=git" >> $GITHUB_ENV
        fi

    - name: Setup Rust Caching
      if: inputs.cache == 'true'
      uses: Swatinem/rust-cache@v2
      with:
        workspaces: ${{inputs.cache-workspaces}}
        cache-directories: ${{inputs.cache-directories}}
        cache-on-failure: ${{inputs.cache-on-failure}}
        key: ${{inputs.cache-key}}