version-tests.yml

name: version-tests

on:
  workflow_call:
    inputs:
      chaste_branch:
        description: 'Chaste branch'
        required: true
        type: string
        default: 'develop'

      test_suites:
        description: 'Test suites'
        required: true
        type: string
        default: 'Continuous,Nightly,Weekly'

      xsd_ver:
        description: 'XSD version'
        required: true
        type: string 
        default: '4.0.0'

      xercesc_ver:
        description: 'Xerces-C version'
        required: true
        type: string 
        default: '3.2.3'

      sundials_ver:
        description: 'Sundials version'
        required: false
        type: string 
        default: '5.8.0'

      boost_ver:
        description: 'Boost version'
        required: true
        type: string 
        default: '1.74.0'

      vtk_ver:
        description: 'VTK version'
        required: false
        type: string 
        default: '7.1.0'

      petsc_ver:
        description: 'PETSc version'
        required: true
        type: string 
        default: '3.12.4'

      petsc_arch:
        description: 'PETSc arch'
        required: true
        type: string
        default: 'linux-gnu'
      
      hdf5_ver:
        description: 'HDF5 version'
        required: true
        type: string 
        default: '1.10.5'

jobs:
  build-and-test:
    runs-on: [self-hosted]
    timeout-minutes: 360
    
    defaults:
      run:
        shell: bash
        
    steps:
      - name: Set environment
        run: |
          test_suites=($(echo "${{ inputs.test_suites }}" | tr '[:upper:]' '[:lower:]' | tr ',' '\n'))

          run_continuous=0;
          run_parallel=0
          run_nightly=0
          run_weekly=0
          
          for suite in "${test_suites[@]}"; do
            case $suite in
              continuous) run_continuous=1;;
              nightly) run_nightly=1;;
              weekly) run_weekly=1;;
              *) echo "Unknown test suite: $suite" 1>&2; exit 1;;
            esac
          done

          echo "run_continuous=${run_continuous}" >> ${GITHUB_ENV}
          echo "run_nightly=${run_nightly}" >> ${GITHUB_ENV}
          echo "run_weekly=${run_weekly}" >> ${GITHUB_ENV}
          
          modules_dir="${MODULES_DIR:-${HOME}/modules}"
          echo "modules_dir=${modules_dir}" >> ${GITHUB_ENV}
          mkdir -p ${modules_dir}/modulefiles

          echo "parallel=$(( $(nproc) < 12 ? $(nproc) : 12 ))" >> ${GITHUB_ENV}
          echo "niceness=10" >> ${GITHUB_ENV}

          testoutput="${HOME}/testoutput/$(date +'%Y%m%d%H%M%S')"
          echo "CHASTE_TEST_OUTPUT=${testoutput}" >> ${GITHUB_ENV}
          mkdir -p ${testoutput}

      - name: Create module loading script
        run: |
          echo "source /etc/profile.d/modules.sh" > modulesinit.sh
          echo "module use ${{ env.modules_dir }}/modulefiles" >> modulesinit.sh
          echo "module purge" >> modulesinit.sh

      - name: Setup xsd
        run: |
          source modulesinit.sh
          err=0 && module test xsd/${{ inputs.xsd_ver }} || err=$?
          if [ $err -ne 0 ]; then
            nice -n ${{ env.niceness }} install_xsd.sh \
              --version=${{ inputs.xsd_ver }} \
              --modules-dir=${{ env.modules_dir }}
            module test xsd/${{ inputs.xsd_ver }}
          fi

      - name: Setup xercesc
        run: |
          source modulesinit.sh
          err=0 && module test xercesc/${{ inputs.xercesc_ver }} || err=$?
          if [ $err -ne 0 ]; then
            nice -n ${{ env.niceness }} install_xercesc.sh \
              --version=${{ inputs.xercesc_ver }} \
              --modules-dir=${{ env.modules_dir }} \
              --parallel=${{ env.parallel }}
            module test xercesc/${{ inputs.xercesc_ver }}
          fi

      - name: Setup sundials
        run: |
          if [ -n "${{ inputs.sundials_ver }}" ]; then
            source modulesinit.sh
            err=0 && module test sundials/${{ inputs.sundials_ver }} || err=$?
            if [ $err -ne 0 ]; then
              nice -n ${{ env.niceness }} install_sundials.sh \
                --version=${{ inputs.sundials_ver }} \
                --modules-dir=${{ env.modules_dir }} \
                --parallel=${{ env.parallel }}
              module test sundials/${{ inputs.sundials_ver }}
            fi
          fi

      - name: Setup boost
        run: |
          source modulesinit.sh
          err=0 && module test boost/${{ inputs.boost_ver }} || err=$?
          if [ $err -ne 0 ]; then
            nice -n ${{ env.niceness }} install_boost.sh \
              --version=${{ inputs.boost_ver }} \
              --modules-dir=${{ env.modules_dir }} \
              --parallel=${{ env.parallel }}
            module test boost/${{ inputs.boost_ver }}
          fi

      - name: Setup vtk
        run: |
          if [ -n "${{ inputs.vtk_ver }}" ]; then
            source modulesinit.sh
            err=0 && module test vtk/${{ inputs.vtk_ver }} || err=$?
            if [ $err -ne 0 ]; then
              nice -n ${{ env.niceness }} install_vtk.sh \
                --version=${{ inputs.vtk_ver }} \
                --modules-dir=${{ env.modules_dir }} \
                --parallel=${{ env.parallel }}
              module test vtk/${{ inputs.vtk_ver }}
            fi
          fi

      - name: Setup petsc_hdf5
        run: |
          source modulesinit.sh
          err=0 && module test petsc_hdf5/${{ inputs.petsc_ver }}_${{ inputs.hdf5_ver }}/${{ inputs.petsc_arch }} || err=$?
          if [ $err -ne 0 ]; then
            nice -n ${{ env.niceness }} install_petsc_hdf5.sh \
              --petsc-version=${{ inputs.petsc_ver }} \
              --hdf5-version=${{ inputs.hdf5_ver }} \
              --petsc-arch=${{ inputs.petsc_arch }} \
              --modules-dir=${{ env.modules_dir }} \
              --parallel=${{ env.parallel }}
            module test petsc_hdf5/${{ inputs.petsc_ver }}_${{ inputs.hdf5_ver }}/${{ inputs.petsc_arch }}
          fi

      - name: Add versions to module loading script
        run: |
          echo "module load xsd/${{ inputs.xsd_ver }}" >> modulesinit.sh
          echo "module load xercesc/${{ inputs.xercesc_ver }}" >> modulesinit.sh
          echo "module load boost/${{ inputs.boost_ver }}" >> modulesinit.sh
          echo "module load petsc_hdf5/${{ inputs.petsc_ver }}_${{ inputs.hdf5_ver }}/${{ inputs.petsc_arch }}" >> modulesinit.sh
          
          if [ -n "${{ inputs.sundials_ver }}" ]; then
            echo "module load sundials/${{ inputs.sundials_ver }}" >> modulesinit.sh
          fi
          
          if [ -n "${{ inputs.vtk_ver }}" ]; then
            echo "module load vtk/${{ inputs.vtk_ver }}" >> modulesinit.sh
          fi
          
      - name: Checkout Chaste
        uses: actions/checkout@v3
        with:
          repository: Chaste/Chaste
          path: Chaste
          ref: ${{ inputs.chaste_branch }}
          submodules: recursive

      - name: Configure Chaste
        run: |
          source modulesinit.sh

          if [ -z "${{ inputs.sundials_ver }}" ]; then
            use_cvode="OFF"
          else
            use_cvode="ON"
          fi
          
          if [ -z "${{ inputs.vtk_ver }}" ]; then
            use_vtk="OFF"
          else
            use_vtk="ON"
          fi

          mkdir -p Chaste/build
          cd Chaste/build
          nice -n ${{ env.niceness }} cmake \
            -DChaste_USE_CVODE=${use_cvode} \
            -DChaste_USE_VTK=${use_vtk} \
            -DCMAKE_BUILD_TYPE=Release \
            ..

      - name: Compile Chaste build info
        run: |
          source modulesinit.sh
          cd Chaste/build
          nice -n ${{ env.niceness }} cmake --build . --parallel ${{ env.parallel }} --target TestChasteBuildInfo
          nice -n ${{ env.niceness }} ctest -V -R TestChasteBuildInfo --output-on-failure | tee buildinfo

      - name: Verify dependency versions
        run: |
          cd Chaste/build
          sed -i.bak 's/"//g' buildinfo  # removes quotes from old sundials versions

          maj_min_rev='^[0-9]\+\.[0-9]\+\.[0-9]\+'
          maj_min='^[0-9]\+\.[0-9]\+'

          xsd_ver="$(echo ${{ inputs.xsd_ver }} | grep -o ${maj_min_rev})"
          grep "<XSD>${xsd_ver}</XSD>" buildinfo
          
          xercesc_ver="$(echo ${{ inputs.xercesc_ver }} | grep -o ${maj_min_rev})"
          grep "<Xerces>${xercesc_ver}</Xerces>" buildinfo
          
          if [ -n "${{ inputs.sundials_ver }}" ]; then
            sundials_ver="$(echo ${{ inputs.sundials_ver }} | grep -o ${maj_min_rev})"
            grep "<SUNDIALS>${sundials_ver}</SUNDIALS>" buildinfo
          fi
          
          boost_ver="$(echo ${{ inputs.boost_ver }} | grep -o ${maj_min_rev})"
          grep "<Boost>${boost_ver}</Boost>" buildinfo
          
          if [ -n "${{ inputs.vtk_ver }}" ]; then
            vtk_ver="$(echo ${{ inputs.vtk_ver }} | grep -o ${maj_min})"
            grep "<VTK>${vtk_ver}</VTK>" buildinfo
          fi
          
          petsc_ver="$(echo ${{ inputs.petsc_ver }} | grep -o ${maj_min_rev})"
          grep "<PETSc>${petsc_ver}</PETSc>" buildinfo
          
          hdf5_ver="$(echo ${{ inputs.hdf5_ver }} | grep -o ${maj_min_rev})"
          grep "<HDF5>${hdf5_ver}</HDF5>" buildinfo

      - name: Build Continuous test pack
        if: ${{ env.run_continuous == '1' }}
        run: |
          source modulesinit.sh
          cd Chaste/build
          nice -n ${{ env.niceness }} cmake --build . --parallel ${{ env.parallel }} --target Continuous

      - name: Run Continuous test pack
        if: ${{ env.run_continuous == '1' }}
        run: |
          source modulesinit.sh
          cd Chaste/build
          nice -n ${{ env.niceness }} ctest -j ${{ env.parallel }} -L Continuous --output-on-failure

      - name: Build Nightly test pack
        if: ${{ env.run_nightly == '1' }}
        run: |
          source modulesinit.sh
          cd Chaste/build
          nice -n ${{ env.niceness }} cmake --build . --parallel ${{ env.parallel }} --target Nightly

      - name: Run Nightly test pack
        if: ${{ env.run_nightly == '1' }}
        run: |
          source modulesinit.sh
          cd Chaste/build
          nice -n ${{ env.niceness }} ctest -j ${{ env.parallel }} -L Nightly --output-on-failure

      - name: Build Weekly test pack
        if: ${{ env.run_weekly == '1' }}
        run: |
          source modulesinit.sh
          cd Chaste/build
          nice -n ${{ env.niceness }} cmake --build . --parallel ${{ env.parallel }} --target Weekly

      - name: Run Weekly test pack
        if: ${{ env.run_weekly == '1' }}
        run: |
          source modulesinit.sh
          cd Chaste/build
          nice -n ${{ env.niceness }} ctest -j ${{ env.parallel }} -L Weekly --output-on-failure

      - name: Cleanup
        if: always()
        run: rm -rf ${{ env.modules_dir }}/src/*