weekly-feature-tagging.yaml

name: Feature Tagging

on:

  workflow_dispatch:
    inputs:
      features:
        type: string
        description: 'Comma-separated list of features to tag'
        default: 'cmd,task,change,ensure,endpoint,interface'
      maximum-reruns:
        type: number
        description: 'Maximum number of times to rerun failed spread tasks'
        default: 2
      run-one-system:
        type: string
        description: 'When set, will only run this system in spread'
      skip-tests:
        type: string
        description: 'Filters out all matches for each space-separated regex expression when running spread tests'
        default: 'ubuntu-14.04-64 tests/lib/ tests/unit/ manual/snapd-refresh-from-old core/persistent-journal'
  schedule:
    - cron: '30 4 * * 6'

jobs:
  set-inputs:
    runs-on: ubuntu-latest
    outputs:
      features: ${{ steps.set-inputs.outputs.features }}
      maximum-reruns: ${{ steps.set-inputs.outputs.maximum-reruns }}
      run-one-system: ${{ steps.set-inputs.outputs.run-one-system }}
      skip-tests: ${{ steps.set-inputs.outputs.skip-tests }}
    steps:
      - name: Set inputs
        id: set-inputs
        run: |
          echo "features=${{ inputs.features || 'cmd,task,change,ensure,endpoint,interface' }}" >> $GITHUB_OUTPUT
          echo "maximum-reruns=${{ inputs.maximum-reruns || 2 }}" >> $GITHUB_OUTPUT
          echo "run-one-system=${{ inputs.run-one-system || '' }}" >> $GITHUB_OUTPUT
          echo "skip-tests=${{ inputs.skip-tests || 'ubuntu-14.04-64 tests/lib/ tests/unit/ manual/snapd-refresh-from-old core/persistent-journal' }}" >> $GITHUB_OUTPUT

  read-systems:
    runs-on: ubuntu-latest
    needs: set-inputs
    outputs:
      fundamental-systems: ${{ steps.read-systems.outputs.fundamental-systems }}
      non-fundamental-systems: ${{ steps.read-systems.outputs.non-fundamental-systems }}
      nested-systems: ${{ steps.read-systems.outputs.nested-systems }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v6
      
      - name: Filter systems
        if: needs.set-inputs.outputs.run-one-system != ''
        run: |
          echo 'fundamental_systems=""' >> $GITHUB_ENV
          echo 'non_fundamental_systems=""' >> $GITHUB_ENV
          echo 'nested_systems=""' >> $GITHUB_ENV
          if grep -q "${{ needs.set-inputs.outputs.run-one-system }}" .github/workflows/data-fundamental-systems.json; then
            echo "fundamental_systems=$(jq -c ".include |= map(select(.systems == \"${{ needs.set-inputs.outputs.run-one-system }}\"))" .github/workflows/data-fundamental-systems.json)" >> $GITHUB_ENV
          elif grep -q "${{ needs.set-inputs.outputs.run-one-system }}" .github/workflows/data-non-fundamental-systems.json; then
            echo "non_fundamental_systems=$(jq -c ".include |= map(select(.systems == \"${{ needs.set-inputs.outputs.run-one-system }}\"))" .github/workflows/data-non-fundamental-systems.json)" >> $GITHUB_ENV
          elif grep -q "${{ needs.set-inputs.outputs.run-one-system }}" .github/workflows/data-nested-systems.json; then
            echo "nested_systems=$(jq -c ".include |= map(select(.systems == \"${{ needs.set-inputs.outputs.run-one-system }}\"))" .github/workflows/data-nested-systems.json)" >> $GITHUB_ENV
          fi
          
      - name: Read all systems
        if: needs.set-inputs.outputs.run-one-system == ''
        run: |
          echo "fundamental_systems=$(jq -c . ./.github/workflows/data-fundamental-systems.json)" >> $GITHUB_ENV
          echo "non_fundamental_systems=$(jq -c . ./.github/workflows/data-non-fundamental-systems.json)" >> $GITHUB_ENV
          echo "nested_systems=$(jq -c . ./.github/workflows/data-nested-systems.json)" >> $GITHUB_ENV

      - name: Read matrix file
        id: read-systems
        shell: bash
        run: |
          echo "fundamental-systems=$fundamental_systems" >> $GITHUB_OUTPUT
          echo "non-fundamental-systems=$non_fundamental_systems" >> $GITHUB_OUTPUT
          echo "nested-systems=$nested_systems" >> $GITHUB_OUTPUT

  tag-features-fundamental:
    uses: ./.github/workflows/spread-tests.yaml
    needs: [set-inputs, read-systems]
    name: "spread ${{ matrix.group }}"
    if: needs.read-systems.outputs.fundamental-systems != ''
    secrets: inherit
    with:
      runs-on: '${{ matrix.runs-on }}'
      group: ${{ matrix.group }}
      backend: ${{ matrix.backend }}
      systems: ${{ matrix.systems }}  
      tasks: ${{ matrix.tasks }}
      rules: ${{ matrix.rules }}
      is-fundamental: true
      use-snapd-snap-from-master: true
      spread-env: "SPREAD_TAG_FEATURES=1"
      upload-artifacts: true
      skip-tests: ${{ needs.set-inputs.outputs.skip-tests }}
    strategy:
      fail-fast: false
      matrix: ${{ fromJson(needs.read-systems.outputs.fundamental-systems) }}

  tag-features-non-fundamental:
    uses: ./.github/workflows/spread-tests.yaml
    needs: [set-inputs, read-systems]
    if: needs.read-systems.outputs.non-fundamental-systems != ''
    name: "spread ${{ matrix.group }}"
    secrets: inherit
    with:
      runs-on: '${{ matrix.runs-on }}'
      group: ${{ matrix.group }}
      backend: ${{ matrix.backend }}
      systems: ${{ matrix.systems }}  
      tasks: ${{ matrix.tasks }}
      rules: ${{ matrix.rules }}
      use-snapd-snap-from-master: true
      spread-env: "SPREAD_TAG_FEATURES=1"
      upload-artifacts: true
      skip-tests: ${{ needs.set-inputs.outputs.skip-tests }}
    strategy:
      fail-fast: false
      matrix: ${{ fromJson(needs.read-systems.outputs.non-fundamental-systems) }}

  tag-features-nested:
    uses: ./.github/workflows/spread-tests.yaml
    needs: [set-inputs, read-systems]
    if: needs.read-systems.outputs.nested-systems != ''
    name: "spread ${{ matrix.group }}"
    secrets: inherit
    with:
      runs-on: '${{ matrix.runs-on }}'
      group: ${{ matrix.group }}
      backend: ${{ matrix.backend }}
      systems: ${{ matrix.systems }}  
      tasks: ${{ matrix.tasks }}
      rules: ${{ matrix.rules }}
      use-snapd-snap-from-master: true
      spread-env: "SPREAD_TAG_FEATURES=1"
      upload-artifacts: true
      skip-tests: ${{ needs.set-inputs.outputs.skip-tests }}
    strategy:
      fail-fast: false
      matrix: ${{ fromJson(needs.read-systems.outputs.nested-systems) }}

  re-run:
    permissions:
      actions: write
    needs: [set-inputs, tag-features-fundamental, tag-features-non-fundamental, tag-features-nested]
    # If the spread tests ended in failure, rerun the workflow up to maximum-reruns times
    if: failure() && fromJSON(github.run_attempt) <= fromJSON(needs.set-inputs.outputs.maximum-reruns)
    runs-on: ubuntu-latest
    steps:
      - env:
          GH_REPO: ${{ github.repository }}
          GH_TOKEN: ${{ github.token }}
        run: gh workflow run rerun.yaml -F run_id=${{ github.run_id }}

  get-all-features:
    runs-on: ubuntu-latest
    if: always()
    steps:
      - name: Checkout code
        uses: actions/checkout@v6

      - name: Download snapd snap
        uses: ./.github/actions/download-snapd-snap
        with:
          use-master-push: true
          is-amd64: true
          is-arm64: false
          is-fips: false

      - name: Get all snapd features
        run: |
          sudo snap install built-snap/snapd_*.snap.keep --dangerous
          snap debug features > all-features.json

      - name: Upload snapd feature data
        uses: actions/upload-artifact@v5
        with:
          name: "all-features"
          path: "all-features.json"

  create-reports:
    needs: [set-inputs, tag-features-fundamental, tag-features-non-fundamental, tag-features-nested, get-all-features]
    runs-on: ["self-hosted", "spread-enabled"]
    if: |
      (always() && (needs.tag-features-fundamental.result == 'success' || needs.tag-features-fundamental.result == 'skipped')
      && (needs.tag-features-non-fundamental.result == 'success' || needs.tag-features-non-fundamental.result == 'skipped')
      && (needs.tag-features-nested.result == 'success' || needs.tag-features-nested.result == 'skipped')) 
      || fromJSON(github.run_attempt) > fromJSON(needs.set-inputs.outputs.maximum-reruns)
    steps:
      - name: Checkout code
        uses: actions/checkout@v6

      - name: Get generated data
        uses: actions/download-artifact@v6
        with:
          path: feature-tags-artifacts
          pattern: spread-artifacts-*
          merge-multiple: true

      - name: Get all features
        uses: actions/download-artifact@v6
        with:
          name: all-features

      - name: Create feature tags
        run: |
          shopt -s nullglob 
          
          featdir="extracted-tags"
          mkdir -p "$featdir"
          composedir="composed-tags"
          mkdir -p "$composedir"
          IFS=',' read -ra features <<< "${{ needs.set-inputs.outputs.features }}"
          for file in "feature-tags-artifacts"/*; do
            mkdir working
            tar -xzf "$file" -C working
            if ! [ -d "working/spread-artifacts/feature-tags" ]; then
              echo "Artifact $file has no artifact data"
              rm -r working
              continue
            fi
            for dir in "working/spread-artifacts/feature-tags"/*/; do
              if [ -f "${dir}/journal.txt" ] && [ -f "${dir}/state.json" ]; then
                ./tests/utils/features/featextractor.py \
                  -f "${features[@]}" \
                  --journal "${dir}/journal.txt" \
                  --state "${dir}/state.json" \
                  --output "$featdir/$(basename ${dir})"
              elif [ -f "${dir}/journal.txt" ] && [ ! -f "${dir}/state.json" ]; then
                ./tests/utils/features/featextractor.py \
                  -f "${features[@]}" \
                  --journal "${dir}/journal.txt" \
                  --output "$featdir/$(basename ${dir})"
              elif [ ! -f "${dir}/journal.txt" ]; then
                echo "No journal.txt present in $dir"
                exit 1
              fi
            done
            ./tests/utils/features/featcomposer.py \
                --dir "$featdir" \
                --output "$composedir" \
                --failed-tests "working/spread-artifacts/failed-tests.txt" \
                --run-attempt "$(cat "working/spread-artifacts/run-attempt.txt")" \
                --env-variables "$(cat "working/spread-artifacts/env-variables.txt")"
            rm -r working
          done
          ./tests/utils/features/featcomposer.py \
            --dir "$composedir" \
            --output "final-feature-tags" \
            --replace-old-runs

          for json in final-feature-tags/*; do
              if grep -qE "-nested.*04-64" <<<"$json"; then
                  version=${json#*ubuntu-}
                  version=${version%%.*}
                  core_file=$(find final-feature-tags -name "*ubuntu-core-$version-64*" || true)
                  if [ -n "$core_file" ]; then
                      echo "merging $json into $core_file"
                      jq -s '.[0].tests += .[1].tests | .[0]' "$core_file" "$json" > temp.json && mv temp.json "$core_file"
                      rm "$json"
                  fi
              fi
          done
          
          ./tests/utils/features/feattranslator.py -f all-features.json -o final-feature-tags/all-features.json

          tar -czf "final-feature-tags.tar.gz" "final-feature-tags"

      - name: Upload results to mongo
        env: 
          MONGO_USER: ${{ secrets.MONGO_USER }}
          MONGO_PASSWORD: ${{ secrets.MONGO_PASS }}
          MONGO_HOST: ${{ secrets.MONGO_HOST }}
          MONGO_PORT: ${{ secrets.MONGO_PORT }}
        run: ./tests/utils/features/mongo_upload.py --dir "final-feature-tags" --verbose
      
      - name: Upload feature data
        uses: actions/upload-artifact@v5
        with:
          name: "feature-tags"
          path: "final-feature-tags.tar.gz"