ci.yml

name: CI
on:
  pull_request:
  push:

jobs:
  test-gnu:
    # dynamically linked glibc
    name: Test on Ubuntu ${{ matrix.os-arch }} (${{ matrix.args }})
    strategy:
      matrix:
        include:
          - rust-target: x86_64-unknown-linux-gnu
            os-target: x86_64-linux-gnu
            os-arch: amd64
            args: ''

          - rust-target: x86_64-unknown-linux-gnu
            os-target: x86_64-linux-gnu
            os-arch: amd64
            args: --no-default-features
            install-sys-libbpf: y

          - rust-target: aarch64-unknown-linux-gnu
            os-target: aarch64-linux-gnu
            os-arch: arm64
            args: ''

          - rust-target: powerpc64le-unknown-linux-gnu
            os-target: powerpc64le-linux-gnu
            os-arch: ppc64el
            args: ''
    runs-on: ubuntu-latest
    env:
      CARGO_BUILD_TARGET: ${{ matrix.rust-target }}
      CARGO_TERM_VERBOSE: 'true'
      RUSTFLAGS: -C linker=/usr/bin/${{ matrix.os-target }}-gcc
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
        with:
          submodules: recursive

      - name: Add apt sources for ${{ matrix.os-arch }}
        if: matrix.os-arch != 'amd64'
        run: |
          dpkg --add-architecture ${{ matrix.os-arch }}

          release=$(. /etc/os-release && echo "$UBUNTU_CODENAME")
          sed -i 's/^deb /deb [arch=amd64] /' /etc/apt/sources.list
          printf 'deb [arch=${{ matrix.os-arch }}] http://ports.ubuntu.com/ %s main restricted\n' \
              $release $release-updates $release-security \
              >> /etc/apt/sources.list
        shell: sudo sh -e {0}

      - name: Install system dependencies
        run: |
          sudo apt-get update
          sudo apt-get install \
              build-essential \
              libelf-dev:${{ matrix.os-arch }} \
              zlib1g-dev:${{ matrix.os-arch }}

      - name: Install libbpf-dev
        if: matrix.install-sys-libbpf == 'y'
        run: sudo apt-get install libbpf-dev:${{ matrix.os-arch }}

      - name: Install linker for ${{ matrix.os-target }}
        if: matrix.os-arch != 'amd64'
        run: sudo apt-get install gcc-${{ matrix.os-target }}

      - name: Install Rust stable for ${{ matrix.rust-target }}
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.rust-target }}

      - run: cargo build ${{ matrix.args }}

      - run: cargo test ${{ matrix.args }}
        if: matrix.os-arch == 'amd64'

  test-musl:
    # dynamically linked musl libc
    name: Test on Alpine Linux x86_64 (${{ matrix.args }})
    runs-on: ubuntu-latest
    strategy:
      matrix:
        include:
          - args: ''
          - args: --no-default-features
            install-sys-libbpf: y
    env:
      CARGO_TERM_VERBOSE: 'true'
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
        with:
          submodules: recursive

      - name: Install Alpine Linux with dependencies
        uses: jirutka/setup-alpine@v1
        with:
          branch: latest-stable
          packages: >
            build-base
            cargo
            elfutils-dev
            linux-headers
            zlib-dev

      - name: Install libbpf-dev
        if: matrix.install-sys-libbpf == 'y'
        run: apk add libbpf-dev
        shell: alpine.sh --root {0}

      - run: cargo build ${{ matrix.args }}
        shell: alpine.sh {0}

      - run: cargo test ${{ matrix.args }}
        shell: alpine.sh {0}

  test-libbpf-rs:
    # check that libbpf-rs, one of the main consumers of the library, works with
    # this version of libbpf-sys
    name: Test libbpf-rs integration
    runs-on: ubuntu-latest
    env:
      CARGO_TERM_VERBOSE: 'true'
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
        with:
          submodules: recursive

      - name: Install system dependencies
        run: |
          sudo apt-get update
          sudo apt-get install \
              build-essential \
              libelf-dev \
              zlib1g-dev

      - name: Build libbpf-rs with libbpf-sys
        run: |
          cargo init --bin libbpf-rs-test-project
          cd libbpf-rs-test-project
          # Add the most recent *published* version of libbpf-rs (as opposed to,
          # say, cloning a development snapshot, which would just introduce
          # additional uncertainty into the process).
          cargo add libbpf-rs
          # Override libbpf-sys in use with our current one.
          cat >> Cargo.toml <<EOF
          [patch.crates-io]
          libbpf-sys = { path = '..' }
          EOF
          cargo build

  publish:
    name: Publish to crates.io
    if: github.ref == 'refs/heads/master' && github.ref_type == 'tag'
    needs:
      - test-gnu
      - test-musl
      - test-libbpf-rs
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
        with:
          submodules: recursive

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.rust-target }}

      # This is needed for cargo-pkgid.
      - name: Fetch dependencies and generate Cargo.lock
        run: cargo fetch

      - name: Resolve crate version and check git tag name
        run: |
          crate_version="$(cargo pkgid | cut -d '#' -f2 | grep -o '[^:]*$')"
          git_tag=${GITHUB_REF#refs/tags/}

          if [ "$git_tag" != "$crate_version" ]; then
              printf '::error::%s\n' "Crate version ($crate_version) does not match git tag ($git_tag)"
              exit 1
          fi

      - name: Publish to crates.io
        # no-verify is to skip building; it has been already verified in the test-* jobs.
        run: cargo publish --no-verify --verbose
        env:
          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}