Update lib/spack/spack/build_systems/ctest.py

Co-authored-by: Chris White <white238@llnl.gov>

.github/workflows/audit.yaml

@@ -0,0 +1,73 @@
+name: audit
+
+on:
+  workflow_call:
+    inputs:
+      with_coverage:
+        required: true
+        type: string
+      python_version:
+        required: true
+        type: string
+
+concurrency:
+  group: audit-${{inputs.python_version}}-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
+  cancel-in-progress: true
+
+jobs:
+  # Run audits on all the packages in the built-in repository
+  package-audits:
+    runs-on: ${{ matrix.system.os }}
+    strategy:
+      matrix:
+        system:
+        - { os: windows-latest, shell: 'powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}' }
+        - { os: ubuntu-latest, shell: bash }
+        - { os: macos-latest, shell: bash }
+    defaults:
+      run:
+        shell: ${{ matrix.system.shell }}
+    steps:
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
+      with:
+        python-version: ${{inputs.python_version}}
+    - name: Install Python packages
+      run: |
+        pip install --upgrade pip setuptools pytest coverage[toml]
+    - name: Setup for Windows run
+      if: runner.os == 'Windows'
+      run: |
+        python -m pip install --upgrade pywin32
+    - name: Package audits (with coverage)
+      if: ${{ inputs.with_coverage == 'true' && runner.os != 'Windows' }}
+      run: |
+          . share/spack/setup-env.sh
+          coverage run $(which spack) audit packages
+          coverage run $(which spack) audit configs
+          coverage run $(which spack) -d audit externals
+          coverage combine
+          coverage xml
+    - name: Package audits (without coverage)
+      if: ${{ inputs.with_coverage == 'false' && runner.os != 'Windows' }}
+      run: |
+          . share/spack/setup-env.sh          
+          spack -d audit packages
+          spack -d audit configs
+          spack -d audit externals
+    - name: Package audits (without coverage)
+      if: ${{ runner.os == 'Windows' }}
+      run: |
+          . share/spack/setup-env.sh          
+          spack -d audit packages
+          ./share/spack/qa/validate_last_exit.ps1
+          spack -d audit configs
+          ./share/spack/qa/validate_last_exit.ps1
+          spack -d audit externals
+          ./share/spack/qa/validate_last_exit.ps1
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+      if: ${{ inputs.with_coverage == 'true' }}
+      with:
+        flags: unittests,audits
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true

.github/workflows/bootstrap.yml

