almalinux-compose-test-arm64.yml

name: almalinux-compose-test-arm64

on:
  workflow_dispatch:
      inputs:

        version_major:
          description: 'AlmaLinux major version'
          required: true
          default: '9'
          type: choice
          options:
            - 9
            - 8

        pungi_repository:
          description: 'Add pungi repositories'
          type: boolean

        pulp_repository:
          description: 'Add pulp repositories'
          type: boolean

        rerun_failed:
          description: 'Re-run failed tests'
          type: boolean
          default: true
jobs:

  start-runner:
    timeout-minutes: 10              # normally it only takes 1-2 minutes
    name: Setup and start self-hosted EC2 runner
    runs-on: ubuntu-latest
    permissions:
      actions: write
    steps:

      - name: Setup and start runner
        id: start-ec2-runner
        uses: NextChapterSoftware/ec2-action-builder@v1.5
        with:
          github_token: ${{ secrets.GIT_HUB_TOKEN }}
          aws_access_key_id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws_secret_access_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws_region: ${{ secrets.AWS_REGION }}
          ec2_ami_id: ${{ secrets[format('EC2_AMI_ID_AL{0}',  ( inputs.version_major == '10-kitten' && '10_KITTEN' || inputs.version_major))] }}
          ec2_subnet_id: ${{ secrets.EC2_SUBNET_ID}}
          ec2_security_group_id: ${{ secrets.EC2_SECURITY_GROUP_ID }}

          ec2_instance_type: t4g.small        # 2 vCPU and 2 GiM Memory are enought to run tests
          ec2_root_disk_size_gb: "16"         # override default size which is too small for actions and tests stuff
          ec2_root_disk_ebs_class: "gp3"      # use faster and cheeper storage instead of default 'gp2'
          ec2_instance_ttl: 60                # Optional (default is 60 minutes)
          ec2_spot_instance_strategy: None    # Other options are: SpotOnly, BestEffort, MaxPerformance
          ec2_instance_tags: >                # Required for IAM role resource permission scoping
            [
              {"Key": "Project", "Value": "GitHub Actions Self-hosted Runners"}
            ]

  compose-test:
    name: AlmaLinux ${{ inputs.version_major }}
    runs-on: ${{ github.run_id }}
    needs: start-runner # required to start the main job when the runner is ready

    steps:
    - uses: actions/checkout@v4

    - name: Prepare stuff
      run: |
        # Environment variables
        pungi_latest_result=latest_result
        pulp_root=${{ inputs.version_major }}
        tmt_options=
        rpm_gpg_key=/etc/pki/rpm-gpg/RPM-GPG-KEY-AlmaLinux
        vm_box=almalinux/${{ inputs.version_major }}
        release_version=${{ inputs.version_major }}
        dnf_crb_repo='CRB'

        case ${{ inputs.version_major }} in
          8)
            dnf_crb_repo='PowerTools'
            ;;
          9)
            tmt_options='--feeling-safe'
            rpm_gpg_key="${rpm_gpg_key}-9"
            ;;
          10-kitten)
            vm_box=lkhn/almalinux-kitten
            release_version=10
            pulp_root=kitten-10
            pungi_latest_result="${pungi_latest_result}_almalinux-kitten"
            tmt_options='--feeling-safe'
            rpm_gpg_key="${rpm_gpg_key}-10"
            ;;
        esac
        # Release major version
        echo "release_version=${release_version}" >> $GITHUB_ENV

        # Pulp repository root of the release
        echo "pulp_root=${pulp_root}" >> $GITHUB_ENV

        # Pungi repository latest results directory
        echo "pungi_latest_result=${pungi_latest_result}" >> $GITHUB_ENV

        # Name of repository to enable (PowerTools/CRB)
        if [ "x${{ inputs.pulp_repository }}" = "xtrue" ]; then
          # Lowercase the name for path in pulp's URL
          pulp_crb_repo="${dnf_crb_repo,,}"
        fi
        echo "dnf_crb_repo=${dnf_crb_repo}" >> $GITHUB_ENV
        echo "pulp_crb_repo=${pulp_crb_repo}" >> $GITHUB_ENV

        # TMT extra options
        echo "tmt_options=${tmt_options}" >> $GITHUB_ENV

        # RPM_GPG_KEY file
        echo "rpm_gpg_key=${rpm_gpg_key}" >> $GITHUB_ENV

        # TMT tests run directory
        echo "tmt_run_dir=/var/tmp/tmt/run-001" >> $GITHUB_ENV

    - name: Create AlmaLinux pungi repository
      if: inputs.pungi_repository
      run: |
        cat <<'EOF'>/etc/yum.repos.d/almalinux-pungi.repo
        [almalinux-${{ env.release_version }}-appstream-pungi]
        baseurl = http://aarch64-pungi-${{ env.release_version }}.almalinux.dev/almalinux/${{ env.release_version }}/$arch/${{ env.pungi_latest_result }}/compose/AppStream/$arch/os/
        enabled = 1
        name = almalinux-${{ env.release_version }}-appstream-pungi
        gpgkey=file://${{ env.rpm_gpg_key }}

        [almalinux-${{ env.release_version }}-baseos-pungi]
        baseurl = http://aarch64-pungi-${{ env.release_version }}.almalinux.dev/almalinux/${{ env.release_version }}/$arch/${{ env.pungi_latest_result }}/compose/BaseOS/$arch/os/
        enabled = 1
        name = almalinux-${{ env.release_version }}-baseos-pungi
        gpgkey=file://${{ env.rpm_gpg_key }}

        [almalinux-${{ env.release_version }}-${{ env.dnf_crb_repo }}-pungi]
        baseurl = http://aarch64-pungi-${{ env.release_version }}.almalinux.dev/almalinux/${{ env.release_version }}/$arch/${{ env.pungi_latest_result }}/compose/${{ env.dnf_crb_repo }}/$arch/os/
        enabled = 1
        name = almalinux-${{ env.release_version }}-${{ env.dnf_crb_repo }}-pungi
        gpgkey=file://${{ env.rpm_gpg_key }}
        EOF

    - name: Create AlmaLinux pulp repository
      if: inputs.pulp_repository
      run: |
        cat <<'EOF'>/etc/yum.repos.d/almalinux-pulp.repo
        [almalinux-${{ env.pulp_root }}-appstream-pulp]
        baseurl = https://build.almalinux.org/pulp/content/prod/almalinux-${{ env.pulp_root }}-appstream-$arch/
        enabled = 1
        name = almalinux-${{ env.pulp_root }}-appstream-pulp
        gpgkey=file://${{ env.rpm_gpg_key }}

        [almalinux-${{ env.pulp_root }}-baseos-pulp]
        baseurl = https://build.almalinux.org/pulp/content/prod/almalinux-${{ env.pulp_root }}-baseos-$arch/
        enabled = 1
        name = almalinux-${{ env.pulp_root }}-baseos-pulp
        gpgkey=file://${{ env.rpm_gpg_key }}

        [almalinux-${{ env.pulp_root }}-${{ env.pulp_crb_repo }}-pulp]
        baseurl = https://build.almalinux.org/pulp/content/prod/almalinux-${{ env.pulp_root }}-${{ env.pulp_crb_repo }}-$arch/
        enabled = 1
        name = almalinux-${{ env.pulp_root }}-${{ env.pulp_crb_repo }}-pulp
        gpgkey=file://${{ env.rpm_gpg_key }}
        EOF

    - name: Update the system
      run: |
        sudo dnf -y clean all
        sudo dnf -y update

    - name: Get system release
      run: |
        echo "system_release=$(cat /etc/almalinux-release)" >> $GITHUB_ENV

    - name: Prepare test infrastructure
      run: |
        enable_repo=${{ env.dnf_crb_repo }}
        case ${{ inputs.version_major }} in
          10-kitten*)
            sudo dnf install -y --enablerepo='extras-common' almalinux-kitten-release-devel
            sudo dnf install -y --enablerepo='${enable_repo,,} devel' python3-pip beakerlib
            sudo sh -c 'export PATH=$PATH:/usr/local/bin; pip install flexparser==0.3.1 tmt'
            ;;
          *)
            sudo dnf -y install epel-release
            sudo dnf install -y --enablerepo=${enable_repo,,} tmt
            ;;
        esac

        echo "[Debug] $(sudo sh -c 'export PATH=$PATH:/usr/local/bin; tmt --version')"

    - name: Run tests
      id: run-tests
      continue-on-error: true
      run: sudo sh -c 'export pungi_repository=${{ inputs.pungi_repository }}; export pulp_repository=${{ inputs.pulp_repository }}; export PATH=$PATH:/usr/local/bin; tmt -vvv -c distro=centos-stream-${{ env.release_version }} run --all provision --how=local ${{ env.tmt_options }}'

    - name: ${{ inputs.version_major }} tests results
      run: |
        #[Debug]
        sudo cat ${{ env.tmt_run_dir }}/plans/legacy/execute/results.yaml ${{ env.tmt_run_dir }}/plans/ng/execute/results.yaml

        sudo /bin/cp -av ${{ env.tmt_run_dir }}/plans/legacy/execute/results.yaml ${{github.action_path}}/legacy.results.yaml
        sudo /bin/cp -av ${{ env.tmt_run_dir }}/plans/ng/execute/results.yaml ${{github.action_path}}/ng.results.yaml

    - name: ${{ inputs.version_major }} tests log
      run: |
        #[Debug]
        sudo cat ${{ env.tmt_run_dir }}/log.txt

        sudo /bin/cp -av ${{ env.tmt_run_dir }}/log.txt ${{github.action_path}}/log.txt

    - name: ${{ inputs.version_major }} tests output
      run: |
        cd ${{ env.tmt_run_dir }}/
        tar cf ${{github.action_path}}/output.tar $( find . -name output.txt ) || true

    - uses: actions/upload-artifact@v4
      with:
        name: Tests log
        path: ${{github.action_path}}/log.txt

    - uses: actions/upload-artifact@v4
      with:
        name: Tests results
        path: ${{github.action_path}}/*.results.yaml

    - uses: actions/upload-artifact@v4
      with:
        name: Tests output
        path: ${{github.action_path}}/output.tar

    - name: Get list of failed tests
      if: job.steps.run-tests.status == failure()
      run: |
        # Install 'yq'
        sudo dnf -y -q install wget
        wget -q https://github.com/mikefarah/yq/releases/latest/download/yq_linux_arm64 -O /usr/bin/yq
        chmod +x /usr/bin/yq

        # Create failed tests list
        yq --no-doc '.[] | select(.result == "fail" or .result == "error") | .name' ${{ env.tmt_run_dir }}/plans/legacy/execute/results.yaml ${{ env.tmt_run_dir }}/plans/ng/execute/results.yaml \
          > ${{ env.tmt_run_dir }}/tests_failed.txt

        echo "[Debug] failed tests:"
        echo "$(cat ${{ env.tmt_run_dir }}/tests_failed.txt)"

    - name: Re-run failed tests, prepare tests summary
      if: job.steps.run-tests.status == failure()
      run: |
        # Tests results and the step exit code
        rerun_results=
        exit_code=0

        # Read failed tests list
        for test_failed in $(cat ${{ env.tmt_run_dir }}/tests_failed.txt | xargs); do
          echo "[Debug] Re-run '${test_failed}'"

          # Include failed test name into resiults summary
          test_result="${test_failed}"

          # Re-run specific failed test
          if [ "${{ inputs.rerun_failed }}" = "true" ]; then
            if sudo sh -c "export pungi_repository=${{ inputs.pungi_repository }}; export pulp_repository=${{ inputs.pulp_repository }}; export PATH=$PATH:/usr/local/bin; tmt -vvv -c distro=centos-stream-${{ env.release_version }} run --all provision --how=local ${{ env.tmt_options }} test --name ${test_failed}"; then
              test_result="${test_failed} [re-run ✅]"
            else
              test_result="${test_failed} [re-run ❌]"
              exit_code=1
            fi
          else
            echo "[Debug]"
            echo "If without re-run, fail this step as the '${test_failed}' test previously failed."
            exit_code=1
          fi

          # Format test results in list format: 'item1', 'item2', ...
          [ "x${rerun_results}" = "x" ] && rerun_results="'${test_result}'" || rerun_results="${rerun_results}, '${test_result}'"

        done

        # Export header and test results
        [ "x${rerun_results}" = "x" ] && summary_header="✅ All tests pass." || summary_header="❌ Failed tests:"
        echo "rerun_results=${rerun_results}" >> $GITHUB_ENV
        echo "summary_header=${summary_header}" >> $GITHUB_ENV

        exit $exit_code

    - name: Print tests summary
      if: job.steps.run-tests.status == failure() || failure()
      uses: actions/github-script@v7
      with:
        result-encoding: string
        script: |
          core.summary
              .addHeading('${{ env.system_release }}', '4')
              .addHeading('Used repositories:', '4')
              .addList(['pulp - ${{ inputs.pulp_repository && '✅' || '❌'}}','pungi - ${{ inputs.pungi_repository && '✅' || '❌'}}'], true)
              .addHeading('${{ env.summary_header }}', '4')
              .addList([${{ env.rerun_results }}], true)
              .write()