zebra/.github/workflows/continous-integration-docker.yml

name: CI Docker

on:
  workflow_dispatch:
    inputs:
      network:
        default: 'Mainnet'
        description: 'Network to deploy: Mainnet or Testnet'
        required: true
      checkpoint_sync:
        default: 'true'
        description: 'Configures `zebrad` to use as many checkpoints as possible'
        required: true
      regenerate-disks:
        type: boolean
        default: false
        description: 'Just update mandatory checkpoint disks'
        required: true
      run-full-sync:
        type: boolean
        default: false
        description: 'Just run a full sync and update tip disks'
        required: true

  pull_request:
    branches:
      - main
    paths:
      # code and tests
      - '**/*.rs'
      # hard-coded checkpoints and proptest regressions
      - '**/*.txt'
      # test data snapshots
      - '**/*.snap'
      # dependencies
      - '**/Cargo.toml'
      - '**/Cargo.lock'
      # workflow definitions
      - 'docker/**'
      - '.github/workflows/continous-integration-docker.yml'
      - '.github/workflows/deploy-gcp-tests.yml'
      - '.github/workflows/build-docker-image.yml'

  push:
    branches:
      - main
    paths:
      # code and tests
      - '**/*.rs'
      # hard-coded checkpoints and proptest regressions
      - '**/*.txt'
      # test data snapshots
      - '**/*.snap'
      # dependencies
      - '**/Cargo.toml'
      - '**/Cargo.lock'
      # workflow definitions
      - 'docker/**'
      - '.github/workflows/continous-integration-docker.yml'
      - '.github/workflows/deploy-gcp-tests.yml'
      - '.github/workflows/build-docker-image.yml'

env:
  # TODO: use the output from ./.github/workflows/build-docker-image.yml
  IMAGE_NAME: zebrad-test
  GAR_BASE: us-docker.pkg.dev/zealous-zebra/zebra
  # TODO: use environmental secrets for dynamic values
  NETWORK: Mainnet

