build.yaml

# This is a basic workflow to help you get started with Actions

name: CI_BUILD

# Controls when the action will run. Triggers the workflow on push
# events but only for the master branch
on:
  push:
    # only trigger on branches, not on tags
    branches: '**'
    paths-ignore:
      - 'docs/**'
  workflow_dispatch:
    inputs:
      UseLastRepositoryBuildJNet:
        description: 'Use latest NuGet packages from JNet'
        required: true
        default: false
        type: boolean
      UseLastRepositoryBuildKNet:
        description: 'Use latest NuGet packages from KNet'
        required: true
        default: false
        type: boolean

concurrency:
  group: '${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}'
  cancel-in-progress: true

# This workflow contains two jobs called "check_changes", "build_windows"
jobs:
  # Verify if a build is needed
  check_changes:
    name: Check changed files
    outputs:
      run_build_windows: ${{ steps.check_files.outputs.run_build_windows || steps.force_execute.outputs.run_build_windows }}
    runs-on: ubuntu-latest
    steps:
      - name: Force check on true
        id: force_execute
        if: ${{ github.event_name != 'push' }}
        run: echo "run_build_windows=true" >> $GITHUB_OUTPUT
      - name: Create modified file list
        id: get_changed_files
        if: ${{ github.event_name == 'push' }}
        uses: masesgroup/retrieve-changed-files@v3
        with:
          format: 'csv'
      - name: Check modified file list
        id: check_files
        if: ${{ github.event_name == 'push' }}
        run: |
          mapfile -d ',' -t added_modified_files < <(printf '%s,' '${{ steps.get_changed_files.outputs.added_modified }}')
          for added_modified_file in "${added_modified_files[@]}"; do
              if [[ $added_modified_file == ".github/workflows/build.yaml"* ]]; then
                echo "$added_modified_file is myself."
                echo "run_build_windows=true" >> $GITHUB_OUTPUT
                break
              fi
              if [[ $added_modified_file == "src/net/"* ]]; then
                echo "$added_modified_file file is under the directory 'src/'."
                echo "run_build_windows=true" >> $GITHUB_OUTPUT
                break
              fi
              if [[ $added_modified_file == "test/"* ]]; then
                echo "$added_modified_file file is under the directory 'src/'."
                echo "run_build_windows=true" >> $GITHUB_OUTPUT
                break
              fi
          done
      - name: Get run_build_windows
        run: echo "The selected run_build_windows is ${{ steps.check_files.outputs.run_build_windows || steps.force_execute.outputs.run_build_windows }}"

  # Now run "build_windows"
  build_windows:
    needs: check_changes
    if: "always() && needs.check_changes.outputs.run_build_windows == 'true'"
    # The type of runner that the job will run on
    runs-on: windows-2022

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:   
      # Runs a set of commands using the runners shell
      # Support longpaths
      - name: Support long paths
        run: git config --system core.longpaths true
    
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - uses: actions/checkout@v4
        with:
          fetch-depth: '1'
          submodules: 'true'

      - name: Get last workflow run of JNet
        if: ${{ inputs.UseLastRepositoryBuildJNet == true }}
        shell: bash
        run: echo "JNET_LAST_RUN=$(curl -sL https://api.github.com/repos/masesgroup/JNet/actions/workflows/build.yaml/runs | jq -r '.workflow_runs[0].id?')" >> $GITHUB_ENV

      - name: Download artifact
        if: ${{ inputs.UseLastRepositoryBuildJNet == true }}
        run: gh run download ${{ env.JNET_LAST_RUN }} --name JNetNuGet --repo masesgroup/JNet --dir JNetNuGet
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: List NuGet packages downloaded
        if: ${{ inputs.UseLastRepositoryBuildJNet == true }}
        continue-on-error: true
        shell: cmd
        run: dir .\JNetNuGet\*nupkg

      - name: Add local repo
        if: ${{ success() && inputs.UseLastRepositoryBuildJNet == true }}
        run: dotnet nuget add source --name localJNetNuGet "${{ github.workspace }}\JNetNuGet\"

      - name: Get last workflow run of KNet
        if: ${{ inputs.UseLastRepositoryBuildKNet == true }}
        shell: bash
        run: echo "KNET_LAST_RUN=$(curl -sL https://api.github.com/repos/masesgroup/KNet/actions/workflows/build.yaml/runs | jq -r '.workflow_runs[0].id?')" >> $GITHUB_ENV

      - name: Download KNetNuGet artifact
        if: ${{ inputs.UseLastRepositoryBuildKNet == true }}
        run: gh run download ${{ env.KNET_LAST_RUN }} --name KNetNuGet --repo masesgroup/KNet --dir KNetNuGet
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: List KNetNuGet packages downloaded
        if: ${{ inputs.UseLastRepositoryBuildKNet == true }}
        continue-on-error: true
        shell: cmd
        run: dir .\KNetNuGet\*nupkg

      - name: Add local repo
        if: ${{ success() && inputs.UseLastRepositoryBuildKNet == true }}
        run: dotnet nuget add source --name localKNetNuGet "${{ github.workspace }}\KNetNuGet\"

      - name: Recompile to create nuget packages
        run: dotnet build --no-incremental --configuration Release /p:Platform="Any CPU" src\net\KEFCore.sln

      - name: List NuGet packages to avoid download of artifact
        shell: cmd
        run: dir .\bin\*nupkg

      - uses: actions/upload-artifact@v4
        with:
          name: KEFCoreNuGet
          path: .\bin\*nupkg

      - name: Compile tests
        run: dotnet build --no-incremental --configuration Release /p:Platform="Any CPU" test\KEFCore.Test.sln

      - name: Prepare configuration files
        run: |
          Copy-Item .github\workflows\configuration\* -Destination bin\net6.0\ -Force
          Copy-Item .github\workflows\configuration\* -Destination bin\net8.0\ -Force

      - name: Save KEFCore net6.0 bin in cache
        uses: actions/cache/save@v4
        with:
          enableCrossOsArchive: true
          path: ./bin/net6.0/
          key: KEFCore_${{ github.run_number }}_${{ github.run_attempt }}_net6.0_bin_${{ github.sha }}
 
      - name: Save KEFCore net8.0 bin in cache
        uses: actions/cache/save@v4
        with:
          enableCrossOsArchive: true
          path: ./bin/net8.0/
          key: KEFCore_${{ github.run_number }}_${{ github.run_attempt }}_net8.0_bin_${{ github.sha }}
 
  execute_tests_linux:
    needs: build_windows
    services:
      kafka:
        # Private registry image
        image: ghcr.io/masesgroup/knet:latest # to be changed with official version when willbe available
        credentials:
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
        ports:
          - 9092:9092
        env:
          KNET_DOCKER_RUNNING_MODE: server
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}
          
    strategy:
      fail-fast: false
      matrix:
        serialization: [ 'Json', 'Protobuf', 'Avro' ]
        framework: [ 'net6.0', 'net8.0' ]
        jdk_vendor: [ 'temurin', 'zulu', 'microsoft', 'corretto', 'oracle']
        jdk_version: [ '11', '17', '21' ] # only LTS versions
        exclude:
          - jdk_vendor: oracle
            jdk_version: 11
        
    runs-on: 'ubuntu-latest'
    steps:
      - name: Restore KEFCore ${{ matrix.framework }} bin from cache
        uses: actions/cache/restore@v4
        with:
          fail-on-cache-miss: true
          enableCrossOsArchive: true
          path: ./bin/${{ matrix.framework }}/
          key: KEFCore_${{ github.run_number }}_${{ github.run_attempt }}_${{ matrix.framework }}_bin_${{ github.sha }}
 
      - name: Set up JDK distribution
        uses: actions/setup-java@v4
        with: # running setup-java again overwrites the settings.xml
          distribution: ${{ matrix.jdk_vendor }}
          java-version: ${{ matrix.jdk_version }}
          check-latest: true

      - name: Execute Benchmark.KNetReplicator on Ubuntu with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetReplicator.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetReplicator_Client_Crash_ubuntu-latest_${{ matrix.serialization }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KafkaStreams.Raw on Ubuntu with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KafkaStreams.Raw.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KafkaStreams.Raw_Client_Crash_ubuntu-latest_${{ matrix.serialization }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KafkaStreams.Buffered on Ubuntu with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KafkaStreams.Buffered.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KafkaStreams.Buffered_Client_Crash_ubuntu-latest_${{ matrix.serialization }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KNetStreams.Raw on Ubuntu with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetStreams.Raw.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Raw_Client_Crash_ubuntu-latest_${{ matrix.serialization }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7
         
      - name: Execute Benchmark.KNetStreams.Raw.Prefetch on Ubuntu with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetStreams.Raw.Prefetch.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Raw.Prefetch_Client_Crash_ubuntu-latest_${{ matrix.serialization }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KNetStreams.Buffered on Ubuntu with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetStreams.Buffered.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Buffered_Client_Crash_ubuntu-latest_${{ matrix.serialization }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KNetStreams.Buffered.Prefetch on Ubuntu with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetStreams.Buffered.Prefetch.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Buffered.Prefetch_Client_Crash_ubuntu-latest_${{ matrix.serialization }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7
         
  execute_tests_other:
    needs: build_windows
    strategy:
      fail-fast: false
      matrix:
        serialization: [ 'Json', 'Protobuf', 'Avro' ]
        os: [ 'macos-latest', 'macos-13' , 'windows-latest' ]
        framework: [ 'net6.0', 'net8.0' ]
        jdk_vendor: [ 'temurin', 'zulu', 'microsoft', 'corretto', 'oracle']
        jdk_version: [ '11', '17', '21' ] # only LTS versions
        exclude:
          - os: macos-latest
            framework: net6.0
          - os: macos-13
            framework: net6.0
          - jdk_vendor: oracle
            jdk_version: 11
        
    runs-on: ${{ matrix.os }}
    steps:
      - name: Restore KEFCore ${{ matrix.framework }} bin from cache
        uses: actions/cache/restore@v4
        with:
          fail-on-cache-miss: true
          enableCrossOsArchive: true
          path: ./bin/${{ matrix.framework }}/
          key: KEFCore_${{ github.run_number }}_${{ github.run_attempt }}_${{ matrix.framework }}_bin_${{ github.sha }}
 
      - name: Set up JDK distribution
        uses: actions/setup-java@v4
        with: # running setup-java again overwrites the settings.xml
          distribution: ${{ matrix.jdk_vendor }}
          java-version: ${{ matrix.jdk_version }}
          check-latest: true

      - name: Authenticate to GitHub
        run: dotnet nuget add source --username ${{ github.actor }} --password ${{ secrets.GITHUB_TOKEN }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/masesgroup/index.json"
        
      - name: Download latest published version of KNetCLI
        run: dotnet tool update -g MASES.KNetCLI

      - name: Start Kafka on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }}
        if: ${{ matrix.os != 'windows-latest' }}
        shell: pwsh
        run: |
          New-Item -Path "${{ github.workspace }}/" -Name "logfiles" -ItemType Directory
          Start-Process -RSE ${{ github.workspace }}/logfiles/PWSH_zookeeper_err.log -RSO ${{ github.workspace }}/logfiles/PWSH_zookeeper_out.log -FilePath knet -ArgumentList ( 'zookeeperstart', '-LogPath', '${{ github.workspace }}/logfiles/', '-Log4JConfiguration', '${{ github.workspace }}/bin/${{ matrix.framework }}/log4j.properties', '${{ github.workspace }}/bin/${{ matrix.framework }}/zookeeper.properties' )
          Start-Process -RSE ${{ github.workspace }}/logfiles/PWSH_kafka_err.log -RSO ${{ github.workspace }}/logfiles/PWSH_kafka_out.log -FilePath knet -ArgumentList ( 'kafkastart',  '-LogPath', '${{ github.workspace }}/logfiles/', '-Log4JConfiguration', '${{ github.workspace }}/bin/${{ matrix.framework }}/log4j.properties', '${{ github.workspace }}/bin/${{ matrix.framework }}/server.properties' )
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - name: Execute Benchmark.KNetReplicator on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os != 'windows-latest' }}
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetReplicator.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetReplicator_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetReplicator_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KafkaStreams.Raw on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os != 'windows-latest' }}
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KafkaStreams.Raw.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KafkaStreams.Raw_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KafkaStreams.Raw_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KafkaStreams.Buffered on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os != 'windows-latest' }}
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KafkaStreams.Buffered.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KafkaStreams.Buffered_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KafkaStreams.Buffered_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KNetStreams.Raw on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os != 'windows-latest' }}
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetStreams.Raw.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetStreams.Raw_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Raw_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KNetStreams.Raw.Prefetch on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os != 'windows-latest' }}
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetStreams.Raw.Prefetch.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetStreams.Raw.Prefetch_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Raw.Prefetch_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KNetStreams.Buffered on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os != 'windows-latest' }}
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetStreams.Buffered.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetStreams.Buffered_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Buffered_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: Execute Benchmark.KNetStreams.Buffered.Prefetch on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os != 'windows-latest' }}
        run: dotnet ${{ github.workspace }}/bin/${{ matrix.framework }}/MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}/bin/${{ matrix.framework }}/Benchmark.KNetStreams.Buffered.Prefetch.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetStreams.Buffered.Prefetch_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Buffered.Prefetch_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: WINDOWS ONLY - Start Kafka and execute Benchmark.KNetReplicator on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os == 'windows-latest' }}
        shell: pwsh
        run: |
          New-Item -Path "${{ github.workspace }}/" -Name "logfiles" -ItemType Directory
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_zookeeper_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_zookeeper_out.log -FilePath knet -ArgumentList ( 'zookeeperstart', '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\zookeeper.properties' )
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_kafka_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_kafka_out.log -FilePath knet -ArgumentList ( 'kafkastart',  '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\server.properties' )
          dotnet ${{ github.workspace }}\bin\${{ matrix.framework }}\MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}\bin\${{ matrix.framework }}\Benchmark.KNetReplicator.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetReplicator_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetReplicator_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: WINDOWS ONLY - Start Kafka and execute Benchmark.KafkaStreams.Raw on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os == 'windows-latest' }}
        shell: pwsh
        run: |
          Start-Sleep -Seconds 20
          Remove-Item ${{ github.workspace }}\logfiles\* -Recurse -Force
          Remove-Item D:\tmp\zookeeper\* -Recurse -Force
          Remove-Item D:\tmp\kafka-logs\* -Recurse -Force
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_zookeeper_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_zookeeper_out.log -FilePath knet -ArgumentList ( 'zookeeperstart', '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\zookeeper.properties' )
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_kafka_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_kafka_out.log -FilePath knet -ArgumentList ( 'kafkastart',  '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\server.properties' )
          dotnet ${{ github.workspace }}\bin\${{ matrix.framework }}\MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}\bin\${{ matrix.framework }}\Benchmark.KafkaStreams.Raw.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KafkaStreams.Raw_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KafkaStreams.Raw_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: WINDOWS ONLY - Start Kafka and execute Benchmark.KafkaStreams.Buffered on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os == 'windows-latest' }}
        shell: pwsh
        run: |
          Start-Sleep -Seconds 20
          Remove-Item ${{ github.workspace }}\logfiles\* -Recurse -Force
          Remove-Item D:\tmp\zookeeper\* -Recurse -Force
          Remove-Item D:\tmp\kafka-logs\* -Recurse -Force
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_zookeeper_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_zookeeper_out.log -FilePath knet -ArgumentList ( 'zookeeperstart', '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\zookeeper.properties' )
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_kafka_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_kafka_out.log -FilePath knet -ArgumentList ( 'kafkastart',  '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\server.properties' )
          dotnet ${{ github.workspace }}\bin\${{ matrix.framework }}\MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}\bin\${{ matrix.framework }}\Benchmark.KafkaStreams.Buffered.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KafkaStreams.Buffered_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KafkaStreams.Buffered_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: WINDOWS ONLY - Start Kafka and execute Benchmark.KNetStreams.Raw on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os == 'windows-latest' }}
        shell: pwsh
        run: |
          Start-Sleep -Seconds 20
          Remove-Item ${{ github.workspace }}\logfiles\* -Recurse -Force
          Remove-Item D:\tmp\zookeeper\* -Recurse -Force
          Remove-Item D:\tmp\kafka-logs\* -Recurse -Force
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_zookeeper_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_zookeeper_out.log -FilePath knet -ArgumentList ( 'zookeeperstart', '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\zookeeper.properties' )
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_kafka_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_kafka_out.log -FilePath knet -ArgumentList ( 'kafkastart',  '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\server.properties' )
          dotnet ${{ github.workspace }}\bin\${{ matrix.framework }}\MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}\bin\${{ matrix.framework }}\Benchmark.KNetStreams.Raw.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetStreams.Raw_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Raw_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: WINDOWS ONLY - Start Kafka and execute Benchmark.KNetStreams.Raw.Prefetch on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os == 'windows-latest' }}
        shell: pwsh
        run: |
          Start-Sleep -Seconds 20
          Remove-Item ${{ github.workspace }}\logfiles\* -Recurse -Force
          Remove-Item D:\tmp\zookeeper\* -Recurse -Force
          Remove-Item D:\tmp\kafka-logs\* -Recurse -Force
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_zookeeper_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_zookeeper_out.log -FilePath knet -ArgumentList ( 'zookeeperstart', '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\zookeeper.properties' )
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_kafka_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_kafka_out.log -FilePath knet -ArgumentList ( 'kafkastart',  '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\server.properties' )
          dotnet ${{ github.workspace }}\bin\${{ matrix.framework }}\MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}\bin\${{ matrix.framework }}\Benchmark.KNetStreams.Raw.Prefetch.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetStreams.Raw.Prefetch_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Raw.Prefetch_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: WINDOWS ONLY - Start Kafka and execute Benchmark.KNetStreams.Buffered on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os == 'windows-latest' }}
        shell: pwsh
        run: |
          Start-Sleep -Seconds 20
          Remove-Item ${{ github.workspace }}\logfiles\* -Recurse -Force
          Remove-Item D:\tmp\zookeeper\* -Recurse -Force
          Remove-Item D:\tmp\kafka-logs\* -Recurse -Force
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_zookeeper_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_zookeeper_out.log -FilePath knet -ArgumentList ( 'zookeeperstart', '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\zookeeper.properties' )
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_kafka_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_kafka_out.log -FilePath knet -ArgumentList ( 'kafkastart',  '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\server.properties' )
          dotnet ${{ github.workspace }}\bin\${{ matrix.framework }}\MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}\bin\${{ matrix.framework }}\Benchmark.KNetStreams.Buffered.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetStreams.Buffered_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Buffered_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

      - name: WINDOWS ONLY - Start Kafka and execute Benchmark.KNetStreams.Buffered.Prefetch on ${{ matrix.os }} with ${{ matrix.jdk_vendor }} ${{ matrix.jdk_version }} based on ${{ matrix.serialization }}
        continue-on-error: true
        if: ${{ matrix.os == 'windows-latest' }}
        shell: pwsh
        run: |
          Start-Sleep -Seconds 20
          Remove-Item ${{ github.workspace }}\logfiles\* -Recurse -Force
          Remove-Item D:\tmp\zookeeper\* -Recurse -Force
          Remove-Item D:\tmp\kafka-logs\* -Recurse -Force
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_zookeeper_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_zookeeper_out.log -FilePath knet -ArgumentList ( 'zookeeperstart', '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\zookeeper.properties' )
          Start-Process -RSE ${{ github.workspace }}\logfiles\PWSH_kafka_err.log -RSO ${{ github.workspace }}\logfiles\PWSH_kafka_out.log -FilePath knet -ArgumentList ( 'kafkastart',  '-LogPath', '${{ github.workspace }}\logfiles\', '-Log4JConfiguration', '${{ github.workspace }}\bin\${{ matrix.framework }}\log4j.properties', '${{ github.workspace }}\bin\${{ matrix.framework }}\server.properties' )
          dotnet ${{ github.workspace }}\bin\${{ matrix.framework }}\MASES.EntityFrameworkCore.KNet.Test.Benchmark.dll ${{ github.workspace }}\bin\${{ matrix.framework }}\Benchmark.KNetStreams.Buffered.Prefetch.json /p:Use${{ matrix.serialization }}=true
        env:
          JCOBRIDGE_LicensePath: ${{ secrets.JCOBRIDGE_ENCODED_2_5_17 }}

      - uses: actions/upload-artifact@v4
        if: ${{ failure() || cancelled() }}
        with:
          name: Benchmark.KNetStreams.Buffered.Prefetch_Server_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/logfiles/
          retention-days: 7

      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: Benchmark.KNetStreams.Buffered.Prefetch_Client_Crash_${{ matrix.serialization }}_${{ matrix.os }}_${{ matrix.framework }}_${{ matrix.jdk_vendor }}_${{ matrix.jdk_version }}
          path: ${{ github.workspace }}/**/hs_err_*
          retention-days: 7

  final_cleanup:
    needs: [ execute_tests_linux, execute_tests_other ]
    if: "always()"
    runs-on: ubuntu-latest
    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - uses: actions/checkout@v4
        with:
          fetch-depth: '1'

      - name: Clear caches
        run: |
          gh extension install actions/gh-actions-cache
          echo "Fetching list of cache key"
          cacheKeysForPR=$(gh actions-cache list --key KEFCore_${{ github.run_number }}_${{ github.run_attempt }} | cut -f 1 )
          ## Setting this to not fail the workflow while deleting cache keys.
          set +e
          echo "Deleting caches..."
          for cacheKey in $cacheKeysForPR
          do
              gh actions-cache delete $cacheKey --confirm
          done
          echo "Done"
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}