haskell.yml

name: Haskell CI

on:
  pull_request: # Required for workflows to be able to be approved from forks
  merge_group:

  push:
    # we need this to populate cache for `main` branch to make it available to the child branches, see
    # https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#restrictions-for-accessing-a-cache
    branches:
      - master
  # GH caches are removed when not accessed within 7 days - this schedule runs the job every 6 days making
  # sure that we always have some caches on main
  schedule:
    - cron: '0 0 */6 * *'

  # DO NOT DELETE.
  # This is required for nightly builds and is invoked by nightly-trigger.yml
  # on a schedule trigger.
  workflow_dispatch:
    inputs:
      reason:
        description: 'Reason'
        required: false
        default: manual
      tests:
        description: 'Tests'
        required: false
        default: some

jobs:
  build:
    runs-on: ${{ matrix.sys.os }}

    strategy:
      fail-fast: false
      matrix:
        # If you edit these versions, make sure the version in the lonely macos-latest job below is updated accordingly
        ghc: ["9.6", "9.8"]
        cabal: ["3.12"]
        sys:
          - { os: windows-latest, shell: 'C:/msys64/usr/bin/bash.exe -e {0}' }
          - { os: ubuntu-latest, shell: bash }
        include:
          # Using include, to make sure there will only be one macOS job, even if the matrix gets expanded later on.
          # We want a single job, because macOS runners are scarce.
          - cabal: "3.12"
            ghc: "9.6"
            sys:
              os: macos-latest
              shell: bash
    defaults:
      run:
        shell: ${{ matrix.sys.shell }}

    env:
      # Modify this value to "invalidate" the cabal cache.
      CABAL_CACHE_VERSION: "2024-07-26"
      # these two are msys2 env vars, they have no effect on non-msys2 installs.
      MSYS2_PATH_TYPE: inherit
      MSYSTEM: MINGW64

    concurrency:
      group: >
        a+${{ github.event_name }}
        b+${{ github.workflow_ref }}
        c+${{ github.job }}
        d+${{ matrix.ghc }}
        e+${{ matrix.cabal }}
        f+${{ matrix.sys.os }}
        g+${{ (startsWith(github.ref, 'refs/heads/gh-readonly-queue/') && github.run_id) || github.event.pull_request.number || github.ref }}
      cancel-in-progress: true

    steps:
    - name: Concurrency group
      run: >
        echo
        a+${{ github.event_name }}
        b+${{ github.workflow_ref }}
        c+${{ github.job }}
        d+${{ matrix.ghc }}
        e+${{ matrix.cabal }}
        f+${{ matrix.sys.os }}
        g+${{ (startsWith(github.ref, 'refs/heads/gh-readonly-queue/') && github.run_id) || github.event.pull_request.number || github.ref }}

    - name: Install Haskell
      uses: input-output-hk/actions/haskell@latest
      id: setup-haskell
      with:
        ghc-version: ${{ matrix.ghc }}
        cabal-version: ${{ matrix.cabal }}

    - name: Install system dependencies
      uses: input-output-hk/actions/base@latest
      with:
        use-sodium-vrf: true # default is true

    - uses: actions/checkout@v4

    - name: Cabal update
      run: cabal update

    - name: Configure build
      run: |
        cp .github/workflows/cabal.project.local.ci cabal.project.local
        echo "# cabal.project.local"
        cat cabal.project.local

    # A dry run `build all` operation does *NOT* downlaod anything, it just looks at the package
    # indices to generate an install plan.
    - name: Build dry run
      run: cabal build all --enable-tests --dry-run --minimize-conflict-set

    # From the install plan we generate a dependency list.
    - name: Record dependencies
      id: record-deps
      run: |
        cat dist-newstyle/cache/plan.json | jq -r '."install-plan"[] | select(.style != "local") | .id' | sort | uniq > dependencies.txt

    # Use a fresh cache each month
    - name: Store month number as environment variable used in cache version
      run:  echo "MONTHNUM=$(date -u '+%m')" >> $GITHUB_ENV

    # From the dependency list we restore the cached dependencies.
    # We use the hash of `dependencies.txt` as part of the cache key because that will be stable
    # until the `index-state` values in the `cabal.project` file changes.
    - name: Restore cached dependencies
      uses: actions/cache/restore@v4
      id: cache
      with:
        path: |
          ${{ steps.setup-haskell.outputs.cabal-store }}
          dist-newstyle
        key:
          cache-${{ env.CABAL_CACHE_VERSION }}-${{ runner.os }}-${{ matrix.ghc }}-${{ env.MONTHNUM }}-${{ hashFiles('dependencies.txt') }}
        # try to restore previous cache from this month if there's no cache for the dependencies set
        restore-keys: |
          cache-${{ env.CABAL_CACHE_VERSION }}-${{ runner.os }}-${{ matrix.ghc }}-${{ env.MONTHNUM }}-

    # Now we install the dependencies. If the cache was found and restored in the previous step,
    # this should be a no-op, but if the cache key was not found we need to build stuff so we can
    # cache it for the next step.
    - name: Install dependencies
      run: cabal build all --enable-tests --only-dependencies -j --ghc-option=-j4

    # Always store the cabal cache.
    # This can fail (benign failure) if there is already a hash at that key.
    - name: Cache Cabal store
      uses: actions/cache/save@v4
      with:
        path: |
          ${{ steps.setup-haskell.outputs.cabal-store }}
          dist-newstyle
        key:
          ${{ steps.cache.outputs.cache-primary-key }}

    # Now we build.
    - name: Build all
      run: cabal build all --enable-tests

    - name: Run tests
      env:
        TMPDIR: ${{ runner.temp }}
        TMP: ${{ runner.temp }}
        KEEP_WORKSPACE: 1
      run: |
        cabal test cardano-testnet cardano-node cardano-node-chairman cardano-submit-api

    - name: Tar failed tests workspaces
      if: ${{ failure() }}
      env:
        TMP: ${{ runner.temp }}
      run: |
        cd $TMP
        find . -name 'module' -type f -exec dirname {} \; | xargs -L1 basename | sort -u | xargs tar -czvf workspaces.tgz

    - name: Upload workspaces on tests failure
      if: ${{ failure() }}
      uses: actions/upload-artifact@v4
      with:
        name: failed-test-workspaces-${{ matrix.sys.os }}-ghc${{ matrix.ghc }}-cabal${{ matrix.cabal }}.tgz
        path: ${{ runner.temp }}/workspaces.tgz

    - name: "Tar artifacts"
      run: |
        mkdir -p artifacts

        for exe in $(cat dist-newstyle/cache/plan.json | jq -r '."install-plan"[] | select(.style == "local" and (."component-name" | startswith("exe:"))) | ."bin-file"'); do
          if [ -f $exe ]; then
            echo "Including artifact $exe"

            ( cd artifacts
              tar -C "$(dirname $exe)" -czf "$(basename $exe).tar.gz" "$(basename $exe)"
            )
          else
            echo "Skipping artifact $exe"
          fi
        done

    - name: Delete socket files in chairman tests in preparation for uploading artifacts
      if: ${{ always() }}
      run: |
        if [ -d "${{ runner.temp }}/chairman" ]; then
          find "${{ runner.temp }}/chairman" -type s -exec rm -f {} \;
        fi

    - name: Save Artifact
      uses: actions/upload-artifact@v4
      if: ${{ always() }}
      continue-on-error: true
      with:
        name: chairman-test-artifacts-${{ matrix.sys.os }}-${{ matrix.ghc }}
        path: ${{ runner.temp }}/chairman/

    # Uncomment the following back in for debugging. Remember to launch a `pwsh` from
    # the tmux session to debug `pwsh` issues. And be reminded that the `/msys2` and
    # `/msys2/mingw64` paths are not in PATH by default for the workflow, but tmate
    # will put them in.
    # You may also want to run
    #
    #   $env:PATH=("C:\Program Files\PowerShell\7;{0}" -f $env:ORIGINAL_PATH)
    #
    # to restore the original path.  Do note that some test might need msys2
    # and will silently fail if msys2 is not in path. See the "Run tests" step.
    #
    # - name: Setup tmate session
    #  if: ${{ failure() }}
    #  uses: mxschmitt/action-tmate@v3
    #  with:
    #     limit-access-to-actor: true

  build-complete:
    needs: [build]
    if: ${{ always() }}
    runs-on: ubuntu-latest
    steps:
    - name: Check if any previous job failed
      run: |
        if [[ "${{ needs.build.result }}" == "failure" ]]; then
          # this ignores skipped dependencies
          echo 'Required jobs failed to build.'
          exit 1
        else
          echo 'Build complete'
        fi

  release:
    needs: [build]
    if: ${{ startsWith(github.ref, 'refs/tags') }}
    runs-on: ubuntu-latest
    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Create Release Tag
      id: create_release_tag
      run: |
        echo "TAG=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_OUTPUT

    - name: Create Release
      id: create_release
      uses: actions/create-release@v1
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      with:
        tag_name: ${{ github.ref }}
        release_name: Release ${{ github.ref }}
        draft: true
        prerelease: false

    - name: Download Artifact
      uses: actions/download-artifact@v1
      with:
        name: artifacts-ubuntu-latest

    - name: Upload Release Asset
      uses: actions/upload-release-asset@v1
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      with:
        upload_url: ${{ steps.create_release.outputs.upload_url }}
        asset_path: ./artifacts-ubuntu-latest/cardano-submit-api.tar.gz
        asset_name: cardano-submit-api_${{ steps.create_release_tag.outputs.TAG }}-linux.tar.gz
        asset_content_type: application/gzip