VeniceCI-E2ETests.yml

# Auto-generated file. Do not edit manually!
#
# To alter these flows, edit:
#
#     internal/venice-test-common/build.gradle
#
# To regenerate, run:
#
#     ./gradlew generateGHCI

name: E2ETests

on: [push, pull_request, workflow_dispatch]

jobs:
  IntegrationTests_1000:
    name: IntegrationTests_1000
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1000
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1000
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1010:
    name: IntegrationTests_1010
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1010
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1010
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1020:
    name: IntegrationTests_1020
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1020
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1020
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1030:
    name: IntegrationTests_1030
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1030
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1030
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1040:
    name: IntegrationTests_1040
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1040
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1040
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1050:
    name: IntegrationTests_1050
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1050
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1050
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1060:
    name: IntegrationTests_1060
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1060
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1060
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1070:
    name: IntegrationTests_1070
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1070
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1070
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1080:
    name: IntegrationTests_1080
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1080
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1080
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1090:
    name: IntegrationTests_1090
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1090
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1090
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1100:
    name: IntegrationTests_1100
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1100
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1100
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1110:
    name: IntegrationTests_1110
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1110
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1110
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1120:
    name: IntegrationTests_1120
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1120
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1120
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1130:
    name: IntegrationTests_1130
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1130
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1130
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1200:
    name: IntegrationTests_1200
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1200
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1200
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1210:
    name: IntegrationTests_1210
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1210
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1210
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1220:
    name: IntegrationTests_1220
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1220
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1220
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1230:
    name: IntegrationTests_1230
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1230
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1230
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1240:
    name: IntegrationTests_1240
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1240
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1240
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1250:
    name: IntegrationTests_1250
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1250
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1250
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1260:
    name: IntegrationTests_1260
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1260
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1260
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1270:
    name: IntegrationTests_1270
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1270
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1270
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1280:
    name: IntegrationTests_1280
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1280
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1280
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1400:
    name: IntegrationTests_1400
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1400
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1400
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1410:
    name: IntegrationTests_1410
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1410
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1410
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1420:
    name: IntegrationTests_1420
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1420
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1420
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1430:
    name: IntegrationTests_1430
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1430
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1430
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1440:
    name: IntegrationTests_1440
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1440
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1440
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1500:
    name: IntegrationTests_1500
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1500
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1500
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_1550:
    name: IntegrationTests_1550
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_1550
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_1550
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  IntegrationTests_9999:
    name: IntegrationTests_9999
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    permissions:
     id-token: write
     contents: read
     checks: write
    timeout-minutes: 120
    concurrency:
     group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-jdk${{ matrix.jdk }}-IntegrationTests_9999
     cancel-in-progress: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.jdk }}
          distribution: 'temurin'
          cache: 'gradle'
      - shell: bash
        run: |
          git remote set-head origin --auto
          git remote add upstream https://github.com/linkedin/venice
          git fetch upstream
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v4
      - name: Run Integration Tests
        run: ./gradlew --continue --no-daemon -DforkEvery=1 -DmaxParallelForks=1 integrationTests_9999
      - name: Package Build Artifacts
        if: success() || failure()
        shell: bash
        run: |
          mkdir ${{ github.job }}-artifacts
          echo "Repository owner: ${{ github.repository_owner }}"
          echo "Repository name: ${{ github.repository }}"
          echo "event name: ${{ github.event_name }}"
          find . -path "**/build/reports/*" -or -path "**/build/test-results/*" > artifacts.list
          rsync -R --files-from=artifacts.list . ${{ github.job }}-artifacts
          tar -zcvf ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz ${{ github.job }}-artifacts
      - name: Generate Fork Repo Test Reports
        if: ${{ (github.repository_owner != 'linkedin') && (success() || failure()) }}
        uses: dorny/test-reporter@v1.9.1
        env:
         NODE_OPTIONS: --max-old-space-size=9182
        with:
         token: ${{ secrets.GITHUB_TOKEN }}
         name: ${{ github.job }} Test Reports       # Name where it report the test results
         path: '**/TEST-*.xml'
         fail-on-error: 'false'
         max-annotations: '10'
         list-tests: 'all'
         list-suites: 'all'
         reporter: java-junit
      - name: Upload Build Artifacts
        if: success() || failure()
        uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}
          path: ${{ github.job }}-jdk${{ matrix.jdk }}-logs.tar.gz
          retention-days: 30

  E2ETestsCompletion:
    strategy:
      fail-fast: false
      matrix:
        jdk: [17]
    runs-on: ubuntu-latest
    needs: [IntegrationTests_1000, IntegrationTests_1010, IntegrationTests_1020, IntegrationTests_1030, IntegrationTests_1040, IntegrationTests_1050, IntegrationTests_1060, IntegrationTests_1070, IntegrationTests_1080, IntegrationTests_1090, IntegrationTests_1100, IntegrationTests_1110, IntegrationTests_1120, IntegrationTests_1130, IntegrationTests_1200, IntegrationTests_1210, IntegrationTests_1220, IntegrationTests_1230, IntegrationTests_1240, IntegrationTests_1250, IntegrationTests_1260, IntegrationTests_1270, IntegrationTests_1280, IntegrationTests_1400, IntegrationTests_1410, IntegrationTests_1420, IntegrationTests_1430, IntegrationTests_1440, IntegrationTests_1500, IntegrationTests_1550, IntegrationTests_9999]
    timeout-minutes: 20
    steps:
    - name: NoOp
      shell: bash
      run: |
        echo "Successfully ran all E2E tests!"