release_dispatch.yml

name: MODFLOW 6 release dispatch
on:
  push:
    branches:
      # initial phase of the release procedure is triggered by pushing a release branch
      - v[0-9]+.[0-9]+.[0-9]+*
      # intermediate phase is triggered by merging the release branch to master
      - master
  # final phase is triggered by promoting/publishing a GitHub release draft to a full release
  release:
    types:
      - published
  # workflow_dispatch trigger to start release via GitHub UI or CLI,
  # as an alternative to triggering when a release branch is pushed.
  # see https://docs.github.com/en/actions/managing-workflow-runs/manually-running-a-workflow
  workflow_dispatch:
    inputs:
      approve:
        description: 'Approve the release. Otherwise it is preliminary/provisional.'
        required: false
        type: boolean
        default: false
      branch:
        description: 'Branch to release from.'
        required: true
        type: string
      compiler_toolchain:
        description: 'Compiler toolchain to use. For supported options see https://github.com/MODFLOW-USGS/modflow6/blob/develop/DEVELOPER.md#compiler-compatibility.'
        required: false
        type: string
        default: 'intel-classic'
      compiler_version:
        description: 'Compiler version to use. For supported options see https://github.com/MODFLOW-USGS/modflow6/blob/develop/DEVELOPER.md#compiler-compatibility.'
        required: false
        type: string
        default: '2021.7'
      commit_version:
        description: 'Commit version numbers back to the develop branch. Not considered if reset is false.'
        required: false
        type: boolean
        default: false
      reset:
        description: 'Reset the develop branch from the master branch. Not considered if approve is false.'
        required: false
        type: boolean
        default: false
      run_tests:
        description: 'Run tests after building binaries.'
        required: false
        type: boolean
        default: true
      version:
        description: 'Version number to use for release.'
        required: true
        type: string
