ci.yml

---
name: CI

'on':
  push:
    branches:
      - "ci-*"
  workflow_dispatch:
  pull_request:
    types:
      - opened
      - reopened
      - synchronize
  merge_group:

env:
  toolchain: nightly-2024-09-19
  CARGO_HTTP_MULTIPLEXING: false
  CARGO_TERM_COLOR: always
  CARGO_UNSTABLE_SPARSE_REGISTRY: true
  CARGO_INCREMENTAL: 0
  PROTOC: protoc
  TERM: unknown

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  clippy:
    name: clippy
    runs-on: [ ubuntu-latest ]
    steps:
      - name: checkout
        uses: actions/checkout@v4
      - name: toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.toolchain }}
          components: clippy, rustfmt
      - name: ubuntu dependencies
        run: |
          sudo apt-get update
          sudo bash scripts/install_ubuntu_dependencies.sh
      - name: Cache cargo files and outputs
        if: startsWith(runner.environment,'github-hosted')
        uses: Swatinem/rust-cache@v2
      - name: caching (nightly)
        if: startsWith(runner.environment,'self-hosted')
        # Don't use rust-cache.
        # Rust-cache disables a key feature of actions/cache: restoreKeys.
        # Without restore keys, we lose the ability to get partial matches on caches, and end
        # up with too many cache misses.
        # Use a "small" suffix to use the build caches where possible, but build caches won't use this
        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry/index
            ~/.cargo/registry/cache
            ~/.cargo/registry/CACHEDIR.TAG
            ~/.cargo/git
            target
          key: tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly-${{ hashFiles('**/Cargo.lock') }}-small
          restore-keys: |
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly-${{ hashFiles('**/Cargo.lock') }}-small
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly-${{ hashFiles('**/Cargo.lock') }}
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly
      - name: cargo format
        run: cargo +${{ env.toolchain }} fmt --all -- --check
      - name: Install cargo-lints
        run: cargo install cargo-lints
      - name: Clippy check (with lints)
        run: cargo +${{ env.toolchain }} lints clippy --all-targets --all-features

  machete:
    # Checks for unused dependencies.
    name: machete
    runs-on: [ ubuntu-20.04 ]
    steps:
      - name: checkout
        uses: actions/checkout@v4
      - name: toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.toolchain }}
          components: clippy, rustfmt
      - name: ubuntu dependencies
        run: |
          sudo apt-get update
          sudo bash scripts/install_ubuntu_dependencies.sh
      - name: caching (machete)
        # Don't use rust-cache.
        # Rust-cache disables a key feature of actions/cache: restoreKeys.
        # Without restore keys, we lose the ability to get partial matches on caches, and end
        # up with too many cache misses.
        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry/index
            ~/.cargo/registry/cache
            ~/.cargo/registry/CACHEDIR.TAG
            ~/.cargo/git
            target
          key: tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly-${{ hashFiles('**/Cargo.lock') }}-small
          restore-keys: |
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly-${{ hashFiles('**/Cargo.lock') }}-small
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly-${{ hashFiles('**/Cargo.lock') }}
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly
      - name: cargo machete
        run: |
          cargo install cargo-machete
          cargo machete
  build-stable:
    # Runs cargo check with stable toolchain to determine whether the codebase is likely to build
    #  on stable Rust.
    name: cargo check with stable
    runs-on: [ self-hosted, ubuntu-high-cpu ]
    env:
      RUSTUP_PERMIT_COPY_RENAME: true
    steps:
      - name: checkout
        uses: actions/checkout@v4
      - name: caching (stable)
        # Don't use rust-cache.
        # Rust-cache disables a key feature of actions/cache: restoreKeys.
        # Without restore keys, we lose the ability to get partial matches on caches, and end
        # up with too many cache misses.
        # This job runs on self-hosted, so use local-cache instead.
        uses: maxnowack/local-cache@v2
        with:
          path: |
            ~/.cargo/registry/index
            ~/.cargo/registry/cache
            ~/.cargo/registry/CACHEDIR.TAG
            ~/.cargo/git
            target
          key: tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-stable-${{ hashFiles('**/Cargo.lock') }}-small
          restore-keys: |
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-stable-${{ hashFiles('**/Cargo.lock') }}-small
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-stable-${{ hashFiles('**/Cargo.lock') }}
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-stable
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}
      - name: rust-toolchain.toml override by removing
        run: rm -f rust-toolchain.toml
      - name: toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: stable
      - name: ubuntu dependencies
        run: |
          sudo apt-get update
          sudo bash scripts/install_ubuntu_dependencies.sh
      - name: rustup show
        run: rustup show
      - name: cargo check
        run: cargo check --release --all-targets --workspace --exclude tari_integration_tests --locked

  licenses:
    name: file licenses
    runs-on: [ ubuntu-22.04 ]
    steps:
      - name: checkout
        uses: actions/checkout@v4
      - name: install ripgrep
        run: |
          #wget https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep_14.1.1-1_amd64.deb.sha256
          wget https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep_14.1.1-1_amd64.deb
          sudo dpkg -i ripgrep_14.1.1-1_amd64.deb
          rg --version || exit 1
      - name: run the license check
        run: ./scripts/file_license_check.sh

  test:
    name: test
    runs-on: [ self-hosted, ubuntu-high-cpu ]
    permissions:
      checks: write
      pull-requests: write
    strategy:
      matrix:
        tari_target_network: [
          { network: "esmeralda" },
        ]
    env:
      TARI_TARGET_NETWORK: ${{ matrix.tari_target_network.target }}
      TARI_NETWORK: ${{ matrix.tari_target_network.network }}
      RUST_LOG: debug
    steps:
      - name: checkout
        uses: actions/checkout@v4
      - name: toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.toolchain }}
      - name: ubuntu dependencies
        run: |
          sudo apt-get update
          sudo bash scripts/install_ubuntu_dependencies.sh
      - name: caching (nightly)
        # Don't use rust-cache.
        # Rust-cache disables a key feature of actions/cache: restoreKeys.
        # Without restore keys, we lose the ability to get partial matches on caches, and end
        # up with too many cache misses.
        # This job runs on self-hosted, so use local-cache instead.
        uses: maxnowack/local-cache@v2
        with:
          path: |
            ~/.cargo/registry/index
            ~/.cargo/registry/cache
            ~/.cargo/registry/CACHEDIR.TAG
            ~/.cargo/git
            target
          key: tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly-${{ hashFiles('**/Cargo.lock') }}-${{ matrix.tari_target_network.target }}
          restore-keys: |
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly-${{ hashFiles('**/Cargo.lock') }}-${{ matrix.tari_target_network.network }}
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly-${{ hashFiles('**/Cargo.lock') }}
            tari-${{ runner.os }}-${{ runner.cpu-model }}-${{ env.toolchain }}-nightly
      - name: Install cargo-nextest
        run: cargo install cargo-nextest --locked --force
      - name: cargo test compile
        run: cargo test -vv --no-run --locked --all-features --release
      - name: cargo test
        run: cargo nextest run --all-features --release
      - name: upload artifact
        uses: actions/upload-artifact@v4  # upload test results as artifact
        if: always()
        with:
          name: test-results-${{ matrix.tari_target_network.target }}.${{ matrix.tari_target_network.network }}
          path: ${{ github.workspace }}/target/nextest/ci/junit.xml

  # Allows other workflows to know the PR number
  artifacts:
    name: pr_2_artifact
    runs-on: [ ubuntu-20.04 ]
    steps:
      - name: Save the PR number in an artifact
        shell: bash
        env:
          PR_NUM: ${{ github.event.number }}
        run: echo $PR_NUM > pr_num.txt

      - name: Upload the PR number
        uses: actions/upload-artifact@v4
        with:
          name: pr_num
          path: ./pr_num.txt

  # needed for test results
  event_file:
    name: "Upload Event File for Test Results"
    runs-on: ubuntu-latest
    steps:
      - name: Upload
        uses: actions/upload-artifact@v4
        with:
          name: Event File
          path: ${{ github.event_path }}