main.yml

name: hdf5 1.12 CI

# Controls when the action will run. Triggers the workflow on push or pull request
on:
  workflow_dispatch:
  push:
  pull_request:
    branches: [ hdf5_1_12 ]
    paths-ignore:
      - '.github/CODEOWNERS'
      - '.github/FUNDING.yml'
      - 'doc/**'
      - 'release_docs/**'
      - 'ACKNOWLEDGEMENTS'
      - 'COPYING**'
      - '**.md'

# Using concurrency to cancel any in-progress job or run
concurrency:
  group: ${{ github.workflow }}-${{ github.sha || github.event.pull_request.number }}
  cancel-in-progress: true

permissions:
  contents: read

# A workflow run is made up of one or more jobs that can run sequentially or
# in parallel. We just have one job, but the matrix items defined below will
# run in parallel.
jobs:

  # A workflow that builds the library and runs all the tests
  build_and_test:

    strategy:

      # The current matrix has three dimensions:
      #
      # * config name
      # * thread-safety on/off
      # * release vs. debug build
      #
      # Most configuration information is added via the 'include' mechanism,
      # which will append the key-value pairs in the configuration where the
      # names match.

      matrix:

        name:
          - "Windows MSVC CMake"
          - "Ubuntu gcc CMake"
          - "Ubuntu gcc Autotools"
          - "Ubuntu gcc Autotools parallel (build only)"
          - "MacOS Clang CMake"

        thread_safety:
          - enabled: true
            text: " TS"
          - enabled: false
            text: ""

        build_mode:
          - text: " REL"
            cmake: "Release"
            autotools: "production"
          - text: " DBG"
            cmake: "Debug"
            autotools: "debug"

        # This is where we list the bulk of the options for each configuration.
        # The key-value pair values are usually appropriate for being CMake or
        # Autotools configure values, so be aware of that.

        include:

          # Windows w/ MSVC + CMake
          #
          # No Fortran, parallel, or VFDs that rely on POSIX things
          - name: "Windows MSVC CMake"
            os: windows-2022
            toolchain: ""
            cpp: ON
            fortran: OFF
            java: ON
            docs: OFF
            libaecfc: ON
            localaec: OFF
            zlibfc: ON
            localzlib: OFF
            parallel: OFF
            mirror_vfd: OFF
            direct_vfd: OFF
            ros3_vfd: OFF
            generator: "-G \"Visual Studio 17 2022\" -A x64"
            run_tests: true

          # Linux (Ubuntu) w/ gcc + CMake
          #
          # We might think about adding Clang, but MacOS already tests that
          # so it's not critical
          - name: "Ubuntu gcc CMake"
            os: ubuntu-latest
            cpp: ON
            fortran: ON
            java: ON
            docs: ON
            libaecfc: ON
            localaec: OFF
            zlibfc: ON
            localzlib: OFF
            parallel: OFF
            mirror_vfd: ON
            direct_vfd: ON
            ros3_vfd: OFF
            toolchain: "config/toolchain/gcc.cmake"
            generator: "-G Ninja"
            run_tests: true

          # Linux (Ubuntu) w/ gcc + Autotools
          #
          # Keep this identical to the CMake configs. Note the difference in
          # the values.
          - name: "Ubuntu gcc Autotools"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            docs: disable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            ros3_vfd: enable
            deprec_sym: enable
            default_api: v112
            szip: yes
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: true

          # Parallel Linux (Ubuntu) w/ gcc + Autotools
          #
          # The GitHub runners are inadequate for running parallel HDF5 tests,
          # so we catch most issues in daily testing. What we have here is just
          # a compile check to make sure nothing obvious is broken.
          - name: "Ubuntu gcc Autotools parallel (build only)"
            os: ubuntu-latest
            cpp: disable
            fortran: enable
            java: disable
            docs: disable
            parallel: enable
            mirror_vfd: disable
            direct_vfd: disable
            ros3_vfd: disable
            deprec_sym: enable
            default_api: v112
            szip: yes
            toolchain: ""
            generator: "autogen"
            flags: "CC=mpicc"
            run_tests: false

          # MacOS w/ Clang + CMake
          #
          # We could also build with the Autotools via brew installing them,
          # but that seems unnecessary
          - name: "MacOS Clang CMake"
            os: macos-13
            cpp: ON
            fortran: OFF
            java: ON
            docs: OFF
            libaecfc: ON
            localaec: OFF
            zlibfc: ON
            localzlib: OFF
            parallel: OFF
            mirror_vfd: ON
            direct_vfd: OFF
            ros3_vfd: OFF
            toolchain: "config/toolchain/clang.cmake"
            generator: "-G Ninja"
            run_tests: true


          #
          # SPECIAL AUTOTOOLS BUILDS
          #
          # These do not run tests and are not built into the matrix and instead
          # become NEW configs as their name would clobber one of the matrix
          # names (so make sure the names are UNIQUE).
          #

          - name: "Ubuntu gcc Autotools v1.6 default API (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            docs: disable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            ros3_vfd: enable
            deprec_sym: enable
            default_api: v16
            szip: yes
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              enabled: false
              text: ""
            build_mode:
              text: " DBG"
              cmake: "Debug"
              autotools: "debug"

          - name: "Ubuntu gcc Autotools v1.8 default API (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            docs: disable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            ros3_vfd: enable
            deprec_sym: enable
            default_api: v18
            szip: yes
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              enabled: false
              text: ""
            build_mode:
              text: " DBG"
              cmake: "Debug"
              autotools: "debug"

          - name: "Ubuntu gcc Autotools v1.10 default API (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            docs: disable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            ros3_vfd: enable
            deprec_sym: enable
            default_api: v110
            szip: yes
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              enabled: false
              text: ""
            build_mode:
              text: " DBG"
              cmake: "Debug"
              autotools: "debug"

          - name: "Ubuntu gcc Autotools v1.12 default API (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            docs: disable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            ros3_vfd: enable
            deprec_sym: enable
            default_api: v112
            szip: yes
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              enabled: false
              text: ""
            build_mode:
              text: " DBG"
              cmake: "Debug"
              autotools: "debug"

          - name: "Ubuntu gcc Autotools no deprecated symbols (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            docs: disable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            ros3_vfd: enable
            deprec_sym: disable
            default_api: v112
            szip: yes
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              enabled: false
              text: ""
            build_mode:
              text: " DBG"
              cmake: "Debug"
              autotools: "debug"

    # Sets the job's name from the properties
    name: "${{ matrix.name }}${{ matrix.build_mode.text }}${{ matrix.thread_safety.text }}"

    # Don't run the action if the commit message says to skip CI
    if: "!contains(github.event.head_commit.message, 'skip-ci')"

    # The type of runner that the job will run on
    runs-on: ${{ matrix.os }}

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:

      #
      # SETUP
      #

      #Useful for debugging
      - name: Dump matrix context
        run: echo '${{ toJSON(matrix) }}'

      # Only CMake need ninja-build, but we just install it unilaterally
      # libssl, etc. are needed for the ros3 VFD
      - name: Install Linux Dependencies
        run: |
           sudo apt update
           sudo apt-get install ninja-build doxygen graphviz
           sudo apt install libssl3 libssl-dev libcurl4 libcurl4-openssl-dev
           sudo apt install gcc-12 g++-12 gfortran-12
           echo "CC=gcc-12" >> $GITHUB_ENV
           echo "CXX=g++-12" >> $GITHUB_ENV
           echo "FC=gfortran-12" >> $GITHUB_ENV
        if: matrix.os == 'ubuntu-latest'

      # CMake gets libaec from fetchcontent
      - name: Install Autotools Dependencies (Linux)
        run: |
           sudo apt install automake autoconf libtool libtool-bin
           sudo apt install libaec0 libaec-dev
        if: (matrix.generator == 'autogen')

      - name: Install Autotools Dependencies (Linux, parallel)
        run: |
           sudo apt install openmpi-bin openmpi-common mpi-default-dev
           echo "CC=mpicc" >> $GITHUB_ENV
           echo "FC=mpif90" >> $GITHUB_ENV
        if: (matrix.generator == 'autogen') && (matrix.parallel == 'enable')

      - name: Install Dependencies (Windows)
        run: choco install ninja
        if: matrix.os == 'windows-latest'

      - name: Install Dependencies (macOS)
        run: brew install ninja doxygen
        if: matrix.os == 'macos-13'

      - name: Set environment for MSVC (Windows)
        run: |
          # Set these environment variables so CMake picks the correct compiler
          echo "CXX=cl.exe" >> $GITHUB_ENV
          echo "CC=cl.exe" >> $GITHUB_ENV
        if:  matrix.os == 'windows-latest'
    
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - name: Get Sources
        uses: actions/checkout@v3

      #
      # AUTOTOOLS CONFIGURE
      #

      - name: Autotools Configure
        run: |
          sh ./autogen.sh
          mkdir "${{ runner.workspace }}/build"
          cd "${{ runner.workspace }}/build"
          ${{ matrix.flags }} $GITHUB_WORKSPACE/configure \
            --enable-build-mode=${{ matrix.build_mode.autotools }} \
            --${{ matrix.deprec_sym }}-deprecated-symbols \
            --with-default-api-version=${{ matrix.default_api }} \
            --enable-shared \
            --${{ matrix.parallel }}-parallel \
            --${{ matrix.cpp }}-cxx \
            --${{ matrix.fortran }}-fortran \
            --${{ matrix.java }}-java \
            --${{ matrix.mirror_vfd }}-mirror-vfd \
            --${{ matrix.direct_vfd }}-direct-vfd \
            --${{ matrix.ros3_vfd }}-ros3-vfd \
            --with-szlib=${{ matrix.szip }}
        shell: bash
        if: (matrix.generator == 'autogen') && ! (matrix.thread_safety.enabled)

      - name: Autotools Configure (Thread-Safe)
        run: |
          sh ./autogen.sh
          mkdir "${{ runner.workspace }}/build"
          cd "${{ runner.workspace }}/build"
          ${{ matrix.flags }} $GITHUB_WORKSPACE/configure \
            --enable-build-mode=${{ matrix.build_mode.autotools }} \
            --enable-shared \
            --enable-threadsafe \
            --disable-hl \
            --${{ matrix.mirror_vfd }}-mirror-vfd \
            --${{ matrix.direct_vfd }}-direct-vfd \
            --${{ matrix.ros3_vfd }}-ros3-vfd \
            --with-szlib=${{ matrix.szip }}
        shell: bash
        if: (matrix.generator == 'autogen') && (matrix.thread_safety.enabled)

      #
      # CMAKE CONFIGURE
      #

      - name: CMake Configure
        run: |
          mkdir "${{ runner.workspace }}/build"
          cd "${{ runner.workspace }}/build"
          cmake -C $GITHUB_WORKSPACE/config/cmake/cacheinit.cmake \
            ${{ matrix.generator }} \
            -DCMAKE_BUILD_TYPE=${{ matrix.build_mode.cmake }} \
            -DCMAKE_TOOLCHAIN_FILE=${{ matrix.toolchain }} \
            -DBUILD_SHARED_LIBS=ON \
            -DHDF5_ENABLE_ALL_WARNINGS=ON \
            -DHDF5_ENABLE_PARALLEL:BOOL=${{ matrix.parallel }} \
            -DHDF5_BUILD_CPP_LIB:BOOL=${{ matrix.cpp }} \
            -DHDF5_BUILD_FORTRAN=${{ matrix.fortran }} \
            -DHDF5_BUILD_JAVA=${{ matrix.java }} \
            -DHDF5_BUILD_DOC=${{ matrix.docs }} \
            -DBUILD_SZIP_WITH_FETCHCONTENT=${{ matrix.libaecfc }} \
            -DLIBAEC_USE_LOCALCONTENT=${{ matrix.localaec }} \
            -DBUILD_ZLIB_WITH_FETCHCONTENT=${{ matrix.zlibfc }} \
            -DZLIB_USE_LOCALCONTENT=${{ matrix.localzlib }} \
            -DHDF5_ENABLE_MIRROR_VFD:BOOL=${{ matrix.mirror_vfd }} \
            -DHDF5_ENABLE_DIRECT_VFD:BOOL=${{ matrix.direct_vfd }} \
            -DHDF5_ENABLE_ROS3_VFD:BOOL=${{ matrix.ros3_vfd }} \
            $GITHUB_WORKSPACE
        shell: bash
        if: (matrix.generator != 'autogen') && ! (matrix.thread_safety.enabled)


      # NOTE: Windows does not support static + thread-safe
      - name: CMake Configure (Thread-Safe)
        run: |
          mkdir "${{ runner.workspace }}/build"
          cd "${{ runner.workspace }}/build"
          cmake -C $GITHUB_WORKSPACE/config/cmake/cacheinit.cmake \
            ${{ matrix.generator }} \
            -DCMAKE_BUILD_TYPE=${{ matrix.build_mode.cmake }} \
            -DCMAKE_TOOLCHAIN_FILE=${{ matrix.toolchain }} \
            -DBUILD_SHARED_LIBS=OFF \
            -DHDF5_ENABLE_ALL_WARNINGS=ON \
            -DHDF5_ENABLE_THREADSAFE:BOOL=ON \
            -DHDF5_ENABLE_PARALLEL:BOOL=${{ matrix.parallel }} \
            -DHDF5_BUILD_CPP_LIB:BOOL=OFF \
            -DHDF5_BUILD_FORTRAN:BOOL=OFF \
            -DHDF5_BUILD_JAVA:BOOL=OFF \
            -DHDF5_BUILD_HL_LIB:BOOL=OFF \
            -DHDF5_BUILD_DOC=OFF \
            -DBUILD_SZIP_WITH_FETCHCONTENT=${{ matrix.libaecfc }} \
            -DLIBAEC_USE_LOCALCONTENT=${{ matrix.localaec }} \
            -DBUILD_ZLIB_WITH_FETCHCONTENT=${{ matrix.zlibfc }} \
            -DZLIB_USE_LOCALCONTENT=${{ matrix.localzlib }} \
            -DHDF5_ENABLE_MIRROR_VFD:BOOL=${{ matrix.mirror_vfd }} \
            -DHDF5_ENABLE_DIRECT_VFD:BOOL=${{ matrix.direct_vfd }} \
            -DHDF5_ENABLE_ROS3_VFD:BOOL=${{ matrix.ros3_vfd }} \
            $GITHUB_WORKSPACE
        shell: bash
        if: (matrix.generator != 'autogen') && (matrix.thread_safety.enabled)

      #
      # BUILD
      #

      - name: Autotools Build
        run: make -j3
        working-directory: ${{ runner.workspace }}/build
        if: matrix.generator == 'autogen'

      - name: CMake Build
        run: cmake --build . --parallel 3 --config ${{ matrix.build_mode.cmake }}
        working-directory: ${{ runner.workspace }}/build
        if: (matrix.generator != 'autogen')

      #
      # RUN TESTS
      #

      # NORMAL

      - name: Autotools Run Tests
        run: make check -j2
        working-directory: ${{ runner.workspace }}/build
        if: (matrix.generator == 'autogen') && (matrix.run_tests) && ! (matrix.thread_safety.enabled)

      - name: CMake Run Tests
        run: ctest . --parallel 2 -C ${{ matrix.build_mode.cmake }} -V
        working-directory: ${{ runner.workspace }}/build
        if: (matrix.generator != 'autogen') && (matrix.run_tests) && ! (matrix.thread_safety.enabled)

      # THREAD-SAFE

      - name: Autotools Run Thread-Safe Tests
        run: |
          cd test
          ./ttsafe
        working-directory: ${{ runner.workspace }}/build
        if: (matrix.generator == 'autogen') && (matrix.run_tests) && (matrix.thread_safety.enabled)

      - name: CMake Run Thread-Safe Tests
        run: ctest . --parallel 2 -C ${{ matrix.build_mode.cmake }} -V -R ttsafe
        working-directory: ${{ runner.workspace }}/build
        if: (matrix.generator != 'autogen') && (matrix.run_tests) && (matrix.thread_safety.enabled)

      #
      # INSTALL (note that this runs even when we don't run the tests)
      #

      - name: Autotools Install
        run: make install
        working-directory: ${{ runner.workspace }}/build
        if: (matrix.generator == 'autogen')

      - name: Autotools Verify Install
        run: make check-install
        working-directory: ${{ runner.workspace }}/build
        if: (matrix.generator == 'autogen')