jobs:
  set_options:
    name: Set release options
    if: github.ref_name != 'master'
    runs-on: ubuntu-22.04
    defaults:
      run:
        shell: bash -l {0}
    outputs:
      branch: ${{ steps.set_branch.outputs.branch }}
      compiler_toolchain: ${{ steps.set_compiler.outputs.compiler_toolchain }}
      compiler_version: ${{ steps.set_compiler.outputs.compiler_version }}
      version: ${{ steps.set_version.outputs.version }}
    steps:
      - name: Set branch
        id: set_branch
        run: |
          # if branch was provided explicitly via workflow_dispatch, use it
          if [[ ("${{ github.event_name }}" == "workflow_dispatch") && (-n "${{ inputs.branch }}") ]]; then
            branch="${{ inputs.branch }}"
            # prevent releases from master
            if [[ "$branch" == "master" ]]; then
              echo "error: releases may not be triggered from branch $branch"
              exit 1
            fi
            echo "using branch $branch from workflow_dispatch"
          elif [[ ("${{ github.event_name }}" == "push") && ("${{ github.ref_name }}" != "master") ]]; then
            # if release was triggered by pushing a release branch, use that branch
            branch="${{ github.ref_name }}"
            echo "using branch $branch from ref ${{ github.ref }}"
          else
            # otherwise exit with an error
            echo "error: this workflow should not have triggered for event ${{ github.event_name }} on branch ${{ github.ref_name }}"
            exit 1
          fi
          echo "branch=$branch" >> $GITHUB_OUTPUT
      - name: Set compiler
        id: set_compiler
        run: |
          # if compiler toolchain was provided explicitly via workflow_dispatch, use it
          if [[ ("${{ github.event_name }}" == "workflow_dispatch") && (-n "${{ inputs.compiler_toolchain }}") ]]; then
            compiler_toolchain="${{ inputs.compiler_toolchain }}"
            compiler_version="${{ inputs.compiler_version }}"
            echo "using compiler toolchain $compiler_toolchain version $compiler_version from workflow_dispatch"
          elif [[ ("${{ github.event_name }}" == "push") && ("${{ github.ref_name }}" != "master") ]]; then
            # if release was triggered by pushing a release branch, use the default toolchain and version
            compiler_toolchain="intel-classic"
            compiler_version="2021.7"
            echo "using default compiler toolchain $compiler_toolchain version $compiler_version"
          else
            # otherwise exit with an error
            echo "error: this workflow should not have triggered for event ${{ github.event_name }} on branch ${{ github.ref_name }}"
            exit 1
          fi
          echo "compiler_toolchain=$compiler_toolchain" >> $GITHUB_OUTPUT
          echo "compiler_version=$compiler_version" >> $GITHUB_OUTPUT
      - name: Set version
        id: set_version
        run: |
          # if version number was provided explicitly via workflow_dispatch, use it
          if [[ ("${{ github.event_name }}" == "workflow_dispatch") && (-n "${{ inputs.version }}") ]]; then
            ver="${{ inputs.version }}"
            echo "using version number $ver from workflow_dispatch"
          elif [[ ("${{ github.event_name }}" == "push") && ("${{ github.ref_name }}" != "master") ]]; then
            # if release was triggered by pushing a release branch, parse version number from branch name (sans leading 'v')
            ref="${{ github.ref_name }}"
            ver="${ref#"v"}"
            echo "parsed version number $ver from branch name $ref"
          else
            # otherwise exit with an error
            echo "error: version number not provided explicitly (via workflow_dispatch input) or implicitly (via branch name)"
            exit 1
          fi
          echo "version=$ver" >> $GITHUB_OUTPUT
  make_dist:
    name: Make distribution
    needs: set_options
    uses: MODFLOW-USGS/modflow6/.github/workflows/release.yml@develop
    with:
      # If the workflow is manually triggered, the maintainer must manually set approve=true to approve a release.
      # If triggered by pushing a release branch, the release is approved if the branch name doesn't contain "rc".
      approve: ${{ (github.event_name == 'workflow_dispatch' && inputs.approve == 'true') || (github.event_name != 'workflow_dispatch' && !contains(github.ref_name, 'rc')) }}
      compiler_toolchain: ${{ needs.set_options.outputs.compiler_toolchain }}
      compiler_version: ${{ needs.set_options.outputs.compiler_version }}
      branch: ${{ needs.set_options.outputs.branch }}
      developmode: false
      full: true
      run_tests: ${{ inputs.run_tests == '' || inputs.run_tests == 'true' }}
      version: ${{ needs.set_options.outputs.version }}
  pr:
    name: Draft release PR
    if: ${{ github.ref_name != 'master' && ((github.event_name == 'workflow_dispatch' && inputs.approve == 'true') || (github.event_name != 'workflow_dispatch' && !contains(github.ref_name, 'rc'))) }}
    needs:
      - set_options
      - make_dist
    runs-on: ubuntu-22.04
    permissions:
      contents: write
      pull-requests: write
    defaults:
      run:
        shell: bash -l {0}
    steps:
      - name: Checkout modflow6
        uses: actions/checkout@v4
        with:
          repository: ${{ github.repository_owner }}/modflow6
          ref: ${{ github.ref }}

      - name: Setup Micromamba
        uses: mamba-org/setup-micromamba@v1
        with:
          environment-file: environment.yml
          cache-downloads: true
          cache-environment: true

      - name: Update version
        working-directory: distribution
        run: |
          # update version files
          ver="${{ needs.set_options.outputs.version }}"
          # approve will be empty if workflow was triggered by pushing a release branch
          # todo: pull approve into set_options job/output?
          if [[ ("${{ inputs.approve }}" == "true") || ("${{ inputs.approve }}" == "") ]]; then
            python update_version.py -v "$ver" --approve
          else
            python update_version.py -v "$ver"
          fi
          
          # lint version.f90
          fprettify -c ../.fprettify.yaml ../src/Utilities/version.f90
          
          # commit and push
          git config core.sharedRepository true
          git config user.name "github-actions[bot]"
          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git add -A
          git commit -m "ci(release): update version to $ver"
          git push origin "${{ github.ref }}"

      - name: Create pull request
        env:
          GITHUB_TOKEN: ${{ github.token }}
        run: |
          ver="${{ needs.set_options.outputs.version }}"
          body='
          # MODFLOW '$ver' release
          
          The release can be approved by merging this PR into `master`. Merging rather than squashing is necessary to preserve the commit history.
          
          When this PR is merged, a final job will be triggered to:
          1) create and tag a draft GitHub release, then upload assets (OS distributions and release notes)
          2) open a PR to update `develop` from `master`, resetting version files and setting `IDEVELOPMODE=1`
          '
          gh pr create -B "master" -H "${{ github.ref }}" --title "Release $ver" --draft --body "$body"

  release:
    name: Draft release
    # runs only after release PR is merged to master
    if: github.event_name == 'push' && github.ref_name == 'master'
    runs-on: ubuntu-22.04
    defaults:
      run:
        shell: bash -l {0}
    steps:
      - name: Checkout modflow6
        uses: actions/checkout@v4
        with:
          repository: ${{ github.repository_owner }}/modflow6
          path: modflow6

      - name: Setup Micromamba
        uses: mamba-org/setup-micromamba@v1
        with:
          environment-file: modflow6/environment.yml
          cache-downloads: true
          cache-environment: true

      - name: Download artifacts
        uses: dawidd6/action-download-artifact@v3

      - name: Draft release
        working-directory: modflow6
        env:
          GITHUB_TOKEN: ${{ github.token }}
        run: |
          # create draft release
          ver=$(python distribution/update_version.py -g)
          title="MODFLOW $ver"
          notes='
          This is the approved USGS MODFLOW '$ver' release.
      
          *Insert citation here*
      
          Visit the USGS "MODFLOW and Related Programs" site for information on MODFLOW 6 and related software: https://doi.org/10.5066/F76Q1VQV
          '
          gh release create "$ver" ../mf*/mf*.zip ../release_notes/release.pdf --target master --title "$title" --notes "$notes" --draft --latest

  reset:
    name: Draft reset PR
    # runs only after GitHub release post is published (promoted from draft to public)
    # to bring release commits from master back into develop and reset IDEVELOPMODE=1.
    if: github.event_name == 'release' && (inputs.reset == 'true' || inputs.reset == '')
    runs-on: ubuntu-22.04
    defaults:
      run:
        shell: bash -l {0}
    steps:

      - name: Checkout modflow6
        uses: actions/checkout@v4
        with:
          repository: ${{ github.repository_owner }}/modflow6
          path: modflow6

      - name: Setup Micromamba
        uses: mamba-org/setup-micromamba@v1
        with:
          environment-file: modflow6/environment.yml
          cache-downloads: true
          cache-environment: true

      - name: Get release tag
        uses: oprypin/find-latest-tag@v1
        id: latest_tag
        with:
          repository: ${{ github.repository }}
          releases-only: true

      - name: Create pull request
        working-directory: modflow6
        env:
          GITHUB_TOKEN: ${{ github.token }}
        run: |
          # create reset branch from master
          reset_branch="post-release-${{ steps.latest_tag.outputs.tag }}-reset"
          git fetch origin
          git checkout master
          git switch -c $reset_branch

          # configure git
          git config core.sharedRepository true
          git config user.name "github-actions[bot]"
          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"

          # updating version numbers if enabled
          if [[ ("${{ inputs.commit_version }}" == "true") || ("${{ inputs.commit_version }}" == "") ]]; then
            ver="${{ steps.latest_tag.outputs.tag }}"
            python distribution/update_version.py -v "$ver"
            git add -A
            git commit -m "ci(release): update version to $ver, reset IDEVELOPMODE to 1"
          else
            # in either case we at least need to reset IDEVELOPMODE to 1
            python distribution/update_version.py
            git add -A
            git commit -m "ci(release): reset IDEVELOPMODE to 1"
          fi
          
          # push reset branch
          git push -u origin $reset_branch

          # create PR into develop
          body='
          Reinitialize the `develop` branch following a successful release.
          '
          gh pr create -B "develop" -H "$reset_branch" --title "Reinitialize develop branch" --draft --body "$body