jobs:
  get-available-disks:
    runs-on: ubuntu-latest
    name: Find available cached state disks
    outputs:
      lwd_tip_disk: ${{ steps.get-available-disks.outputs.lwd_tip_disk }}
      zebra_tip_disk: ${{ steps.get-available-disks.outputs.zebra_tip_disk }}
      zebra_checkpoint_disk: ${{ steps.get-available-disks.outputs.zebra_checkpoint_disk }}
    permissions:
      contents: 'read'
      id-token: 'write'
    steps:
      - uses: actions/checkout@v3.0.2
        with:
          persist-credentials: false
          fetch-depth: 0

      # Setup gcloud CLI
      - name: Authenticate to Google Cloud
        id: auth
        uses: google-github-actions/auth@v0.8.0
        with:
          workload_identity_provider: 'projects/143793276228/locations/global/workloadIdentityPools/github-actions/providers/github-oidc'
          service_account: 'github-service-account@zealous-zebra.iam.gserviceaccount.com'
          token_format: 'access_token'

      # Disk images in GCP are required to be in lowercase, but the blockchain network
      # uses sentence case, so we need to downcase ${{ env.NETWORK or github.event.inputs.network }}
      #
      # Passes a lowercase Network name to subsequent steps using $NETWORK env variable
      - name: Downcase network name for disks
        run: |
          NETWORK_CAPS=${{ env.NETWORK || github.event.inputs.network }}
          echo "NETWORK=${NETWORK_CAPS,,}" >> $GITHUB_ENV          

      # Find a cached state disk for subsequent jobs needing a cached state without
      # restricting the result from any branch.
      #
      # This search is executed considering the actual version from constants.rs
      #
      # Generate one of the following outputs with a boolean to pass to subsequent jobs:
      # - lwd_tip_disk
      # - zebra_tip_disk
      # - zebra_checkpoint_disk
      - name: Find cached state disks
        id: get-available-disks
        run: |
          LOCAL_STATE_VERSION=$(grep -oE "DATABASE_FORMAT_VERSION: .* [0-9]+" "$GITHUB_WORKSPACE/zebra-state/src/constants.rs" | grep -oE "[0-9]+" | tail -n1)
          echo "STATE_VERSION: $LOCAL_STATE_VERSION"

          LWD_TIP_DISK=$(gcloud compute images list --filter="name~lwd-cache-.+-[0-9a-f]+-v${LOCAL_STATE_VERSION}-${NETWORK}-tip" --format="value(NAME)" --sort-by=~creationTimestamp --limit=1)
          if [[ -z "$LWD_TIP_DISK" ]]; then
              echo "No TIP disk found for LWD"
              echo "::set-output name=lwd_tip_disk::${{ toJSON(false) }}"
          else
              echo "Disk: $LWD_TIP_DISK"
              echo "::set-output name=lwd_tip_disk::${{ toJSON(true) }}"
          fi

          ZEBRA_TIP_DISK=$(gcloud compute images list --filter="name~zebrad-cache-.+-[0-9a-f]+-v${LOCAL_STATE_VERSION}-${NETWORK}-tip" --format="value(NAME)" --sort-by=~creationTimestamp --limit=1)
          if [[ -z "$ZEBRA_TIP_DISK" ]]; then
              echo "No TIP disk found for ZEBRA"
              echo "::set-output name=zebra_tip_disk::${{ toJSON(false) }}"
          else
              echo "Disk: $ZEBRA_TIP_DISK"
              echo "::set-output name=zebra_tip_disk::${{ toJSON(true) }}"
          fi

          ZEBRA_CHECKPOINT_DISK=$(gcloud compute images list --filter="name~zebrad-cache-.+-[0-9a-f]+-v${LOCAL_STATE_VERSION}-${NETWORK}-checkpoint" --format="value(NAME)" --sort-by=~creationTimestamp --limit=1)
          if [[ -z "$ZEBRA_CHECKPOINT_DISK" ]]; then
              echo "No CHECKPOINT found for ZEBRA"
              echo "::set-output name=zebra_checkpoint_disk::${{ toJSON(false) }}"
          else
              echo "Disk: $ZEBRA_CHECKPOINT_DISK"
              echo "::set-output name=zebra_checkpoint_disk::${{ toJSON(true) }}"
          fi          

  build:
    name: Build
    uses: ./.github/workflows/build-docker-image.yml
    with:
      dockerfile_path: ./docker/Dockerfile
      dockerfile_target: tests
      image_name: zebrad-test
      # TODO: validate how to use variable/conditional values for Testnet
      network: Mainnet
      checkpoint_sync: true
      rust_backtrace: full
      rust_lib_backtrace: full
      colorbt_show_hidden: '1'
      zebra_skip_ipv6_tests: '1'
      rust_log: info

  # Run all the zebra tests, including tests that are ignored by default.
  # Skips tests that need a cached state disk or a lightwalletd binary.
  #
  # (We activate the gRPC feature to avoid recompiling `zebrad`, but we don't actually run any gRPC tests.)
  test-all:
    name: Test all
    runs-on: ubuntu-latest
    needs: build
    if: ${{ github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true' }}
    steps:
      - name: Inject slug/short variables
        uses: rlespinasse/github-slug-action@v4
        with:
          short-length: 7

      - name: Run all zebrad tests
        run: |
          docker pull ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }}
          docker run --name zebrad-tests -t ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }} cargo test --locked --release --features lightwalletd-grpc-tests --workspace -- --nocapture --include-ignored          

  # Run state tests with fake activation heights.
  #
  # This test changes zebra-chain's activation heights,
  # which can recompile all the Zebra crates,
  # so we want its build products to be cached separately.
  #
  # Also, we don't want to accidentally use the fake heights in other tests.
  #
  # (The gRPC feature is a zebrad feature, so it isn't needed here.)
  test-fake-activation-heights:
    name: Test with fake activation heights
    runs-on: ubuntu-latest
    needs: build
    if: ${{ github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true' }}
    steps:
      - name: Inject slug/short variables
        uses: rlespinasse/github-slug-action@v4
        with:
          short-length: 7

      - name: Run tests with fake activation heights
        run: |
          docker pull ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }}
          docker run -e TEST_FAKE_ACTIVATION_HEIGHTS --name zebrad-tests -t ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }} cargo test --locked --release --package zebra-state --lib -- --nocapture --include-ignored with_fake_activation_heights          
        env:
          TEST_FAKE_ACTIVATION_HEIGHTS: '1'

  # Test that Zebra syncs and checkpoints a few thousand blocks from an empty state.
  #
  # (We activate the gRPC feature to avoid recompiling `zebrad`, but we don't actually run any gRPC tests.)
  test-empty-sync:
    name: Test checkpoint sync from empty state
    runs-on: ubuntu-latest
    needs: build
    if: ${{ github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true' }}
    steps:
      - name: Inject slug/short variables
        uses: rlespinasse/github-slug-action@v4
        with:
          short-length: 7

      - name: Run zebrad large sync tests
        run: |
          docker pull ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }}
          docker run --name zebrad-tests -t ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }} cargo test --locked --release --features lightwalletd-grpc-tests --package zebrad --test acceptance -- --nocapture --include-ignored sync_large_checkpoints_          

  # Test launching lightwalletd with an empty lightwalletd and Zebra state.
  #
  # (We activate the gRPC feature to avoid recompiling `zebrad`, but we don't actually run any gRPC tests.)
  test-lightwalletd-integration:
    name: Test integration with lightwalletd
    runs-on: ubuntu-latest
    needs: build
    if: ${{ github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true' }}
    steps:
      - name: Inject slug/short variables
        uses: rlespinasse/github-slug-action@v4
        with:
          short-length: 7

      - name: Run tests with empty lightwalletd launch
        run: |
          docker pull ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }}
          docker run -e ZEBRA_TEST_LIGHTWALLETD --name lightwalletd-tests -t ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }} cargo test --locked --release --features lightwalletd-grpc-tests --package zebrad --test acceptance -- --nocapture --include-ignored lightwalletd_integration          
        env:
          ZEBRA_TEST_LIGHTWALLETD: '1'

  # Regenerate mandatory checkpoint Zebra cached state disks.
  #
  # Runs:
  # - on every PR update, but only if there's no available disk matching the actual state version from constants.rs
  # - on request, using workflow_dispatch with regenerate-disks
  #
  # Note: the output from get-available-disks should match with the caller workflow inputs
  regenerate-stateful-disks:
    name: Zebra checkpoint
    needs: [ build, get-available-disks ]
    uses: ./.github/workflows/deploy-gcp-tests.yml
    if: ${{ !fromJSON(needs.get-available-disks.outputs.zebra_checkpoint_disk) || github.event.inputs.regenerate-disks == 'true' }}
    with:
      test_id: sync-to-checkpoint
      test_description: Test sync up to mandatory checkpoint
      test_variables: '-e TEST_DISK_REBUILD=1 -e ZEBRA_FORCE_USE_COLOR=1'
      needs_zebra_state: false
      saves_to_disk: true
      disk_suffix: checkpoint
      height_grep_text: 'flushing database to disk .*height.*=.*Height'

  # Test that Zebra syncs and fully validates a few thousand blocks from a cached mandatory checkpoint disk
  #
  # If the state version has changed, waits for the new cached state to be created.
  # Otherwise, if the state rebuild was skipped, runs immediately after the build job.
  test-stateful-sync:
    name: Zebra checkpoint update
    needs: regenerate-stateful-disks
    uses: ./.github/workflows/deploy-gcp-tests.yml
    if: ${{ !cancelled() && !failure() && github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true' }}
    with:
      test_id: sync-past-checkpoint
      test_description: Test full validation sync from a cached state
      test_variables: '-e TEST_CHECKPOINT_SYNC=1 -e ZEBRA_FORCE_USE_COLOR=1'
      needs_zebra_state: true
      saves_to_disk: false
      disk_suffix: checkpoint

  # Test that Zebra can run a full mainnet sync,
  # and regenerate chain tip Zebra cached state disks.
  #
  # Runs:
  # - after every PR is merged to `main`
  # - on every PR update, but only if there's no available disk matching the actual state version from constants.rs
  # - on request, using workflow_dispatch with run-full-sync
  #
  # Note: the output from get-available-disks should match with the caller workflow inputs
  test-full-sync:
    name: Zebra tip
    needs: [ build, get-available-disks ]
    uses: ./.github/workflows/deploy-gcp-tests.yml
    # to also run on Mergify head branches,
    # add `|| (github.event_name == 'push' && startsWith(github.head_ref, 'mergify/merge-queue/'))`:
    # https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#running-your-workflow-based-on-the-head-or-base-branch-of-a-pull-request-1
    if: ${{ (github.event_name == 'push' && github.ref_name == 'main') || !fromJSON(needs.get-available-disks.outputs.zebra_tip_disk) || github.event.inputs.run-full-sync == 'true' }}
    with:
      test_id: full-sync-to-tip
      test_description: Test a full sync up to the tip
      test_variables: '-e TEST_FULL_SYNC=1 -e ZEBRA_FORCE_USE_COLOR=1 -e FULL_SYNC_MAINNET_TIMEOUT_MINUTES=600'
      needs_zebra_state: false
      saves_to_disk: true
      disk_suffix: tip
      height_grep_text: 'current_height.*=.*Height'

  # Test that Zebra can answer a synthetic RPC call, using a cached Zebra tip state
  #
  # Runs:
  # - after every PR is merged to `main`
  # - on every PR update
  #
  # If the state version has changed, waits for the new cached state to be created.
  # Otherwise, if the state rebuild was skipped, runs immediately after the build job.
  lightwalletd-rpc-test:
    name: Zebra tip JSON-RPC
    needs: test-full-sync
    uses: ./.github/workflows/deploy-gcp-tests.yml
    if: ${{ !cancelled() && !failure() && github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true' }}
    with:
      app_name: lightwalletd
      test_id: fully-synced-rpc
      test_description: Test lightwalletd RPC with a Zebra tip state
      test_variables: '-e TEST_LWD_RPC_CALL=1 -e ZEBRA_TEST_LIGHTWALLETD=1 -e ZEBRA_FORCE_USE_COLOR=1 -e ZEBRA_CACHED_STATE_DIR=/var/cache/zebrad-cache'
      needs_zebra_state: true
      saves_to_disk: false
      disk_suffix: tip
      root_state_path: '/var/cache'
      zebra_state_dir: 'zebrad-cache'

  # Test that Zebra can handle a lightwalletd send transaction RPC call, using a cached Zebra tip state
  #
  # Runs:
  # - after every PR is merged to `main`
  # - on every PR update
  #
  # If the state version has changed, waits for the new cached states to be created.
  # Otherwise, if the state rebuild was skipped, runs immediately after the build job.
  # TODO: move this job under lightwalletd-full-sync to have a sequential logic
  lightwalletd-transactions-test:
    name: lightwalletd tip send
    needs: lightwalletd-full-sync
    uses: ./.github/workflows/deploy-gcp-tests.yml
    if: ${{ !cancelled() && !failure() && github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true' }}
    with:
      app_name: lightwalletd
      test_id: lwd-send-transactions
      test_description: Test sending transactions via lightwalletd
      test_variables: '-e TEST_LWD_TRANSACTIONS=1 -e ZEBRA_TEST_LIGHTWALLETD=1 -e ZEBRA_FORCE_USE_COLOR=1 -e ZEBRA_CACHED_STATE_DIR=/var/cache/zebrad-cache -e LIGHTWALLETD_DATA_DIR=/var/cache/lwd-cache'
      needs_zebra_state: true
      needs_lwd_state: true
      saves_to_disk: false
      disk_suffix: tip
      root_state_path: '/var/cache'
      zebra_state_dir: 'zebrad-cache'
      lwd_state_dir: 'lwd-cache'

  # Test full sync of lightwalletd with a Zebra tip state
  #
  # Runs:
  # - after every PR is merged to `main`
  # - on every PR update
  #
  # If the state version has changed, waits for the new cached state to be created.
  # Otherwise, if the state rebuild was skipped, runs immediately after the build job.
  lightwalletd-full-sync:
    name: lightwalletd tip
    needs: [ test-full-sync, get-available-disks ]
    uses: ./.github/workflows/deploy-gcp-tests.yml
    # to also run on Mergify head branches,
    # add `|| (github.event_name == 'push' && startsWith(github.head_ref, 'mergify/merge-queue/'))`:
    # https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#running-your-workflow-based-on-the-head-or-base-branch-of-a-pull-request-1
    # TODO: this test is unreliable, in the meanwhile we'll only generate a new lwd cached state when a full sync is also triggered
    if: ${{ (!cancelled() && !failure() && github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true') || !fromJSON(needs.get-available-disks.outputs.lwd_tip_disk) }}
    with:
      app_name: lightwalletd
      test_id: lwd-full-sync
      test_description: Test lightwalletd full sync
      test_variables: '-e TEST_LWD_FULL_SYNC=1 -e ZEBRA_TEST_LIGHTWALLETD=1 -e ZEBRA_FORCE_USE_COLOR=1 -e ZEBRA_CACHED_STATE_DIR=/var/cache/zebrad-cache -e LIGHTWALLETD_DATA_DIR=/var/cache/lwd-cache'
      needs_zebra_state: true
      needs_lwd_state: false
      saves_to_disk: true
      disk_prefix: lwd-cache
      disk_suffix: tip
      root_state_path: '/var/cache'
      zebra_state_dir: 'zebrad-cache'
      lwd_state_dir: 'lwd-cache'

  # Test update sync of lightwalletd with a lightwalletd and Zebra tip state
  # Runs:
  # - after every PR is merged to `main`
  # - on every PR update
  #
  # If the state version has changed, waits for the new cached states to be created.
  # Otherwise, if the state rebuild was skipped, runs immediately after the build job.
  lightwalletd-update-sync:
    name: lightwalletd tip update
    needs: lightwalletd-full-sync
    uses: ./.github/workflows/deploy-gcp-tests.yml
    if: ${{ !cancelled() && !failure() && github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true' }}
    with:
      app_name: lightwalletd
      test_id: lwd-update-sync
      test_description: Test lightwalletd update sync with both states
      test_variables: '-e TEST_LWD_UPDATE_SYNC=1 -e ZEBRA_TEST_LIGHTWALLETD=1 -e ZEBRA_FORCE_USE_COLOR=1 -e ZEBRA_CACHED_STATE_DIR=/var/cache/zebrad-cache -e LIGHTWALLETD_DATA_DIR=/var/cache/lwd-cache'
      needs_zebra_state: true
      needs_lwd_state: true
      saves_to_disk: false
      disk_prefix: lwd-cache
      disk_suffix: tip
      root_state_path: '/var/cache'
      zebra_state_dir: 'zebrad-cache'
      lwd_state_dir: 'lwd-cache'

  # Test that Zebra can handle gRPC wallet calls, using a cached Zebra tip state
  #
  # Runs:
  # - after every PR is merged to `main`
  # - on every PR update
  #
  # If the state version has changed, waits for the new cached states to be created.
  # Otherwise, if the state rebuild was skipped, runs immediately after the build job.
  lightwalletd-grpc-test:
    name: lightwalletd GRPC tests
    needs: lightwalletd-full-sync
    uses: ./.github/workflows/deploy-gcp-tests.yml
    if: ${{ !cancelled() && !failure() && github.event.inputs.regenerate-disks != 'true' && github.event.inputs.run-full-sync != 'true' }}
    with:
      app_name: lightwalletd
      test_id: lwd-grpc-wallet
      test_description: Test gRPC calls via lightwalletd
      test_variables: '-e TEST_LWD_GRPC=1 -e ZEBRA_TEST_LIGHTWALLETD=1 -e ZEBRA_FORCE_USE_COLOR=1 -e ZEBRA_CACHED_STATE_DIR=/var/cache/zebrad-cache -e LIGHTWALLETD_DATA_DIR=/var/cache/lwd-cache'
      needs_zebra_state: true
      needs_lwd_state: true
      saves_to_disk: false
      disk_suffix: tip
      root_state_path: '/var/cache'
      zebra_state_dir: 'zebrad-cache'
      lwd_state_dir: 'lwd-cache'