ResInsight/.github/workflows/ResInsightWithCache.yml

name: ResInsight Build With Cache

on:
  push:
  pull_request:
  schedule:
    # Every day at 1am to make sure we have a build cache for the current date
    # build cache is
    - cron: "0 1 * * * "
env:
  BUILD_TYPE: Release
  BUILDCACHE_VERSION: 0.27.6
  BUILDCACHE_DIR: ${{ github.workspace }}/buildcache_dir
  BUILDCACHE_ACCURACY: SLOPPY

concurrency:
  group: build-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: true

jobs:
  ResInsight-x64-buildcache:
    runs-on: ${{ matrix.config.os }}
    strategy:
      fail-fast: false
      matrix:
        config:
          - {
              name: "Windows Latest MSVC",
              os: windows-2022,
              cc: "cl",
              cxx: "cl",
              vcpkg-response-file: vcpkg_x64-windows.txt,
              vcpkg-triplet: x64-windows,
              build-python-module: true,
              execute-unit-tests: true,
            }
          - {
              name: "Ubuntu Latest gcc",
              os: ubuntu-20.04,
              cc: "gcc",
              cxx: "g++",
              vcpkg-response-file: vcpkg_x64-linux.txt,
              vcpkg-triplet: x64-linux,
              build-python-module: true,
              execute-unit-tests: true,
            }
          - {
              name: "Ubuntu Latest clang",
              os: ubuntu-20.04,
              cc: "clang",
              cxx: "clang++",
              vcpkg-response-file: vcpkg_x64-linux.txt,
              vcpkg-triplet: x64-linux,
              build-python-module: true,
              execute-unit-tests: true,
            }
    steps:
      - name: Checkout
        uses: actions/checkout@v3
        with:
          submodules: true

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: "3.8"
      - name: Display Python version
        run: python -c "import sys; print(sys.version)"

      - name: Get Python executable path
        shell: bash
        id: python-path
        run: echo "PYTHON_EXECUTABLE=$(python -c 'import sys; import pathlib; print (pathlib.PurePath(sys.executable).as_posix())')" >> $GITHUB_OUTPUT

      - name: Print Python path
        run: echo "${{ steps.python-path.outputs.PYTHON_EXECUTABLE }}"

      - name: Install dependencies
        # Make sure protobuf version is compatible with grpc - https://github.com/OPM/ResInsight/issues/9304
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Use CMake
        uses: lukka/get-cmake@latest

      - name: Use MSVC (Windows)
        uses: ilammy/msvc-dev-cmd@v1

      - name: Download buildcache
        id: buildcache-download
        shell: cmake -P {0}
        run: |
          if ("${{ runner.os }}" STREQUAL "Windows")
            set(buildcache_suffix "windows.zip")
          elseif ("${{ runner.os }}" STREQUAL "macOS")
            set(buildcache_suffix "macos.zip")
          elseif ("${{ runner.os }}" STREQUAL "Linux")
            set(buildcache_suffix "linux.tar.gz")
          endif()

          set(buildcache_version $ENV{BUILDCACHE_VERSION})
          set(buildcache_url "https://github.com/mbitsnbites/buildcache/releases/download/v${buildcache_version}/buildcache-${buildcache_suffix}")
          file(DOWNLOAD "${buildcache_url}" ./buildcache.zip)
          execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./buildcache.zip)

          if (NOT "${{ runner.os }}" STREQUAL "Windows")
            execute_process(
              COMMAND chmod +x buildcache/bin/buildcache
            )
          endif()

      - name: Get current time
        uses: josStorer/get-current-time@v2.0.2
        id: current-time
        with:
          format: YYYY-MM-DD

      - name: Print time stamp
        run: echo "timestamp ${{ steps.current-time.outputs.formattedTime }}"

      - name: Cache Buildcache
        id: cache-buildcache
        uses: actions/cache@v3
        with:
          path: ${{ env.BUILDCACHE_DIR }}
          key: ${{ matrix.config.os }}-${{ matrix.config.cc }}-cache-v02-${{ steps.current-time.outputs.formattedTime }}
      - name: Create Folder for buildcache
        run: New-Item ${{ env.BUILDCACHE_DIR }} -ItemType "directory" -Force
        shell: pwsh
      - name: Add buildcache to system path
        run: echo "${{github.workspace}}/buildcache/bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8
        shell: pwsh

      - name: Install Linux dependencies
        if: "contains( matrix.config.os, 'ubuntu')"
        run: |
          sudo apt-get update
          sudo apt-get install libxkbcommon-x11-0 libgl1-mesa-dev mesa-common-dev libglfw3-dev libglu1-mesa-dev libhdf5-dev
          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 100 --slave /usr/bin/g++ g++ /usr/bin/g++-10 --slave /usr/bin/gcov gcov /usr/bin/gcov-10

      - name: Install Qt
        uses: jurplel/install-qt-action@v3
        with:
          version: 5.12.12
          modules: qtscript
          dir: "${{ github.workspace }}/Qt/"
          cache: true

      - name: Set vcpkg's response file path used as part of cache's key.
        uses: lukka/set-shell-env@master
        with:
          VCPKGRESPONSEFILE: ${{ github.workspace }}/${{ matrix.config.vcpkg-response-file }}
      - name: Restore from cache and install vcpkg
        uses: lukka/run-vcpkg@v7
        id: runvcpkg
        with:
          vcpkgArguments: "@${{ github.workspace }}/${{ matrix.config.vcpkg-response-file }}"
          vcpkgDirectory:
            "${{ github.workspace }}/ThirdParty/vcpkg"
            # Ensure the cache key changes any time the content of the response file changes.
          appendedCacheKey: ${{ hashFiles(env.VCPKGRESPONSEFILE) }}-cache-key-v2

      - name: Cache dynamic version of OpenSSL (Linux)
        if: "contains( matrix.config.os, 'ubuntu_disabled')"
        uses: actions/cache@v3
        with:
          path: ${{ github.workspace }}/ThirdParty/vcpkg/installed/x64-linux-dynamic
          key: ${{ matrix.config.os }}-vcpkg-x64-linux-dynamic_v05

      - name: Install dynamic version of OpenSSL (Linux)
        if: "contains( matrix.config.os, 'ubuntu')"
        run: |
          $VCPKG_ROOT/vcpkg install --overlay-triplets=${{ github.workspace }}/ThirdParty/vcpkg-custom-triplets --triplet x64-linux-dynamic openssl

      - name: Configure
        shell: cmake -P {0}
        run: |
          set(ENV{CC} ${{ matrix.config.cc }})
          set(ENV{CXX} ${{ matrix.config.cxx }})

          execute_process(
            COMMAND cmake
              -S .
              -B cmakebuild
              -D CMAKE_BUILD_TYPE=$ENV{BUILD_TYPE}
              -D CMAKE_INSTALL_PREFIX=cmakebuild/install
              -D RESINSIGHT_BUNDLE_OPENSSL=true
              -D RESINSIGHT_INCLUDE_APPLICATION_UNIT_TESTS=true
              -D RESINSIGHT_TREAT_WARNINGS_AS_ERRORS=true
              -D RESINSIGHT_ENABLE_GRPC=${{ matrix.config.build-python-module }}
              -D RESINSIGHT_GRPC_PYTHON_EXECUTABLE=${{ steps.python-path.outputs.PYTHON_EXECUTABLE }}
              -D RESINSIGHT_GRPC_DOWNLOAD_PYTHON_MODULE=true
              -D CMAKE_TOOLCHAIN_FILE=ThirdParty/vcpkg/scripts/buildsystems/vcpkg.cmake
              -G Ninja
            RESULT_VARIABLE result
          )
          if (NOT result EQUAL 0)
            message(FATAL_ERROR "Bad exit status")
          endif()
      - name: Build
        shell: cmake -P {0}
        run: |
          set(ENV{NINJA_STATUS} "[%f/%t %o/sec] ")
          execute_process(
            COMMAND cmake --build cmakebuild --target install
            RESULT_VARIABLE result
          )
          if (NOT result EQUAL 0)
            message(FATAL_ERROR "Bad exit status")
          endif()

      - name: Stats for buildcache
        run: ${{ github.workspace }}/buildcache/bin/buildcache -s
      - name: Run Unit Tests
        if: "matrix.config.execute-unit-tests == true"
        shell: bash
        run: |
          cmakebuild/ApplicationExeCode/ResInsight --unittest

      - name: Run pytest
        if: "matrix.config.build-python-module == true"
        env:
          RESINSIGHT_EXECUTABLE: ${{ runner.workspace }}/ResInsight/cmakebuild/ApplicationExeCode/ResInsight
        run: |
          cd GrpcInterface/Python/rips
          ${{ steps.python-path.outputs.PYTHON_EXECUTABLE }} -m pytest --console

      - name: Upload artifact
        if: matrix.config.os == 'windows-latest'
        uses: actions/upload-artifact@v3
        with:
          name: ResInsight-${{ matrix.config.name }}
          path: ${{ runner.workspace }}/ResInsight/cmakebuild/install