name: Test

on:
  workflow_dispatch:
    inputs:
      network:
        default: 'Mainnet'
      regenerate-disks:
        type: boolean
        default: false
        description: Just update stateful disks
  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/test.yml'

env:
  CARGO_INCREMENTAL: '1'
  ZEBRA_SKIP_IPV6_TESTS: '1'
  RUST_BACKTRACE: full
  RUST_LIB_BACKTRACE: full
  COLORBT_SHOW_HIDDEN: '1'
  NETWORK: Mainnet
  PROJECT_ID: zealous-zebra
  GAR_BASE: us-docker.pkg.dev/zealous-zebra/zebra
  GCR_BASE: gcr.io/zealous-zebra
  REGION: us-central1
  ZONE: us-central1-a
  MACHINE_TYPE: c2d-standard-4
  IMAGE_NAME: zebrad-test

jobs:
  build:
    name: Build images
    timeout-minutes: 210
    runs-on: ubuntu-latest
    permissions:
      contents: 'read'
      id-token: 'write'
    steps:
      - uses: actions/checkout@v3.0.0
        with:
          persist-credentials: false

      - name: Inject slug/short variables
        uses: rlespinasse/github-slug-action@v4
        with:
          short-length: 7

        # Automatic tag management and OCI Image Format Specification for labels
      - name: Docker meta
        id: meta
        uses: docker/metadata-action@v3.7.0
        with:
          # list of Docker images to use as base name for tags
          images: |
            ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}
            ${{ env.GCR_BASE }}/${{ env.GITHUB_REPOSITORY_SLUG_URL }}/${{ env.IMAGE_NAME }}
          # generate Docker tags based on the following events/attributes
          tags: |
            type=schedule
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=semver,pattern={{major}}
            type=sha

      # Setup Docker Buildx to allow use of docker cache layers from GH
      - name: Set up Docker Buildx
        id: buildx
        uses: docker/setup-buildx-action@v1

      - name: Authenticate to Google Cloud
        id: auth
        uses: google-github-actions/auth@v0.7.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'

      - name: Login to Google Artifact Registry
        uses: docker/login-action@v1.14.1
        with:
          registry: us-docker.pkg.dev
          username: oauth2accesstoken
          password: ${{ steps.auth.outputs.access_token }}

      - name: Login to Google Container Registry
        uses: docker/login-action@v1.14.1
        with:
          registry: gcr.io
          username: oauth2accesstoken
          password: ${{ steps.auth.outputs.access_token }}

      # Build and push image to Google Artifact Registry
      - name: Build & push
        id: docker_build
        uses: docker/build-push-action@v2.10.0
        with:
          target: tester
          context: .
          file: ./docker/Dockerfile
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          build-args: |
            NETWORK=${{ github.event.inputs.network || env.NETWORK }}
            SHORT_SHA=${{ env.GITHUB_SHA_SHORT }}
            RUST_BACKTRACE=${{ env.RUST_BACKTRACE }}
            RUST_LIB_BACKTRACE=${{ env.RUST_LIB_BACKTRACE }}
            COLORBT_SHOW_HIDDEN=${{ env.COLORBT_SHOW_HIDDEN }}
            ZEBRA_SKIP_NETWORK_TESTS="1"
            CHECKPOINT_SYNC=${{ github.event.inputs.checkpoint_sync || true }}
            RUST_LOG=debug
            SENTRY_DSN=${{ secrets.SENTRY_ENDPOINT }}
          push: true
          cache-from: type=registry,ref=${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:${{ env.GITHUB_REF_SLUG_URL }}-buildcache
          cache-to: type=registry,ref=${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:${{ env.GITHUB_REF_SLUG_URL }}-buildcache,mode=max

  # Run all the zebra tests, including tests that are ignored by default
  test-all:
    name: Test all
    runs-on: ubuntu-latest
    needs: build
    if: ${{ github.event.inputs.regenerate-disks != '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 -e ZEBRA_SKIP_IPV6_TESTS --name zebrad-tests -t ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }} cargo test --locked --release --features enable-sentry --workspace -- --include-ignored

  # 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.
  test-fake-activation-heights:
    name: Test with fake activation heights
    runs-on: ubuntu-latest
    needs: build
    if: ${{ github.event.inputs.regenerate-disks != '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 ZEBRA_SKIP_IPV6_TESTS -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 -- with_fake_activation_heights
        env:
          TEST_FAKE_ACTIVATION_HEIGHTS: '1'

  # Test that Zebra syncs and checkpoints a few thousand blocks from an empty state
  test-empty-sync:
    name: Test checkpoint sync from empty state
    runs-on: ubuntu-latest
    needs: build
    if: ${{ github.event.inputs.regenerate-disks != '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 -e ZEBRA_SKIP_IPV6_TESTS --name zebrad-tests -t ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }} cargo test --locked --release --features enable-sentry --test acceptance sync_large_checkpoints_ -- --ignored

  test-lightwalletd-integration:
    name: Test integration with lightwalletd
    runs-on: ubuntu-latest
    needs: build
    if: ${{ github.event.inputs.regenerate-disks != 'true' }}
    steps:
      - name: Inject slug/short variables
        uses: rlespinasse/github-slug-action@v4
        with:
          short-length: 7

      - name: Run tests with included lightwalletd binary
        run: |
          docker pull ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }}
          docker run -e ZEBRA_SKIP_IPV6_TESTS -e ZEBRA_TEST_LIGHTWALLETD --name zebrad-tests -t ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }} cargo test --locked --release --features enable-sentry --test acceptance -- lightwalletd_integration --nocapture
        env:
          ZEBRA_TEST_LIGHTWALLETD: '1'

  regenerate-stateful-disks:
    name: Regenerate stateful disks
    runs-on: ubuntu-latest
    needs: build
    outputs:
      any_changed: ${{ steps.changed-files-specific.outputs.any_changed }}
    permissions:
      contents: 'read'
      id-token: 'write'
    steps:
      - uses: actions/checkout@v3.0.0
        with:
          persist-credentials: false
          fetch-depth: '2'

      # Only run this job if the database format version has (likely) changed.
      #
      # If we have accidentally changed the format, but not changed the version,
      # we want to run with the old cached state, so this job fails.
      #
      # If we change the state path without changing the version,
      # this job will take a few hours, because it will do a full rebuild.
      - name: Get specific changed files
        id: changed-files-specific
        uses: tj-actions/changed-files@v18.6
        with:
          files: |
            zebra-state/**/constants.rs

      - name: Inject slug/short variables
        uses: rlespinasse/github-slug-action@v4
        with:
          short-length: 7

      - name: Downcase network name for disks
        run: |
          echo LOWER_NET_NAME="${{ github.event.inputs.network || env.NETWORK }}" | awk '{print tolower($0)}' >> $GITHUB_ENV

      # Setup gcloud CLI
      - name: Authenticate to Google Cloud
        id: auth
        uses: google-github-actions/auth@v0.7.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'

      # Check if our destination compute instance exists and delete it
      - name: Delete existing instance with same SHA
        id: delete-old-instance
        if: ${{ steps.changed-files-specific.outputs.any_changed == 'true' || github.event.inputs.regenerate-disks == 'true' }}
        run: |
          INSTANCE=$(gcloud compute instances list --filter=regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }} --format='value(NAME)')
          if [ -z "${INSTANCE}" ]; then
            echo "No instance to delete"
          else
            gcloud compute instances delete "${INSTANCE}" --zone "${{ env.ZONE }}" --delete-disks all --quiet
          fi

      - name: Create GCP compute instance
        id: create-instance
        if: ${{ steps.changed-files-specific.outputs.any_changed == 'true' || github.event.inputs.regenerate-disks == 'true' }}
        run: |
          gcloud compute instances create-with-container "regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}" \
          --boot-disk-size 100GB \
          --boot-disk-type pd-ssd \
          --create-disk name="zebrad-cache-${{ env.GITHUB_SHA_SHORT }}-${{ env.lower_net_name }}-canopy",size=100GB,type=pd-ssd \
          --container-mount-disk mount-path='/zebrad-cache',name="zebrad-cache-${{ env.GITHUB_SHA_SHORT }}-${{ env.lower_net_name }}-canopy" \
          --container-image ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }} \
          --container-restart-policy=never \
          --container-stdin \
          --container-tty \
          --container-command="cargo" \
          --container-arg="test" \
          --container-arg="--locked" \
          --container-arg="--release" \
          --container-arg="--features" \
          --container-arg="enable-sentry,test_sync_to_mandatory_checkpoint_${{ env.lower_net_name }}" \
          --container-arg="--manifest-path" \
          --container-arg="zebrad/Cargo.toml" \
          --container-arg="sync_to_mandatory_checkpoint_${{ env.lower_net_name }}" \
          --container-env=ZEBRA_SKIP_IPV6_TESTS=1 \
          --machine-type ${{ env.MACHINE_TYPE }} \
          --scopes cloud-platform \
          --metadata=google-monitoring-enabled=true,google-logging-enabled=true \
          --tags zebrad \
          --zone "${{ env.ZONE }}"

      # TODO: this approach is very mesy, but getting the just created container name is very error prone and GCP doesn't have a workaround for this without requiring a TTY
      # This TODO relates to the following issues:
      # https://github.com/actions/runner/issues/241
      # https://www.googlecloudcommunity.com/gc/Infrastructure-Compute-Storage/SSH-into-Compute-Container-not-easily-possible/td-p/170915
      - name: Get container name from logs
        id: get-container-name
        if: ${{ steps.create-instance.outcome == 'success' }}
        run: |
          INSTANCE_ID=$(gcloud compute instances describe regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }} --zone ${{ env.ZONE }} --format='value(id)')
          echo "Using instance: $INSTANCE_ID"
          while [[ ${CONTAINER_NAME} != *"regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}"* ]]; do
              CONTAINER_NAME=$(gcloud logging read 'log_name=projects/${{ env.PROJECT_ID }}/logs/cos_system AND jsonPayload.MESSAGE:regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}' --format='value(jsonPayload.MESSAGE)' --limit=1 | grep -o '...-regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}-....' | tr -d "'.")
              echo "Using container: ${CONTAINER_NAME} from instance: ${INSTANCE_ID}"
              sleep 10
          done
          CONTAINER_NAME=$(gcloud logging read 'log_name=projects/${{ env.PROJECT_ID }}/logs/cos_system AND jsonPayload.MESSAGE:regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}' --format='value(jsonPayload.MESSAGE)' --limit=1 | grep -o '...-regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}-....' | tr -d "'.")
          echo "::set-output name=zebra_container::$CONTAINER_NAME"
          sleep 60

      - name: Regenerate stateful disks logs
        id: sync-to-checkpoint
        if: ${{ steps.create-instance.outcome == 'success' }}
        run: |
          gcloud compute ssh \
          regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }} \
          --zone ${{ env.ZONE }} \
          --quiet \
          --ssh-flag="-o ServerAliveInterval=5" \
          --command="docker logs --follow ${{ env.ZEBRA_CONTAINER }}"
        env:
          ZEBRA_CONTAINER: ${{ steps.get-container-name.outputs.zebra_container }}

      # Create image from disk that will be used to sync past mandatory checkpoint test
      # Force the image creation as the disk is still attached even though is not being used by the container
      - name: Create image from state disk
        # Only run if the earlier step succeeds
        if: steps.sync-to-checkpoint.outcome == 'success'
        run: |
          gcloud compute images create zebrad-cache-${{ env.GITHUB_SHA_SHORT }}-${{ env.lower_net_name }}-canopy \
          --force \
          --source-disk=zebrad-cache-${{ env.GITHUB_SHA_SHORT }}-${{ env.lower_net_name }}-canopy \
          --source-disk-zone=${{ env.ZONE }} \
          --storage-location=us \
          --description="Created from head branch ${{ env.GITHUB_HEAD_REF_SLUG_URL }} targeting ${{ env.GITHUB_BASE_REF_SLUG }} from PR ${{ env.GITHUB_REF_SLUG_URL }} with commit ${{ env.GITHUB_EVENT_PULL_REQUEST_HEAD_SHA }}"

      - name: Delete test instance
        # Do not delete the instance if the sync timeouts in GitHub
        if: ${{ steps.sync-to-checkpoint.outcome == 'success' || steps.sync-to-checkpoint.outcome == 'failure' }}
        continue-on-error: true
        run: |
          gcloud compute instances delete "regenerate-disk-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}" --zone "${{ env.ZONE }}" --delete-disks all --quiet

  # Test that Zebra syncs and fully validates a few thousand blocks from a cached post-checkpoint state
  test-stateful-sync:
    name: Test full validation sync from cached state
    runs-on: ubuntu-latest
    needs: [ build, regenerate-stateful-disks]
    permissions:
      contents: 'read'
      id-token: 'write'
    steps:
      - name: Inject slug/short variables
        uses: rlespinasse/github-slug-action@v4
        with:
          short-length: 7

      - name: Downcase network name for disks
        run: |
          echo LOWER_NET_NAME="${{ github.event.inputs.network || env.NETWORK }}" | awk '{print tolower($0)}' >> $GITHUB_ENV

      # Setup gcloud CLI
      - name: Authenticate to Google Cloud
        id: auth
        uses: google-github-actions/auth@v0.7.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'

      # Check if our destination compute instance exists and delete it
      - name: Delete existing instance with same SHA
        id: delete-old-instance
        if: ${{ needs.regenerate-stateful-disks.outputs.any_changed != 'true' || github.event.inputs.regenerate-disks != 'true'}}
        run: |
          INSTANCE=$(gcloud compute instances list --filter=sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }} --format='value(NAME)')
          if [ -z "${INSTANCE}" ]; then
            echo "No instance to delete"
          else
            gcloud compute instances delete "${INSTANCE}" --zone "${{ env.ZONE }}" --delete-disks all --quiet
          fi

      - name: Get disk state name from gcloud
        id: get-disk-name
        if: ${{ needs.regenerate-stateful-disks.outputs.any_changed != 'true' || github.event.inputs.regenerate-disks != 'true'}}
        run: |
          output=$(gcloud compute images list --filter="zebrad-cache" --format="value(NAME)" --sort-by=~creationTimestamp --limit=1)
          echo "Disk: $output"
          echo "Description: $(gcloud compute images describe $output --format='value(DESCRIPTION)')"
          echo "::set-output name=sha::$output"

      # Creates Compute Engine virtual machine instance w/ disks
      - name: Create GCP compute instance
        id: create-instance
        run: |
          gcloud compute instances create-with-container "sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}" \
          --boot-disk-size 100GB \
          --boot-disk-type pd-ssd \
          --create-disk=image=${{ env.CACHED_DISK_NAME }},name=zebrad-cache-${{ env.GITHUB_SHA_SHORT }}-${{ env.lower_net_name }}-canopy,size=100GB,type=pd-ssd \
          --container-mount-disk=mount-path='/zebrad-cache',name=zebrad-cache-${{ env.GITHUB_SHA_SHORT }}-${{ env.lower_net_name }}-canopy \
          --container-image ${{ env.GAR_BASE }}/${{ env.IMAGE_NAME }}:sha-${{ env.GITHUB_SHA_SHORT }} \
          --container-restart-policy=never \
          --container-stdin \
          --container-tty \
          --container-command="cargo" \
          --container-arg="test" \
          --container-arg="--locked" \
          --container-arg="--release" \
          --container-arg="--features" \
          --container-arg="enable-sentry,test_sync_past_mandatory_checkpoint_${{ env.lower_net_name }}" \
          --container-arg="--manifest-path" \
          --container-arg="zebrad/Cargo.toml" \
          --container-arg="sync_past_mandatory_checkpoint_${{ env.lower_net_name }}" \
          --container-env=ZEBRA_SKIP_IPV6_TESTS=1 \
          --machine-type ${{ env.MACHINE_TYPE }} \
          --scopes cloud-platform \
          --metadata=google-monitoring-enabled=true,google-logging-enabled=true \
          --tags zebrad \
          --zone "${{ env.ZONE }}"
        env:
          CACHED_DISK_NAME: ${{ steps.get-disk-name.outputs.sha }}

      # TODO: this approach is very mesy, but getting the just created container name is very error prone and GCP doesn't have a workaround for this without requiring a TTY
      # This TODO relates to the following issues:
      # https://github.com/actions/runner/issues/241
      # https://www.googlecloudcommunity.com/gc/Infrastructure-Compute-Storage/SSH-into-Compute-Container-not-easily-possible/td-p/170915
      - name: Get container name from logs
        id: get-container-name
        if: ${{ steps.create-instance.outcome == 'success' }}
        run: |
          INSTANCE_ID=$(gcloud compute instances describe sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }} --zone ${{ env.ZONE }} --format='value(id)')
          echo "Using instance: $INSTANCE_ID"
          while [[ ${CONTAINER_NAME} != *"sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}"* ]]; do
              CONTAINER_NAME=$(gcloud logging read 'log_name=projects/${{ env.PROJECT_ID }}/logs/cos_system AND jsonPayload.MESSAGE:sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}' --format='value(jsonPayload.MESSAGE)' --limit=1 | grep -o '...-sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}-....' | tr -d "'.")
              echo "Using container: ${CONTAINER_NAME} from instance: ${INSTANCE_ID}"
              sleep 10
          done
          CONTAINER_NAME=$(gcloud logging read 'log_name=projects/${{ env.PROJECT_ID }}/logs/cos_system AND jsonPayload.MESSAGE:sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}' --format='value(jsonPayload.MESSAGE)' --limit=1 | grep -o '...-sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}-....' | tr -d "'.")
          echo "::set-output name=zebra_container::$CONTAINER_NAME"
          sleep 60

      - name: Sync past mandatory checkpoint logs
        id: sync-past-checkpoint
        run: |
          gcloud compute ssh \
          sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }} \
          --zone ${{ env.ZONE }} \
          --quiet \
          --ssh-flag="-o ServerAliveInterval=5" \
          --command="docker logs --follow ${{ env.ZEBRA_CONTAINER }}"
        env:
          ZEBRA_CONTAINER: ${{ steps.get-container-name.outputs.zebra_container }}

      - name: Delete test instance
        # Do not delete the instance if the sync timeouts in GitHub
        if: ${{ steps.sync-past-checkpoint.outcome == 'success' || steps.sync-past-checkpoint.outcome == 'failure' }}
        continue-on-error: true
        run: |
          gcloud compute instances delete "sync-checkpoint-${{ env.GITHUB_REF_SLUG_URL }}-${{ env.GITHUB_SHA_SHORT }}" --zone "${{ env.ZONE }}" --delete-disks all --quiet