kata-containers/.github/workflows/build-checks.yaml

on:
  workflow_call:
    inputs:
      instance:
        required: true
        type: string

# No workflow-level `concurrency` here: this file is only `workflow_call`'d. Each
# caller already uses `concurrency` + `cancel-in-progress` so a new push cancels the
# whole tree. A top-level group on the reusable workflow was too coarse—it matched
# every parallel `uses` with the same caller + PR + instance, so self-hosted matrix
# legs (arm, s390x, ppc64le) cancelled each other. Job-level `concurrency` below is
# enough to supersede in-flight matrix cells on a new run without blocking unrelated
# parallel callers that share `inputs.instance`.

permissions: {}
name: Build checks
jobs:
  check:
    name: check
    timeout-minutes: 60
    runs-on: >-
      ${{
        ( contains(inputs.instance, 's390x') && matrix.component.name == 'runtime' ) && 's390x' ||
        inputs.instance
      }}
    strategy:
      fail-fast: false
      matrix:
        command:
          - "make check"
          - "make test"
          - "sudo -E PATH=\"$PATH\" make test"
        component:
          - name: agent
            path: src/agent
            needs:
              - rust
              - libdevmapper
              - libseccomp
              - protobuf-compiler
              - clang
          - name: dragonball
            path: src/dragonball
            needs:
              - rust
          - name: runtime
            path: src/runtime
            needs:
              - golang
              - XDG_RUNTIME_DIR
          - name: runtime-rs
            path: src/runtime-rs
            needs:
              - rust
              - protobuf-compiler
          - name: libs
            path: src/libs
            needs:
              - rust
              - libdevmapper
              - protobuf-compiler
          - name: agent-ctl
            path: src/tools/agent-ctl
            needs:
              - rust
              - protobuf-compiler
              - clang
          - name: kata-ctl
            path: src/tools/kata-ctl
            needs:
              - rust
              - protobuf-compiler
          - name: trace-forwarder
            path: src/tools/trace-forwarder
            needs:
              - rust
          - name: genpolicy
            path: src/tools/genpolicy
            needs:
              - rust
              - protobuf-compiler
        instance:
          - ${{ inputs.instance }}
    concurrency:
      group: ${{ github.workflow }}-${{ github.job }}-${{ github.event.pull_request.number || github.ref }}-${{ inputs.instance }}-${{ toJSON(matrix) }}
      cancel-in-progress: true
    steps:
      - name: Adjust a permission for repo
        run: |
          sudo chown -R "$USER":"$USER" "$GITHUB_WORKSPACE" "$HOME"
          sudo rm -rf "$GITHUB_WORKSPACE"/* || { sleep 10 && sudo rm -rf "$GITHUB_WORKSPACE"/*; }
          sudo rm -f /tmp/kata_hybrid*  # Sometime we got leftover from test_setup_hvsock_failed()

      - name: Checkout the code
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          fetch-depth: 0
          persist-credentials: false

      - name: Install yq
        run: |
          ./ci/install_yq.sh
        env:
          INSTALL_IN_GOPATH: false
      - name: Read properties from versions.yaml
        if: contains(matrix.component.needs, 'golang')
        run: |
          go_version="$(yq '.languages.golang.version' versions.yaml)"
          [ -n "$go_version" ]
          echo "GO_VERSION=${go_version}" >> "$GITHUB_ENV"
      - name: Setup Golang version ${{ env.GO_VERSION }}
        if: contains(matrix.component.needs, 'golang')
        uses: actions/setup-go@7a3fe6cf4cb3a834922a1244abfce67bcef6a0c5 # v6.2.0
        with:
          go-version: ${{ env.GO_VERSION }}
          # Setup-go doesn't work properly with ppc64le: https://github.com/actions/setup-go/issues/648
          architecture: ${{ contains(inputs.instance, 'ppc64le') && 'ppc64le' || '' }}
      - name: Setup rust
        if: contains(matrix.component.needs, 'rust')
        run: |
          ./tests/install_rust.sh
          echo "${HOME}/.cargo/bin" >> "$GITHUB_PATH"
          if [ "$(uname -m)" == "x86_64" ] || [ "$(uname -m)" == "aarch64" ]; then
            sudo apt-get update && sudo apt-get -y install musl-tools
          fi
      - name: Install devicemapper
        if: contains(matrix.component.needs, 'libdevmapper') && matrix.command == 'make check'
        run: sudo apt-get update && sudo apt-get -y install libdevmapper-dev
      - name: Install libseccomp
        if: contains(matrix.component.needs, 'libseccomp') && matrix.command != 'make check'
        run: |
          libseccomp_install_dir=$(mktemp -d -t libseccomp.XXXXXXXXXX)
          gperf_install_dir=$(mktemp -d -t gperf.XXXXXXXXXX)
          ./ci/install_libseccomp.sh "${libseccomp_install_dir}" "${gperf_install_dir}"
          echo "Set environment variables for the libseccomp crate to link the libseccomp library statically"
          echo "LIBSECCOMP_LINK_TYPE=static" >> "$GITHUB_ENV"
          echo "LIBSECCOMP_LIB_PATH=${libseccomp_install_dir}/lib" >> "$GITHUB_ENV"
      - name: Install protobuf-compiler
        if: contains(matrix.component.needs, 'protobuf-compiler')
        run: sudo apt-get update && sudo apt-get -y install protobuf-compiler
      - name: Install clang
        if: contains(matrix.component.needs, 'clang') && matrix.command == 'make check'
        run: sudo apt-get update && sudo apt-get -y install clang
      - name: Setup XDG_RUNTIME_DIR
        if: contains(matrix.component.needs, 'XDG_RUNTIME_DIR') && matrix.command != 'make check'
        run: |
          XDG_RUNTIME_DIR=$(mktemp -d "/tmp/kata-tests-$USER.XXX" | tee >(xargs chmod 0700))
          echo "XDG_RUNTIME_DIR=${XDG_RUNTIME_DIR}" >> "$GITHUB_ENV"
      - name: Skip tests that depend on virtualization capable runners when needed
        if: ${{ endsWith(inputs.instance, '-arm') }}
        run: |
          echo "GITHUB_RUNNER_CI_NON_VIRT=true" >> "$GITHUB_ENV"
      - name: Running `${{ matrix.command }}` for ${{ matrix.component.name }}
        run: |
          cd "${COMPONENT_PATH}"
          eval "${COMMAND}"
        env:
          COMMAND: ${{ matrix.command }}
          COMPONENT_PATH: ${{ matrix.component.path }}
          RUST_BACKTRACE: "1"
          RUST_LIB_BACKTRACE: "0"
          SKIP_GO_VERSION_CHECK: "1"