qns.yml

name: QNS

on:
  push:
    branches: ["main"]
    paths-ignore: ["*.md", "*.png", "*.svg", "LICENSE-*"]
  pull_request:
    branches: ["main"]
    paths-ignore: ["*.md", "*.png", "*.svg", "LICENSE-*"]
  merge_group:
  schedule:
    # Run at 1 AM each day
    - cron: '0 1 * * *'
  workflow_dispatch:

concurrency:
  group: ${{ github.workflow }}-${{ github.ref_name }}
  cancel-in-progress: true

permissions: read-all

env:
  LATEST: neqo-latest
  DELIM: ' vs. '

jobs:
  docker-image:
    name: Build Docker image
    runs-on: ubuntu-latest
    outputs:
      imageID: ${{ steps.docker_build_and_push.outputs.imageID }}
    permissions:
      packages: write
    steps:
      - uses: docker/setup-qemu-action@5927c834f5b4fdf503fca6f4c7eccda82949e1ee # v3.1.0
      - uses: docker/setup-buildx-action@4fd812986e6c8c2a69e18311145f9371337f27d4 # v3.4.0
      - uses: docker/login-action@0d4c9c5ea7693da7b068278f7b52bda2a190a446 # v3.2.0
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ github.token }}

      - uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81 # v5.5.1
        id: meta
        with:
          images: ghcr.io/${{ github.repository }}-qns
          tags: |
            # default
            type=schedule
            type=ref,event=branch
            type=ref,event=tag
            type=ref,event=pr
            # set latest tag for default branch
            type=raw,value=latest,enable={{is_default_branch}}

      - uses: docker/build-push-action@1a162644f9a7e87d8f4b053101d1d9a712edc18c # v6.3.0
        if: github.event_name != 'pull_request'
        with:
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          file: qns/Dockerfile
          build-args: RUST_VERSION=stable
          cache-from: type=gha
          cache-to: type=gha,mode=max
          platforms: 'linux/amd64, linux/arm64'

      - uses: docker/build-push-action@1a162644f9a7e87d8f4b053101d1d9a712edc18c # v6.3.0
        id: docker_build_and_push
        with:
          tags: ${{ steps.meta.outputs.tags }}
          file: qns/Dockerfile
          build-args: RUST_VERSION=stable
          cache-from: type=gha
          cache-to: type=gha,mode=max
          platforms: 'linux/amd64'
          outputs: type=docker,dest=/tmp/${{ env.LATEST }}.tar

      - uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b # v4.3.4
        with:
          name: '${{ env.LATEST }} Docker image'
          path: /tmp/${{ env.LATEST }}.tar

  implementations:
    name: Determine interop pairs
    needs: docker-image
    runs-on: ubuntu-latest
    outputs:
      pairs: ${{ steps.config.outputs.pairs }}
      implementations: ${{ steps.config.outputs.implementations }}
    env:
      URL: https://github.com/mozilla/neqo
      ROLE: both
    steps:
      - id: config
        run: |
          # Add neqo-latest to implementations.json
          curl https://raw.githubusercontent.com/quic-interop/quic-interop-runner/master/implementations.json | \
            jq --arg key "$LATEST" --argjson newEntry '
              {
                "image": "${{ needs.docker-image.outputs.imageID }}",
                "url": "${{ env.URL }}",
                "role": "${{ env.ROLE }}"
              }' '.[$key] = $newEntry' > implementations.json
          {
            echo "implementations<<EOF"
            cat implementations.json
            echo "EOF"
          } >> "$GITHUB_OUTPUT"
          # Determine valid interop pairs that contain $LATEST
          jq < implementations.json "[
              [to_entries[] | select(.value.role==\"server\" or .value.role==\"both\").key] as \$servers |
              [to_entries[] | select(.value.role==\"client\" or .value.role==\"both\").key] as \$clients |
              \$clients[] as \$client |
              \$servers[] as \$server |
              \$client + \"$DELIM\" + \$server |
              select(contains(\"$LATEST\"))
            ]" > pairs.json
          {
            echo "pairs<<EOF"
            cat pairs.json
            echo "EOF"
          } >> "$GITHUB_OUTPUT"

  run-qns:
    name: Run QNS
    needs: implementations
    strategy:
      fail-fast: false
      matrix:
        pair: ${{ fromJson(needs.implementations.outputs.pairs) }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
        with:
          name: '${{ env.LATEST }} Docker image'
          path: /tmp

      - run: docker load --input /tmp/${{ env.LATEST }}.tar

      - id: depair
        run: |
          PAIR=$(echo ${{ matrix.pair }} | sed "s/$DELIM/%/g")
          echo "client=$(echo "$PAIR" | cut -d% -f1)" >> "$GITHUB_OUTPUT"
          echo "server=$(echo "$PAIR" | cut -d% -f2)" >> "$GITHUB_OUTPUT"

      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7

      # TODO: Replace once https://github.com/quic-interop/quic-interop-runner/pull/356 is merged.
      - uses: ./.github/actions/quic-interop-runner
        with:
          client: ${{ steps.depair.outputs.client }}
          server: ${{ steps.depair.outputs.server }}
          implementations: ${{ needs.implementations.outputs.implementations }}

  report:
    name: Report results
    needs: run-qns
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
      - uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
        with:
          pattern: '*results'
          path: results

      - run: |
          for RUN in results/*; do
            [ -e "$RUN/result.json" ] || continue
            CLIENT=$(jq -r < "$RUN/result.json" '.clients[0]')
            SERVER=$(jq -r < "$RUN/result.json" '.servers[0]')
            jq < "$RUN/result.json" '
                . as $data |
                {
                  results: [.results[] | group_by(.result)[] | {(.[0].result): [.[] | .abbr]}] |
                  add
                } |
                . + {log_url: $data.log_url}
              ' > "$RUN/grouped.json"
            for GROUP in $(jq -r < "$RUN/grouped.json" '.results | keys[]'); do
              RESULT=$(jq < "$RUN/grouped.json" -r '.results.'"$GROUP"'[]' | fmt -w 1000)
              LOG=$(jq -r < "$RUN/grouped.json" -r '.log_url')
              [ -n "$RESULT" ] || continue
              {
                echo -n "* ["
                [ "$CLIENT" == "$LATEST" ] || echo -n "<ins>"
                echo -n "$CLIENT"
                [ "$CLIENT" == "$LATEST" ] || echo -n "</ins>"
                echo -n "$DELIM"
                [ "$SERVER" == "$LATEST" ] || echo -n "<ins>"
                echo -n "$SERVER"
                [ "$SERVER" == "$LATEST" ] || echo -n "</ins>"
                echo -n "]($LOG): "
                echo "**$RESULT**"
              } >> "$GROUP.md"
            done
          done
          {
            echo "### Failed Interop Tests"
            if [ -e failed.md ]; then
              echo "[QUIC Interop Runner](https://github.com/quic-interop/quic-interop-runner), *client* vs. *server*"
              cat failed.md
            else
              echo "None :tada:"
            fi
            echo "<details><summary>All results</summary>"
            echo
            for GROUP in succeeded unsupported; do
              echo "### ${GROUP^} Interop Tests"
              if [ -e "$GROUP.md" ]; then
                echo "[QUIC Interop Runner](https://github.com/quic-interop/quic-interop-runner), *client* vs. *server*"
                cat "$GROUP.md"
              else
                echo "None :question:"
              fi
            done
            echo
            echo "</details>"
          } >> comment.md

      - uses: ./.github/actions/pr-comment-data-export
        with:
          name: ${{ github.workflow }}
          contents: comment.md