@@ -0,0 +1,201 @@
+name: Bootstrapping
+
+on:
+  # This Workflow can be triggered manually
+  workflow_dispatch:
+  workflow_call:
+  schedule:
+    # nightly at 2:16 AM
+    - cron: '16 2 * * *'
+
+concurrency:
+  group: bootstrap-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
+  cancel-in-progress: true
+
+jobs:
+  distros-clingo-sources:
+    runs-on: ubuntu-latest
+    container: ${{ matrix.image }}
+    strategy:
+      matrix:
+        image: ["fedora:latest", "opensuse/leap:latest"]
+    steps:
+      - name: Setup Fedora
+        if: ${{ matrix.image == 'fedora:latest' }}
+        run: |
+          dnf install -y \
+              bzip2 curl file gcc-c++ gcc gcc-gfortran git gzip \
+              make patch unzip which xz python3 python3-devel tree \
+              cmake bison bison-devel libstdc++-static
+      - name: Setup OpenSUSE
+        if: ${{ matrix.image == 'opensuse/leap:latest' }}
+        run: |
+          # Harden CI by applying the workaround described here: https://www.suse.com/support/kb/doc/?id=000019505
+          zypper update -y || zypper update -y
+          zypper install -y \
+              bzip2 curl file gcc-c++ gcc gcc-fortran tar git gpg2 gzip \
+              make patch unzip which xz python3 python3-devel tree \
+              cmake bison
+      - name: Checkout
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        with:
+          fetch-depth: 0
+      - name: Bootstrap clingo
+        run: |
+          source share/spack/setup-env.sh
+          spack bootstrap disable github-actions-v0.5
+          spack bootstrap disable github-actions-v0.4
+          spack external find cmake bison
+          spack -d solve zlib
+          tree ~/.spack/bootstrap/store/
+
+  clingo-sources:
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        runner: ['macos-13', 'macos-14', "ubuntu-latest", "windows-latest"]
+    steps:
+      - name: Setup macOS
+        if: ${{ matrix.runner != 'ubuntu-latest' && matrix.runner != 'windows-latest' }}
+        run: |
+          brew install cmake bison tree
+      - name: Checkout
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
+        with:
+          python-version: "3.12"
+      - name: Bootstrap clingo
+        env:
+          SETUP_SCRIPT_EXT: ${{ matrix.runner == 'windows-latest' && 'ps1' || 'sh' }}
+          SETUP_SCRIPT_SOURCE: ${{ matrix.runner == 'windows-latest' && './' || 'source ' }}
+          USER_SCOPE_PARENT_DIR: ${{ matrix.runner == 'windows-latest' && '$env:userprofile' || '$HOME' }}
+          VALIDATE_LAST_EXIT: ${{ matrix.runner == 'windows-latest' && './share/spack/qa/validate_last_exit.ps1' || '' }}
+        run: |
+          ${{ env.SETUP_SCRIPT_SOURCE }}share/spack/setup-env.${{ env.SETUP_SCRIPT_EXT }}
+          spack bootstrap disable github-actions-v0.5
+          spack bootstrap disable github-actions-v0.4
+          spack external find --not-buildable cmake bison
+          spack -d solve zlib
+          ${{ env.VALIDATE_LAST_EXIT }}
+          tree ${{ env.USER_SCOPE_PARENT_DIR }}/.spack/bootstrap/store/
+
+  gnupg-sources:
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        runner: [ 'macos-13', 'macos-14', "ubuntu-latest" ]
+    steps:
+      - name: Setup macOS
+        if: ${{ matrix.runner != 'ubuntu-latest' }}
+        run: |
+          brew install tree gawk
+          sudo rm -rf $(command -v gpg gpg2)
+      - name: Setup Ubuntu
+        if: ${{ matrix.runner == 'ubuntu-latest' }}
+        run: sudo rm -rf $(command -v gpg gpg2 patchelf)
+      - name: Checkout
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        with:
+          fetch-depth: 0
+      - name: Bootstrap GnuPG
+        run: |
+          source share/spack/setup-env.sh
+          spack solve zlib
+          spack bootstrap disable github-actions-v0.5
+          spack bootstrap disable github-actions-v0.4
+          spack -d gpg list
+          tree ~/.spack/bootstrap/store/
+
+  from-binaries:
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        runner: ['macos-13', 'macos-14', "ubuntu-latest", "windows-latest"]
+    steps:
+      - name: Setup macOS
+        if: ${{ matrix.runner != 'ubuntu-latest' && matrix.runner != 'windows-latest'}}
+        run: |
+          brew install tree
+          # Remove GnuPG since we want to bootstrap it
+          sudo rm -rf /usr/local/bin/gpg
+      - name: Setup Ubuntu
+        if: ${{ matrix.runner == 'ubuntu-latest' }}
+        run: |
+          sudo rm -rf $(which gpg) $(which gpg2) $(which patchelf)
+      - name: Setup Windows
+        if: ${{ matrix.runner == 'windows-latest' }}
+        run: |
+          Remove-Item -Path (Get-Command gpg).Path
+          Remove-Item -Path (Get-Command file).Path
+      - name: Checkout
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
+        with:
+          python-version: |
+            3.8
+            3.9
+            3.10
+            3.11
+            3.12
+      - name: Set bootstrap sources
+        env:
+          SETUP_SCRIPT_EXT: ${{ matrix.runner == 'windows-latest' && 'ps1' || 'sh' }}
+          SETUP_SCRIPT_SOURCE: ${{ matrix.runner == 'windows-latest' && './' || 'source ' }}
+        run: |
+          ${{ env.SETUP_SCRIPT_SOURCE }}share/spack/setup-env.${{ env.SETUP_SCRIPT_EXT }}
+          spack bootstrap disable github-actions-v0.4
+      - name: Disable from source bootstrap
+        if: ${{ matrix.runner != 'windows-latest' }}
+        run: |
+          source share/spack/setup-env.sh
+          spack bootstrap disable spack-install
+      - name: Bootstrap clingo
+        # No binary clingo on Windows yet
+        if: ${{ matrix.runner != 'windows-latest' }}
+        run: |
+          set -e
+          for ver in '3.8' '3.9' '3.10' '3.11' '3.12' ; do
+            not_found=1
+            ver_dir="$(find $RUNNER_TOOL_CACHE/Python -wholename "*/${ver}.*/*/bin" | grep . || true)"
+            if [[ -d "$ver_dir" ]] ; then
+              echo "Testing $ver_dir"
+              if $ver_dir/python --version ; then
+                export PYTHON="$ver_dir/python"
+                not_found=0
+                old_path="$PATH"
+                export PATH="$ver_dir:$PATH"
+                ./bin/spack-tmpconfig -b ./.github/workflows/bin/bootstrap-test.sh
+                export PATH="$old_path"
+              fi
+            fi
+            if (($not_found)) ; then
+              echo Required python version $ver not found in runner!
+              exit 1
+            fi
+          done
+      - name: Bootstrap GnuPG
+        env:
+          SETUP_SCRIPT_EXT: ${{ matrix.runner == 'windows-latest' && 'ps1' || 'sh' }}
+          SETUP_SCRIPT_SOURCE: ${{ matrix.runner == 'windows-latest' && './' || 'source ' }}
+          USER_SCOPE_PARENT_DIR: ${{ matrix.runner == 'windows-latest' && '$env:userprofile' || '$HOME' }}
+          VALIDATE_LAST_EXIT: ${{ matrix.runner == 'windows-latest' && './share/spack/qa/validate_last_exit.ps1' || '' }}
+        run: |
+          ${{ env.SETUP_SCRIPT_SOURCE }}share/spack/setup-env.${{ env.SETUP_SCRIPT_EXT }}
+          spack -d gpg list
+          ${{ env.VALIDATE_LAST_EXIT }}
+          tree ${{ env.USER_SCOPE_PARENT_DIR }}/.spack/bootstrap/store/
+      - name: Bootstrap File
+        env:
+          SETUP_SCRIPT_EXT: ${{ matrix.runner == 'windows-latest' && 'ps1' || 'sh' }}
+          SETUP_SCRIPT_SOURCE: ${{ matrix.runner == 'windows-latest' && './' || 'source ' }}
+          USER_SCOPE_PARENT_DIR: ${{ matrix.runner == 'windows-latest' && '$env:userprofile' || '$HOME' }}
+          VALIDATE_LAST_EXIT: ${{ matrix.runner == 'windows-latest' && './share/spack/qa/validate_last_exit.ps1' || '' }}
+        run: |
+          ${{ env.SETUP_SCRIPT_SOURCE }}share/spack/setup-env.${{ env.SETUP_SCRIPT_EXT }}
+          spack -d python share/spack/qa/bootstrap-file.py
+          ${{ env.VALIDATE_LAST_EXIT }}
+          tree ${{ env.USER_SCOPE_PARENT_DIR }}/.spack/bootstrap/store/

.github/workflows/build-containers.yml

@@ -0,0 +1,133 @@
+name: Containers
+
+on:
+  # This Workflow can be triggered manually
+  workflow_dispatch:
+  # Build new Spack develop containers nightly.
+  schedule:
+    - cron: '34 0 * * *'
+  # Run on pull requests that modify this file
+  pull_request:
+    branches:
+      - develop
+    paths:
+      - '.github/workflows/build-containers.yml'
+      - 'share/spack/docker/*'
+      - 'share/spack/templates/container/*'
+      - 'lib/spack/spack/container/*'
+  # Let's also build & tag Spack containers on releases.
+  release:
+    types: [published]
+
+concurrency:
+  group: build_containers-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
+  cancel-in-progress: true
+
+jobs:
+  deploy-images:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    strategy:
+      # Even if one container fails to build we still want the others
+      # to continue their builds.
+      fail-fast: false
+      # A matrix of Dockerfile paths, associated tags, and which architectures
+      # they support.
+      matrix:
+        # Meaning of the various items in the matrix list
+        # 0: Container name (e.g. ubuntu-bionic)
+        # 1: Platforms to build for
+        # 2: Base image (e.g. ubuntu:22.04)
+        dockerfile: [[amazon-linux, 'linux/amd64,linux/arm64', 'amazonlinux:2'],
+                     [centos-stream9, 'linux/amd64,linux/arm64,linux/ppc64le', 'centos:stream9'],
+                     [leap15, 'linux/amd64,linux/arm64,linux/ppc64le', 'opensuse/leap:15'],
+                     [ubuntu-focal, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:20.04'],
+                     [ubuntu-jammy, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:22.04'],
+                     [ubuntu-noble, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:24.04'],
+                     [almalinux8, 'linux/amd64,linux/arm64,linux/ppc64le', 'almalinux:8'],
+                     [almalinux9, 'linux/amd64,linux/arm64,linux/ppc64le', 'almalinux:9'],
+                     [rockylinux8, 'linux/amd64,linux/arm64', 'rockylinux:8'],
+                     [rockylinux9, 'linux/amd64,linux/arm64', 'rockylinux:9'],
+                     [fedora39, 'linux/amd64,linux/arm64,linux/ppc64le', 'fedora:39'],
+                     [fedora40, 'linux/amd64,linux/arm64,linux/ppc64le', 'fedora:40']]
+    name: Build ${{ matrix.dockerfile[0] }}
+    if: github.repository == 'spack/spack'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+
+      - uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81
+        id: docker_meta
+        with:
+          images: |
+              ghcr.io/${{ github.repository_owner }}/${{ matrix.dockerfile[0] }}
+              ${{ github.repository_owner }}/${{ matrix.dockerfile[0] }}
+          tags: |
+              type=schedule,pattern=nightly
+              type=schedule,pattern=develop
+              type=semver,pattern={{version}}
+              type=semver,pattern={{major}}.{{minor}}
+              type=semver,pattern={{major}}
+              type=ref,event=branch
+              type=ref,event=pr
+
+      - name: Generate the Dockerfile
+        env:
+          SPACK_YAML_OS: "${{ matrix.dockerfile[2] }}"
+        run: |
+          .github/workflows/bin/generate_spack_yaml_containerize.sh
+          . share/spack/setup-env.sh
+          mkdir -p dockerfiles/${{ matrix.dockerfile[0] }}
+          spack containerize --last-stage=bootstrap | tee dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile
+          printf "Preparing to build ${{ env.container }} from dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile"
+          if [ ! -f "dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile" ]; then
+              printf "dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile does not exist"
+              exit 1;
+          fi
+
+      - name: Upload Dockerfile
+        uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874
+        with:
+          name: dockerfiles_${{ matrix.dockerfile[0] }}
+          path: dockerfiles
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@49b3bc8e6bdd4a60e6116a5414239cba5943d3cf
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Log in to DockerHub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build & Deploy ${{ matrix.dockerfile[0] }}
+        uses: docker/build-push-action@5cd11c3a4ced054e52742c5fd54dca954e0edd85
+        with:
+          context: dockerfiles/${{ matrix.dockerfile[0] }}
+          platforms: ${{ matrix.dockerfile[1] }}
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.docker_meta.outputs.tags }}
+          labels: ${{ steps.docker_meta.outputs.labels }}
+
+  merge-dockerfiles:
+    runs-on: ubuntu-latest
+    needs: deploy-images
+    steps:
+      - name: Merge Artifacts
+        uses: actions/upload-artifact/merge@50769540e7f4bd5e21e526ee35c689e35e0d6874
+        with:
+          name: dockerfiles
+          pattern: dockerfiles_*
+          delete-merged: true

.github/workflows/ci.yaml

@@ -74,3 +74,19 @@ jobs:
       # job outputs: https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#jobsjob_idoutputs
       # setting environment variables from earlier steps: https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-environment-variable
       #
+  bootstrap:
+    if: ${{ github.repository == 'spack/spack' && needs.changes.outputs.bootstrap == 'true' }}
+    needs: [ prechecks, changes ]
+    uses: ./.github/workflows/bootstrap.yml
+    secrets: inherit
+  unit-tests:
+    if: ${{ github.repository == 'spack/spack' && needs.changes.outputs.core == 'true' }}
+    needs: [ prechecks, changes ]
+    uses: ./.github/workflows/unit_tests.yaml
+    secrets: inherit
+  all:
+    needs: [ unit-tests, bootstrap ]
+    runs-on: ubuntu-latest
+    steps:
+    - name: Success
+      run: "true"

.github/workflows/nightly-win-builds.yml

@@ -0,0 +1,31 @@
+name: Windows Paraview Nightly
+
+on:
+  schedule:
+    - cron: '0 2 * * *' # Run at 2 am
+
+defaults:
+  run:
+    shell:
+     powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}
+
+
+jobs:
+  build-paraview-deps:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
+      with:
+        python-version: 3.9
+    - name: Install Python packages
+      run: |
+          python -m pip install --upgrade pip six pywin32 setuptools coverage
+    - name: Build Test
+      run: |
+        spack compiler find
+        spack external find cmake ninja win-sdk win-wdk wgl msmpi
+        spack -d install -y --cdash-upload-url https://cdash.spack.io/submit.php?project=Spack+on+Windows --cdash-track Nightly --only dependencies paraview
+        exit 0

.github/workflows/unit_tests.yaml

@@ -0,0 +1,247 @@
+name: unit tests
+
+on:
+  workflow_dispatch:
+  workflow_call:
+
+concurrency:
+  group: unit_tests-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
+  cancel-in-progress: true
+
+jobs:
+  # Run unit tests with different configurations on linux
+  ubuntu:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12']
+        on_develop:
+        - ${{ github.ref == 'refs/heads/develop' }}
+        include:
+        - python-version: '3.6'
+          os: ubuntu-20.04
+          on_develop: ${{ github.ref == 'refs/heads/develop' }}
+        exclude:
+        - python-version: '3.7'
+          os: ubuntu-latest
+          on_develop: false
+        - python-version: '3.8'
+          os: ubuntu-latest
+          on_develop: false
+        - python-version: '3.9'
+          os: ubuntu-latest
+          on_develop: false
+        - python-version: '3.10'
+          os: ubuntu-latest
+          on_develop: false
+        - python-version: '3.11'
+          os: ubuntu-latest
+          on_develop: false
+
+    steps:
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install System packages
+      run: |
+          sudo apt-get -y update
+          # Needed for unit tests
+          sudo apt-get -y install \
+              coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build \
+              cmake bison libbison-dev kcov
+    - name: Install Python packages
+      run: |
+          pip install --upgrade pip setuptools pytest pytest-xdist pytest-cov
+          pip install --upgrade flake8 "isort>=4.3.5" "mypy>=0.900" "click" "black"
+    - name: Setup git configuration
+      run: |
+          # Need this for the git tests to succeed.
+          git --version
+          . .github/workflows/bin/setup_git.sh
+    - name: Bootstrap clingo
+      if: ${{ matrix.concretizer == 'clingo' }}
+      env:
+          SPACK_PYTHON: python
+      run: |
+          . share/spack/setup-env.sh
+          spack bootstrap disable spack-install
+          spack bootstrap now
+          spack -v solve zlib
+    - name: Run unit tests
+      env:
+          SPACK_PYTHON: python
+          SPACK_TEST_PARALLEL: 2
+          COVERAGE: true
+          UNIT_TEST_COVERAGE: ${{ matrix.python-version == '3.11' }}
+      run: |
+          share/spack/qa/run-unit-tests
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+      with:
+        flags: unittests,linux,${{ matrix.concretizer }}
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true
+  # Test shell integration
+  shell:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
+      with:
+        python-version: '3.11'
+    - name: Install System packages
+      run: |
+          sudo apt-get -y update
+          # Needed for shell tests
+          sudo apt-get install -y coreutils kcov csh zsh tcsh fish dash bash
+    - name: Install Python packages
+      run: |
+          pip install --upgrade pip setuptools pytest coverage[toml] pytest-xdist
+    - name: Setup git configuration
+      run: |
+          # Need this for the git tests to succeed.
+          git --version
+          . .github/workflows/bin/setup_git.sh
+    - name: Run shell tests
+      env:
+          COVERAGE: true
+      run: |
+          share/spack/qa/run-shell-tests
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+      with:
+        flags: shelltests,linux
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true
+
+  # Test RHEL8 UBI with platform Python. This job is run
+  # only on PRs modifying core Spack
+  rhel8-platform-python:
+    runs-on: ubuntu-latest
+    container: registry.access.redhat.com/ubi8/ubi
+    steps:
+    - name: Install dependencies
+      run: |
+          dnf install -y \
+              bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
+              make patch tcl unzip which xz
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - name: Setup repo and non-root user
+      run: |
+          git --version
+          git config --global --add safe.directory /__w/spack/spack
+          git fetch --unshallow
+          . .github/workflows/bin/setup_git.sh
+          useradd spack-test
+          chown -R spack-test .
+    - name: Run unit tests
+      shell: runuser -u spack-test -- bash {0}
+      run: |
+          source share/spack/setup-env.sh
+          spack -d bootstrap now --dev
+          spack unit-test -k 'not cvs and not svn and not hg' -x --verbose
+  # Test for the clingo based solver (using clingo-cffi)
+  clingo-cffi:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
+      with:
+        python-version: '3.11'
+    - name: Install System packages
+      run: |
+          sudo apt-get -y update
+          sudo apt-get -y install coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build kcov
+    - name: Install Python packages
+      run: |
+          pip install --upgrade pip setuptools pytest coverage[toml] pytest-cov clingo pytest-xdist
+          pip install --upgrade flake8 "isort>=4.3.5" "mypy>=0.900" "click" "black"
+    - name: Setup git configuration
+      run: |
+          # Need this for the git tests to succeed.
+          git --version
+          . .github/workflows/bin/setup_git.sh
+    - name: Run unit tests (full suite with coverage)
+      env:
+          COVERAGE: true
+      run: |
+          share/spack/qa/run-unit-tests
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+      with:
+        flags: unittests,linux,clingo
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true
+  # Run unit tests on MacOS
+  macos:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-13, macos-14]
+        python-version: ["3.11"]
+    steps:
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install Python packages
+      run: |
+          pip install --upgrade pip setuptools
+          pip install --upgrade pytest coverage[toml] pytest-xdist pytest-cov
+    - name: Setup Homebrew packages
+      run: |
+        brew install dash fish gcc gnupg2 kcov
+    - name: Run unit tests
+      env:
+        SPACK_TEST_PARALLEL: 4
+      run: |
+        git --version
+        . .github/workflows/bin/setup_git.sh
+        . share/spack/setup-env.sh
+        $(which spack) bootstrap disable spack-install
+        $(which spack) solve zlib
+        common_args=(--dist loadfile --tx '4*popen//python=./bin/spack-tmpconfig python -u ./bin/spack python' -x)
+        $(which spack) unit-test --verbose --cov --cov-config=pyproject.toml --cov-report=xml:coverage.xml "${common_args[@]}"
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+      with:
+        flags: unittests,macos
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true
+  # Run unit tests on Windows
+  windows:
+    defaults:
+      run:
+        shell:
+          powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
+      with:
+        python-version: 3.9
+    - name: Install Python packages
+      run: |
+          python -m pip install --upgrade pip pywin32 setuptools pytest-cov clingo
+    - name: Create local develop
+      run: |
+        ./.github/workflows/bin/setup_git.ps1
+    - name: Unit Test
+      run: |
+        spack unit-test -x --verbose --cov --cov-config=pyproject.toml
+        ./share/spack/qa/validate_last_exit.ps1
+        coverage combine -a
+        coverage xml
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+      with:
+        flags: unittests,windows
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true

.github/workflows/valid-style.yml

@@ -54,4 +54,36 @@ jobs:
     - name: Run style tests
       run: |
           share/spack/qa/run-style-tests
-
+  audit:
+    uses: ./.github/workflows/audit.yaml
+    secrets: inherit
+    with:
+      with_coverage: ${{ inputs.with_coverage }}
+      python_version: '3.11'
+  # Check that spack can bootstrap the development environment on Python 3.6 - RHEL8
+  bootstrap-dev-rhel8:
+    runs-on: ubuntu-latest
+    container: registry.access.redhat.com/ubi8/ubi
+    steps:
+      - name: Install dependencies
+        run: |
+          dnf install -y \
+              bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
+              make patch tcl unzip which xz
+      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+      - name: Setup repo and non-root user
+        run: |
+          git --version
+          git config --global --add safe.directory /__w/spack/spack
+          git fetch --unshallow
+          . .github/workflows/bin/setup_git.sh
+          useradd spack-test
+          chown -R spack-test .
+      - name: Bootstrap Spack development environment
+        shell: runuser -u spack-test -- bash {0}
+        run: |
+          source share/spack/setup-env.sh
+          spack debug report
+          spack -d bootstrap now --dev
+          spack style -t black
+          spack unit-test -V

lib/spack/spack/build_systems/ctest.py

@@ -0,0 +1,192 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import glob
+import importlib
+import inspect
+import os
+import shutil
+import time
+
+import llnl.util.filesystem as fs
+import llnl.util.tty as tty
+
+import spack.build_systems.cmake
+import spack.builder
+import spack.util.log_parse
+from spack.builder import run_after
+from spack.directives import depends_on, requires, variant
+from spack.package import CMakePackage
+
+
+class CTestBuilder(spack.build_systems.cmake.CMakeBuilder):
+    """
+    This builder mirrors the behavior of a CMakeBuilder, but all commands are run through
+    CTest. This ensures that xml files are created through CTest.  This provides a unified
+    buildstamp and improved xml over the spack generated ones.
+
+    An additional phase is added for running tests post installation.  This allows for things
+    like regression tests that can be used to monitior differences in behavior/performance
+    without failing the install.
+    """
+
+    phases = ("cmake", "build", "install", "analysis")
+
+    @property
+    def std_cmake_args(self):
+        """
+        Args to always supply to CMake. CDash args don't do anything if you don't submit
+
+        TODO: workout how to get the track,build,site mapped correctly
+        Currently this ignores the spack flags, and injests the CTestConfig.cmake files
+
+        In ExaWind it is hooked into additional infrastrucure.
+        The spack flags are not ingestible to the package as far as I can currently tell.
+        """
+        args = super().std_cmake_args
+        if self.spec.variants["cdash_submit"].value:
+            args.extend(
+                [
+                    "-D",
+                    f"BUILDNAME={self.pkg.spec.name}",
+                    "-D",
+                    f"CTEST_BUILD_OPTIONS={self.pkg.spec.short_spec}",
+                    "-D",
+                    "SITE=TODO",
+                ]
+            )
+        return args
+
+    def ctest_args(self):
+        args = ["-T", "Test"]
+        args.append("--stop-time")
+        overall_test_timeout = 60 * 60 * 4  # 4 hours TODO should probably be a variant
+        args.append(time.strftime("%H:%M:%S", time.localtime(time.time() + overall_test_timeout)))
+        args.append("-VV")  # make sure lots of output can go to the log
+        # a way to parse additional information to ctest exectution.
+        # for ecample in exawind, we default to running unit-tests, but for nightly tests
+        # we expand to our regression test suite through this variant
+        extra_args = self.pkg.spec.variants["ctest_args"].value
+        if extra_args:
+            args.extend(extra_args.split())
+        return args
+
+    @property
+    def build_args(self):
+        """
+        CTest arguments that translate to running a to the end of the build phase through CTest
+        """
+        args = [
+            "--group",
+            self.pkg.spec.name,
+            "-T",
+            "Start",
+            "-T",
+            "Configure",
+            "-T",
+            "Build",
+            "-VV",
+        ]
+        return args
+
+    @property
+    def submit_args(self):
+        """
+        CTest arguments just for sumbmission.  Allows us to split phases, where default CTest behavior is to configure, build, test and submit from a single command.
+        """
+        args = ["-T", "Submit", "-V"]
+        return args
+
+    def submit_cdash(self, pkg, spec, prefix):
+        ctest = Executable(self.spec["cmake"].prefix.bin.ctest)
+        ctest.add_default_env("CTEST_PARALLEL_LEVEL", str(make_jobs))
+        build_env = os.environ.copy()
+        ctest(*self.submit_args, env=build_env)
+
+    def build(self, pkg, spec, prefix):
+        """
+        The only reason to run through the CTest interface is if we want to submit to CDash with
+        unified CTest xml's.
+        If we aren't going to submit then we can just run as the CMakeBuilder
+        """
+        if self.pkg.spec.variants["cdash_submit"].value:
+            ctest = Executable(self.spec["cmake"].prefix.bin.ctest)
+            ctest.add_default_env("CMAKE_BUILD_PARALLEL_LEVEL", str(make_jobs))
+            with fs.working_dir(self.build_directory):
+                build_env = os.environ.copy()
+                # have ctest run, but we still want to submit if there are build failures where spack would stop.
+                # check for errors and submit to cdash if there are failures
+                output = ctest(
+                    *self.build_args, env=build_env, output=str.split, error=str.split
+                ).split("\n")
+                errors, warnings = spack.util.log_parse.parse_log_events(output)
+                if len(errors) > 0:
+                    errs = [str(e) for e in errors]
+                    tty.warn(f"Errors: {errs}")
+                    tty.warn(f"returncode {ctest.returncode}")
+                    self.submit_cdash(pkg, spec, prefix)
+                    raise BaseException(f"{self.pkg.spec.name} had build errors")
+
+        else:
+            super().build(pkg, spec, prefix)
+
+    def analysis(self, pkg, spec, prefix):
+        """
+        This method currently runs tests post install to avoid the undesired side effect
+        of failing installs for failed tests with spack's built in testing infrastructure
+        """
+
+        with working_dir(self.build_directory):
+            args = self.ctest_args()
+            tty.debug("{} running CTest".format(self.pkg.spec.name))
+            tty.debug("Running:: ctest" + " ".join(args))
+            ctest = Executable(self.spec["cmake"].prefix.bin.ctest)
+            ctest.add_default_env("CTEST_PARALLEL_LEVEL", str(make_jobs))
+            ctest.add_default_env("CMAKE_BUILD_PARALLEL_LEVEL", str(make_jobs))
+            build_env = os.environ.copy()
+            ctest(*args, "-j", str(make_jobs), env=build_env, fail_on_error=False)
+
+            if self.pkg.spec.variants["cdash_submit"].value:
+                self.submit_cdash(pkg, spec, prefix)
+
+
+class CtestPackage(CMakePackage):
+    """
+    This package's default behavior is to act as a Standard CMakePackage,
+    """
+
+    CMakeBuilder = CTestBuilder
+    variant("cdash_submit", default=False, description="Submit results to cdash")
+    variant("ctest_args", default="", description="quoted string of arguments to send to ctest")
+
+    def setup_build_environment(self, env):
+        env.prepend_path("PYTHONPATH", os.environ["EXAWIND_MANAGER"])
+
+    def do_clean(self):
+        """
+        A nice feature for development builds.  Can be omitted from the final product.
+        """
+        super().do_clean()
+        if not self.stage.managed_by_spack:
+            build_artifacts = glob.glob(os.path.join(self.stage.source_path, "spack-*"))
+            for f in build_artifacts:
+                if os.path.isfile(f):
+                    os.remove(f)
+                if os.path.isdir(f):
+                    shutil.rmtree(f)
+            ccjson = os.path.join(self.stage.source_path, "compile_commands.json")
+
+            if os.path.isfile(ccjson):
+                os.remove(ccjson)
+
+    @run_after("cmake")
+    def copy_compile_commands(self):
+        """
+        A nice feature for development builds.  Can be omitted from the final product.
+        """
+        if self.spec.satisfies("dev_path=*"):
+            target = os.path.join(self.stage.source_path, "compile_commands.json")
+            source = os.path.join(self.build_directory, "compile_commands.json")
+            if os.path.isfile(source):
+                shutil.copyfile(source, target)

lib/spack/spack/fetch_strategy.py

@@ -24,7 +24,6 @@
 """
 import copy
 import functools
-import http.client
 import os
 import os.path
 import re
@@ -60,6 +59,19 @@
 #: List of all fetch strategies, created by FetchStrategy metaclass.
 all_strategies = []
 
+CONTENT_TYPE_MISMATCH_WARNING_TEMPLATE = (
+    "The contents of {subject} look like {content_type}.  Either the URL"
+    " you are trying to use does not exist or you have an internet gateway"
+    " issue.  You can remove the bad archive using 'spack clean"
+    " <package>', then try again using the correct URL."
+)
+
+
+def warn_content_type_mismatch(subject, content_type="HTML"):
+    tty.warn(
+        CONTENT_TYPE_MISMATCH_WARNING_TEMPLATE.format(subject=subject, content_type=content_type)
+    )
+
 
 def _needs_stage(fun):
     """Many methods on fetch strategies require a stage to be set
@@ -253,7 +265,6 @@ def __init__(self, *, url: str, checksum: Optional[str] = None, **kwargs) -> Non
         self.extra_options: dict = kwargs.get("fetch_options", {})
         self._curl: Optional[Executable] = None
         self.extension: Optional[str] = kwargs.get("extension", None)
-        self._effective_url: Optional[str] = None
 
     @property
     def curl(self) -> Executable:
@@ -309,13 +320,7 @@ def _check_headers(self, headers):
         # redirects properly.
         content_types = re.findall(r"Content-Type:[^\r\n]+", headers, flags=re.IGNORECASE)
         if content_types and "text/html" in content_types[-1]:
-            msg = (
-                f"The contents of {self.archive_file or 'the archive'} fetched from {self.url} "
-                " looks like HTML. This can indicate a broken URL, or an internet gateway issue."
-            )
-            if self._effective_url != self.url:
-                msg += f" The URL redirected to {self._effective_url}."
-            tty.warn(msg)
+            warn_content_type_mismatch(self.archive_file or "the archive")
 
     @_needs_stage
     def _fetch_urllib(self, url):
@@ -341,12 +346,6 @@ def _fetch_urllib(self, url):
         with open(save_file, "wb") as f:
             shutil.copyfileobj(response, f)
 
-        # Save the redirected URL for error messages. Sometimes we're redirected to an arbitrary
-        # mirror that is broken, leading to spurious download failures. In that case it's helpful
-        # for users to know which URL was actually fetched.
-        if isinstance(response, http.client.HTTPResponse):
-            self._effective_url = response.geturl()
-
         self._check_headers(str(response.headers))
 
     @_needs_stage
@@ -466,7 +465,7 @@ def check(self):
         if not self.digest:
             raise NoDigestError(f"Attempt to check {self.__class__.__name__} with no digest.")
 
-        verify_checksum(self.archive_file, self.digest, self.url, self._effective_url)
+        verify_checksum(self.archive_file, self.digest)
 
     @_needs_stage
     def reset(self):
@@ -1434,26 +1433,21 @@ def expand(self):
         if len(files) != 1:
             raise ChecksumError(self, f"Expected a single file in {src_dir}.")
 
-        verify_checksum(
-            os.path.join(src_dir, files[0]), self.expanded_sha256, self.url, self._effective_url
-        )
+        verify_checksum(os.path.join(src_dir, files[0]), self.expanded_sha256)
 
 
-def verify_checksum(file: str, digest: str, url: str, effective_url: Optional[str]) -> None:
+def verify_checksum(file, digest):
     checker = crypto.Checker(digest)
     if not checker.check(file):
         # On failure, provide some information about the file size and
         # contents, so that we can quickly see what the issue is (redirect
         # was not followed, empty file, text instead of binary, ...)
         size, contents = fs.filesummary(file)
-        long_msg = (
+        raise ChecksumError(
+            f"{checker.hash_name} checksum failed for {file}",
             f"Expected {digest} but got {checker.sum}. "
-            f"File size = {size} bytes. Contents = {contents!r}. "
-            f"URL = {url}"
+            f"File size = {size} bytes. Contents = {contents!r}",
         )
-        if effective_url and effective_url != url:
-            long_msg += f", redirected to = {effective_url}"
-        raise ChecksumError(f"{checker.hash_name} checksum failed for {file}", long_msg)
 
 
 def stable_target(fetcher):

var/spack/repos/builtin/packages/hypar/package.py

@@ -18,14 +18,14 @@ class Hypar(AutotoolsPackage):
     """
 
     homepage = "http://hypar.github.io/"
-    url = "https://github.com/debog/hypar/archive/refs/tags/v4.1.tar.gz"
-    git = "https://github.com/debog/hypar.git"
+    url = "https://bitbucket.org/deboghosh/hypar/get/v4.1.tar.gz"
+    git = "https://bitbucket.org/deboghosh/hypar.git"
 
     maintainers("debog")
 
     tags = ["proxy-app", "ecp-proxy-app"]
 
-    version("4.1", sha256="b3bfc6da28d78e2cc89868a35990617e4f77521b68911772887c2f8d0b1fec21")
+    version("4.1", sha256="36c11dcfda006115f4656ff73790992e5caea99dbc64776c9db4e0a29b4c60da")
 
     variant("mpi", default=True, description="Build with MPI support")
     variant("openmp", default=False, description="Build with OpenMP support")
@@ -48,9 +48,8 @@ def configure_args(self):
         args = []
         spec = self.spec
         if "+mpi" in spec:
+            args.append("--enable-mpi")
             args.append("--with-mpi-dir={0}".format(spec["mpi"].prefix))
-        else:
-            args.append("--enable-serial")
         if "+openmp" in spec:
             args.append("--enable-omp")
         if "+scalapack" in spec:

var/spack/repos/builtin/packages/mfem/package.py

@@ -973,9 +973,6 @@ def find_optional_library(name, prefix):
             if "^rocthrust" in spec and not spec["hip"].external:
                 # petsc+rocm needs the rocthrust header path
                 hip_headers += spec["rocthrust"].headers
-            if "^rocprim" in spec and not spec["hip"].external:
-                # rocthrust [via petsc+rocm] has a dependency on rocprim
-                hip_headers += spec["rocprim"].headers
             if "^hipblas" in spec and not spec["hip"].external:
                 # superlu-dist+rocm needs the hipblas header path
                 hip_headers += spec["hipblas"].headers

var/spack/repos/builtin/packages/petsc/package.py

@@ -253,7 +253,6 @@ def check_fortran_compiler(self):
     depends_on("hip", when="+rocm")
 
     with when("+rocm"):
-        depends_on("rocm-core")
         depends_on("hipblas")
         depends_on("hipsparse")
         depends_on("hipsolver")
@@ -603,7 +602,7 @@ def configure_options(self):
                 hip_arch = spec.variants["amdgpu_target"].value
                 options.append("--with-hip-arch={0}".format(hip_arch[0]))
             hip_pkgs = ["hipsparse", "hipblas", "hipsolver", "rocsparse", "rocsolver", "rocblas"]
-            hip_ipkgs = hip_pkgs + ["rocthrust", "rocprim", "rocm-core"]
+            hip_ipkgs = hip_pkgs + ["rocthrust", "rocprim"]
             hip_lpkgs = hip_pkgs
             if spec.satisfies("^rocrand@5.1:"):
                 hip_ipkgs.extend(["rocrand"])