ci.yml

name: CI
on:
  push:
    branches:
      - master
  pull_request: null
  release:
    types:
      - published
env:
  DATABASE_URL: postgres://postgres:my-secret@localhost:5432
  DASEL_VERSION: https://github.com/TomWright/dasel/releases/download/v1.24.3/dasel_linux_amd64
  CARGO_TERM_COLOR: always
  RUSTFLAGS: -D warnings
  REGISTRY: ghcr.io
  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 2
  SQLX_OFFLINE: true
  RUSTC_VERSION: 1.72.0
  BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
  IS_MASTER: ${{ github.head_ref == 'master' || github.ref_name == 'master' }}
  IS_DEVELOP: ${{ github.head_ref == 'develop' || github.ref_name == 'develop' }}
  IS_RELEASE: ${{ github.event_name == 'release' && github.event.action == 'published' }}
jobs:
  cancel-previous-runs:
    runs-on: buildjet-4vcpu-ubuntu-2204
    steps:
      - name: Cancel Previous Runs
        uses: styfle/cancel-workflow-action@0.9.1
        with:
          access_token: ${{ github.token }}
  set-env-vars:
    runs-on: buildjet-4vcpu-ubuntu-2204
    outputs:
      IS_MASTER: ${{ steps.set-env.outputs.IS_MASTER }}
      IS_DEVELOP: ${{ steps.set-env.outputs.IS_DEVELOP }}
      IS_RELEASE: ${{ steps.set-env.outputs.IS_RELEASE }}
      IS_RELEASE_OR_MASTER_OR_DEVELOP_OR_SEMVER: ${{ steps.set-env.outputs.IS_RELEASE_OR_MASTER_OR_DEVELOP_OR_SEMVER }}
    steps:
      - name: Set env vars
        id: set-env
        run: >
          echo "IS_MASTER=${{ env.IS_MASTER }}" >> $GITHUB_OUTPUT

          echo "IS_DEVELOP=${{ env.IS_DEVELOP }}" >> $GITHUB_OUTPUT

          echo "IS_RELEASE=${{ env.IS_RELEASE }}" >> $GITHUB_OUTPUT

          if [[ ${{ env.IS_MASTER }} == 'true' || ${{ env.IS_DEVELOP }} == 'true' || ${{ env.IS_RELEASE }} == 'true' || ${{ env.BRANCH_NAME }} =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
            echo "IS_RELEASE_OR_MASTER_OR_DEVELOP_OR_SEMVER=true" >> $GITHUB_OUTPUT
          else
            echo "IS_RELEASE_OR_MASTER_OR_DEVELOP_OR_SEMVER=false" >> $GITHUB_OUTPUT
          fi
  cargo-toml-fmt-check:
    runs-on: buildjet-4vcpu-ubuntu-2204
    needs:
      - set-env-vars
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.RUSTC_VERSION }}
      - name: setup binstall
        uses: taiki-e/install-action@cargo-binstall
      - name: Install Cargo.toml linter
        run: cargo binstall --no-confirm cargo-sort
      - name: Run Cargo.toml sort check
        run: cargo sort -w --check packages/**/Cargo.toml
  docs-test:
    uses: FuelLabs/github-actions/.github/workflows/mdbook-docs.yml@master
    with:
      docs-src-path: docs/src
  mdbook-build:
    needs:
      - docs-test
    runs-on: buildjet-4vcpu-ubuntu-2204
    steps:
      - name: Install toolchain
        uses: dtolnay/rust-toolchain@stable
      - uses: buildjet/cache@v3
        with:
          path: |
            ~/.cargo/bin/
            ~/.cargo/registry/index/
            ~/.cargo/registry/cache/
            ~/.cargo/git/db/
            target/
          key: ${{ matrix.command }}-${{ matrix.args }}-${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
      - name: mdbook build
        uses: peaceiris/actions-mdbook@v1
        with:
          mdbook-version: latest
  cargo-fmt-check:
    if: needs.set-env-vars.outputs.IS_RELEASE != 'true'
    needs:
      - set-env-vars
    runs-on: buildjet-4vcpu-ubuntu-2204
    steps:
      - uses: actions/checkout@v3
      - name: Install toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt
      - name: cargo fmt --all --verbose -- --check
        run: cargo fmt --all --verbose -- --check
  cargo-clippy-no-default-features:
    runs-on: buildjet-4vcpu-ubuntu-2204
    needs:
     - set-env-vars
     - cargo-toml-fmt-check
     - cargo-fmt-check
    if: needs.set-env-vars.outputs.IS_RELEASE_OR_MASTER_OR_DEVELOP_OR_SEMVER !=
      'true'
    steps:
      - uses: actions/checkout@v3
      - name: Install toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy, rustfmt
      - name: cargo clippy --locked --no-default-features
        run: cargo clippy --locked --no-default-features
  cargo-clippy-all-features-all-targets:
    runs-on: buildjet-4vcpu-ubuntu-2204
    needs:
     - set-env-vars
     - cargo-toml-fmt-check
     - cargo-fmt-check
    if: needs.set-env-vars.outputs.IS_RELEASE_OR_MASTER_OR_DEVELOP_OR_SEMVER !=
      'true'
    steps:
      - uses: actions/checkout@v3
      - name: Install toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy, rustfmt
      - name: cargo clippy --locked --all-targets --all-features
        run: cargo clippy --locked --all-targets --all-features
  unit-tests:
    if: needs.set-env-vars.outputs.IS_RELEASE_OR_MASTER_OR_DEVELOP_OR_SEMVER !=
      'true'
    needs:
      - set-env-vars
      - cargo-toml-fmt-check
      - cargo-fmt-check
    runs-on: buildjet-4vcpu-ubuntu-2204
    services:
      postgres:
        image: postgres:latest
        env:
          POSTGRES_PASSWORD: my-secret
          POSTGRES_DB: postgres
          POSTGRES_USER: postgres
        ports:
          - 5432:5432
        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s
          --health-retries 5
        credentials:
          username: fuellabs
          password: ${{ secrets.DOCKER_IO_READ_ONLY_TOKEN }}
    steps:
      - uses: actions/checkout@v3
      - name: Install toolchain
        uses: dtolnay/rust-toolchain@stable
      - name: cargo test --locked --all-targets --workspace --exclude fuel-indexer-tests
          --exclude plugin-tests --exclude fuel-indexer-benchmarks
        run: cargo test --locked --all-targets --workspace --exclude fuel-indexer-tests
          --exclude plugin-tests --exclude fuel-indexer-benchmarks
  integration-tests:
    if: needs.set-env-vars.outputs.IS_RELEASE_OR_MASTER_OR_DEVELOP_OR_SEMVER != 'true'
    needs:
      - set-env-vars
      - cargo-toml-fmt-check
      - cargo-fmt-check
    runs-on: buildjet-4vcpu-ubuntu-2204
    services:
      postgres:
        image: postgres:latest
        env:
          POSTGRES_PASSWORD: my-secret
          POSTGRES_DB: postgres
          POSTGRES_USER: postgres
        ports:
          - 5432:5432
        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s
          --health-retries 5
        credentials:
          username: fuellabs
          password: ${{ secrets.DOCKER_IO_READ_ONLY_TOKEN }}
    steps:
      - uses: actions/checkout@v3
      - name: Install toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: wasm32-unknown-unknown
      - uses: buildjet/cache@v3
        with:
          path: |
            ~/.cargo/bin/
            ~/.cargo/registry/index/
            ~/.cargo/registry/cache/
            ~/.cargo/git/db/
            target/
          key: ${{ matrix.command }}-${{ matrix.args }}-${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
      - name: Install SQLx CLI
        run: |
          if ! which sqlx; then cargo install sqlx-cli; fi
      - name: Install wasm-snip
        run: |
          if ! which wasm-snip; then cargo install wasm-snip; fi
      - name: Build fuel-indexer* and forc-index binaries
        run: cargo build -p forc-index -p fuel-indexer -p fuel-indexer-api-server --locked --release
      - name: Build and test examples
        run: |
          export PATH=$PATH:$PWD/target/release
          bash ./packages/fuel-indexer-tests/scripts/test-examples.bash
      - name: Build fuel-indexer-test WASM
        run: |
          cargo build -p fuel-indexer-test --release --target wasm32-unknown-unknown
          bash scripts/stripper.bash fuel_indexer_test.wasm
          cp fuel_indexer_test.wasm target/wasm32-unknown-unknown/release/
      - name: Build simple-wasm WASM
        run: |
          cargo build -p simple-wasm --release --target wasm32-unknown-unknown
          bash scripts/stripper.bash simple_wasm.wasm
          cp simple_wasm.wasm target/wasm32-unknown-unknown/release/
      - name: Integration tests
        run: |
          export PATH=$PATH:$PWD/target/release
          cargo test --locked --all-targets --features postgres -p fuel-indexer-tests -- --test-threads=1
      - name: trybuild tests
        run: |
          export PATH=$PATH:$PWD/target/release
          cargo test --locked --all-targets --features trybuild -p fuel-indexer-tests
  publish-docker-image:
    needs:
      - set-env-vars
    if: needs.set-env-vars.outputs.IS_RELEASE == 'true' || needs.set-env-vars.outputs.IS_MASTER == 'true'
    runs-on: buildjet-4vcpu-ubuntu-2204
    permissions:
      contents: read
      packages: write
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
      - name: Docker meta
        id: meta
        uses: docker/metadata-action@v3
        with:
          images: |
            ghcr.io/fuellabs/fuel-indexer
          tags: |
            type=sha
            type=ref,event=branch
            type=ref,event=tag
            type=semver,pattern={{raw}}
          flavor: |
            latest=${{ env.IS_MASTER || env.IS_RELEASE }}
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1
      - name: Log in to the ghcr.io registry
        uses: docker/login-action@v1
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.repository_owner }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Log in to the docker.io registry
        uses: docker/login-action@v2
        with:
          username: fuellabs
          password: ${{ secrets.DOCKER_IO_READ_ONLY_TOKEN }}
      - name: Build and push the image to ghcr.io
        uses: docker/build-push-action@v4
        with:
          context: .
          file: deployment/Dockerfile
          platforms: linux/amd64,linux/arm64
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=registry,ref=ghcr.io/fuellabs/fuel-indexer-build-cache:latest
          cache-to: type=registry,ref=ghcr.io/fuellabs/fuel-indexer-build-cache:latest,mode=max
      - name: Notify if Job Fails
        uses: ravsamhq/notify-slack-action@v2
        if: always() && (github.ref == 'refs/heads/master' || github.ref_type == 'tag')
        with:
          status: ${{ job.status }}
          token: ${{ secrets.GITHUB_TOKEN }}
          notification_title: "{workflow} has {status_message}"
          message_format: "{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> :
            <{run_url}|View Run Results>"
          footer: ""
          notify_when: failure
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_NOTIFY_BUILD }}
  publish-fuel-indexer-binaries:
    runs-on: ${{ matrix.job.os }}
    needs:
      - set-env-vars
    if: needs.set-env-vars.outputs.IS_RELEASE == 'true'
    strategy:
      matrix:
        job:
          - os: buildjet-4vcpu-ubuntu-2204
            platform: linux
            target: x86_64-unknown-linux-gnu
            cross_image: x86_64-linux-gnu
          - os: buildjet-4vcpu-ubuntu-2204
            platform: linux-arm
            target: aarch64-unknown-linux-gnu
            cross_image: aarch64-linux-gnu
          - os: macos-latest
            platform: darwin
            target: x86_64-apple-darwin
          - os: macos-latest
            platform: darwin-arm
            target: aarch64-apple-darwin
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
      - name: Set up Docker Buildx
        if: matrix.job.cross_image
        uses: docker/setup-buildx-action@v1
      - name: Setup custom cross env ${{ matrix.job.cross_image }}
        if: matrix.job.cross_image
        uses: docker/build-push-action@v2
        with:
          context: ci
          file: ci/Dockerfile.${{ matrix.job.target }}-clang
          tags: ${{ matrix.job.cross_image }}:latest
          load: true
          cache-from: type=gha
          cache-to: type=gha,mode=max
      - name: Install packages (macOS)
        if: matrix.job.os == 'macos-latest'
        run: |
          ci/macos-install-packages.sh
      - uses: actions/checkout@v3
      - name: Install toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.job.target }}
      - name: Install cross
        uses: baptiste0928/cargo-install@v1
        with:
          crate: cross
          cache-key: ${{ matrix.job.target }}
      - name: Build fuel-indexer
        run: |
          cross \
            build \
            --profile=release \
            --target ${{ matrix.job.target }} \
            -p fuel-indexer \
            --features fuel-core-lib \
            -p fuel-indexer-api-server \
            -p forc-index
      - name: Strip release binary linux x86_64
        if: matrix.job.platform == 'linux'
        run: >
          strip "target/${{ matrix.job.target }}/release/fuel-indexer"

          strip "target/${{ matrix.job.target }}/release/fuel-indexer-api-server"

          strip "target/${{ matrix.job.target }}/release/forc-index"
      - name: Strip release binary aarch64-linux-gnu
        if: matrix.job.target == 'aarch64-unknown-linux-gnu'
        run: |
          docker run --rm -v \
          "$PWD/target:/target:Z" \
          aarch64-linux-gnu:latest \
          aarch64-linux-gnu-strip \
          /target/aarch64-unknown-linux-gnu/release/fuel-indexer

          docker run --rm -v \
          "$PWD/target:/target:Z" \
          aarch64-linux-gnu:latest \
          aarch64-linux-gnu-strip \
          /target/aarch64-unknown-linux-gnu/release/fuel-indexer-api-server

          docker run --rm -v \
          "$PWD/target:/target:Z" \
          aarch64-linux-gnu:latest \
          aarch64-linux-gnu-strip \
          /target/aarch64-unknown-linux-gnu/release/forc-index
      - name: Strip release binary mac
        if: matrix.job.os == 'macos-latest'
        run: >
          strip -x "target/${{ matrix.job.target }}/release/fuel-indexer"

          strip -x "target/${{ matrix.job.target }}/release/fuel-indexer-api-server"

          strip -x "target/${{ matrix.job.target }}/release/forc-index"
      - name: Prepare Binary Artifact
        env:
          PLATFORM_NAME: ${{ matrix.job.platform }}
          TARGET: ${{ matrix.job.target }}
        run: >
          # trim refs/tags/ prefix

          FUEL_INDEXER_VERSION="${GITHUB_REF#refs/tags/}"


          # optionally trim v from tag prefix

          FUEL_INDEXER_VERSION="${FUEL_INDEXER_VERSION#v}"

          echo "version is: $FUEL_INDEXER_VERSION"


          # setup artifact filename

          INDEXER_ARTIFACT="fuel-indexer-$FUEL_INDEXER_VERSION-${{ env.TARGET }}"

          API_SERVER_ARTIFACT="fuel-indexer-api-server-$FUEL_INDEXER_VERSION-${{ env.TARGET }}"

          FORC_INDEX_ARTIFACT="forc-index-$FUEL_INDEXER_VERSION-${{ env.TARGET }}"

          INDEXER_ZIP_FILE_NAME="$INDEXER_ARTIFACT.tar.gz"

          API_SERVER_ZIP_FILE_NAME="$API_SERVER_ARTIFACT.tar.gz"

          FORC_INDEX_ZIP_FILE_NAME="$FORC_INDEX_ARTIFACT.tar.gz"

          echo "INDEXER_ZIP_FILE_NAME=$INDEXER_ZIP_FILE_NAME" >> $GITHUB_ENV

          echo "API_SERVER_ZIP_FILE_NAME=$API_SERVER_ZIP_FILE_NAME" >> $GITHUB_ENV

          echo "FORC_INDEX_ZIP_FILE_NAME=$FORC_INDEX_ZIP_FILE_NAME" >> $GITHUB_ENV


          # create zip file

          mkdir -pv "$INDEXER_ARTIFACT"

          mkdir -pv "$API_SERVER_ARTIFACT"

          mkdir -pv "$FORC_INDEX_ARTIFACT"

          cp "target/${{ matrix.job.target }}/release/fuel-indexer" "$INDEXER_ARTIFACT"

          cp "target/${{ matrix.job.target }}/release/fuel-indexer-api-server" "$API_SERVER_ARTIFACT"

          cp "target/${{ matrix.job.target }}/release/forc-index" "$FORC_INDEX_ARTIFACT"

          tar -czvf "$INDEXER_ZIP_FILE_NAME" "$INDEXER_ARTIFACT"

          tar -czvf "$API_SERVER_ZIP_FILE_NAME" "$API_SERVER_ARTIFACT"

          tar -czvf "$FORC_INDEX_ZIP_FILE_NAME" "$FORC_INDEX_ARTIFACT"
      - name: Upload Indexer Binary Artifact
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ github.token }}
        with:
          upload_url: ${{ github.event.release.upload_url }}
          asset_path: ./${{ env.INDEXER_ZIP_FILE_NAME }}
          asset_name: ${{ env.INDEXER_ZIP_FILE_NAME }}
          asset_content_type: application/gzip
      - name: Upload Api Server Binary Artifact
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ github.token }}
        with:
          upload_url: ${{ github.event.release.upload_url }}
          asset_path: ./${{ env.API_SERVER_ZIP_FILE_NAME }}
          asset_name: ${{ env.API_SERVER_ZIP_FILE_NAME }}
          asset_content_type: application/gzip
      - name: Upload Forc Index Binary Artifact
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ github.token }}
        with:
          upload_url: ${{ github.event.release.upload_url }}
          asset_path: ./${{ env.FORC_INDEX_ZIP_FILE_NAME }}
          asset_name: ${{ env.FORC_INDEX_ZIP_FILE_NAME }}
          asset_content_type: application/gzip
      - name: Notify if Job Fails
        uses: ravsamhq/notify-slack-action@v2
        if: always() && (github.ref == 'refs/heads/master' || github.ref_type == 'tag')
          && matrix.job.os != 'macos-latest'
        with:
          status: ${{ job.status }}
          token: ${{ secrets.GITHUB_TOKEN }}
          notification_title: "{workflow} has {status_message}"
          message_format: "{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> :
            <{run_url}|View Run Results>"
          footer: ""
          notify_when: failure
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_NOTIFY_BUILD }}
  deploy:
    if: needs.set-env-vars.outputs.IS_MASTER == 'true'
    needs:
      - publish-docker-image
      - set-env-vars
    runs-on: buildjet-4vcpu-ubuntu-2204
    steps:
      - name: Set Environment Variables
        run: |
          tag=(`echo $GITHUB_SHA | cut -c1-7`)
          echo "IMAGE_TAG=`echo sha-$tag`" >> $GITHUB_ENV
          echo "DEPLOYMENT_VERSION=$(echo $GITHUB_SHA)" >> $GITHUB_ENV
      - name: Deploy Fuel Indexer
        id: deploy_fuel_indexer
        run: >
          curl \
            -X POST \
            -H "Accept: application/vnd.github.v3+json" \
            -H "Authorization: token ${{ secrets.REPO_TOKEN }}" \
            https://api.github.com/repos/FuelLabs/fuel-deployment/actions/workflows/deploy-fuel-indexer.yml/dispatches \
            -d '{"ref":"master","inputs":{ "k8s-type": "${{ env.K8S }}", "config-directory": "${{ env.CONFIG }}", "config-env": "${{ env.ENV }}", "deployment-version": "${{ env.DEPLOYMENT_VERSION }}", "image-tag": "${{ env.IMAGE_TAG }}" }}'
        env:
          K8S: eks
          CONFIG: fuel-dev1
          ENV: fueldevsway.env
  publish:
    needs:
      - set-env-vars
    if: needs.set-env-vars.outputs.IS_RELEASE == 'true'
    runs-on: buildjet-4vcpu-ubuntu-2204
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
      - name: Install toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: wasm32-unknown-unknown
      - name: Verify tag version
        run: >
          curl -sSLf "${DASEL_VERSION}" -L -o dasel && chmod +x dasel

          mv ./dasel /usr/local/bin/dasel

          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} Cargo.toml
      - name: Publish crates
        uses: katyo/publish-crates@v2
        with:
          registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
      - name: Notify Slack On Failure
        uses: ravsamhq/notify-slack-action@v2
        if: always()
        with:
          status: ${{ job.status }}
          token: ${{ secrets.GITHUB_TOKEN }}
          notification_title: "{workflow} has {status_message}"
          message_format: "{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> :
            <{run_url}|View Run Results>"
          footer: ""
          notify_when: failure
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_NOTIFY_BUILD }}
  validation-complete:
    if: always()
    needs:
      - deploy
      - publish
      - unit-tests
      - integration-tests
      - cargo-clippy-no-default-features
      - cargo-clippy-all-features-all-targets
      - cargo-fmt-check
    runs-on: buildjet-4vcpu-ubuntu-2204
    steps:
      - run: true
  notify-slack-on-failure:
    needs:
      - validation-complete
    if: always()
    runs-on: buildjet-4vcpu-ubuntu-2204
    steps:
      - name: Notify Slack On Failure
        uses: ravsamhq/notify-slack-action@v2
        with:
          status: ${{ job.status }}
          token: ${{ secrets.GITHUB_TOKEN }}
          notification_title: "{workflow} has {status_message}"
          message_format: "{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> :
            <{run_url}|View Run Results>"
          footer: ""
          notify_when: failure
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_NOTIFY_BUILD }}