release.yml

name: Release

on:
  schedule:
  # Every Monday at 07:00 (UTC)
  - cron: '00 7 * * MON'
  workflow_dispatch:
    inputs:
      release_type:
        description: 'Release type'     
        required: true
        type: choice
        options:
        - minor
        - patch
      release_branch:
        description: Branch to release
        required: true
        default: master
        type: string
      quay_repository:
        description: Quay repository    
        type: string
        default: quay.io/kiali/kiali-operator
        required: true
  
jobs:
  initialize:
    name: Initialize
    runs-on: ubuntu-20.04
    outputs:
      release_type: ${{ steps.release_type.outputs.release_type }}
      release_version: ${{ steps.release_version.outputs.release_version }}
      branch_version: ${{ steps.branch_version.outputs.branch_version }}
      next_version: ${{ steps.next_version.outputs.next_version }}
      quay_tag: ${{ steps.quay_tag.outputs.quay_tag }}
    steps:
    - name: Checkout code
      uses: actions/checkout@v4
      with:
        ref: ${{ github.event.inputs.release_branch || github.ref_name }}

    - name: Prepare scripts
      run: |
        cat <<-EOF > bump.py
        import sys
        release_type = sys.argv[1]
        version = sys.argv[2]
        parts = version.split('.')
        major = int(parts[0][1:])
        minor = int(parts[1])
        patch = int(parts[2])
        if release_type == 'major':
            major = major + 1
            minor = 0
            patch = 0
        elif release_type == 'minor':
            minor = minor + 1 
            patch = 0
        elif release_type == 'patch':
            patch = patch + 1
        print('.'.join(['v' + str(major), str(minor), str(patch)]))
        EOF
        
        cat <<-EOF > minor.py
        import datetime

        # The base date can be any end of sprint from the past
        base = int(datetime.datetime.strptime("24/04/2022", "%d/%m/%Y").timestamp())
        now = int(datetime.datetime.now().timestamp())

        diff = now - base

        days_elapsed = int(diff / (24*60*60))
        weeks_elapsed = int(days_elapsed / 7)
        weeks_mod3 = int(weeks_elapsed % 3)

        print(weeks_mod3)
        EOF

    - name: Determine release type
      id: release_type
      run: |
        if [ -z ${{ github.event.inputs.release_type }} ];
        then
          DO_RELEASE=$(python minor.py)
          if [[ $DO_RELEASE == "1" ]]
          then
            echo "release_type=minor" >> $GITHUB_OUTPUT
          else
            echo "release_type=skip" >> $GITHUB_OUTPUT
          fi
        else
          echo "release_type=${{ github.event.inputs.release_type }}" >> $GITHUB_OUTPUT
        fi
    
    - name: Determine release version
      if: ${{ steps.release_type.outputs.release_type != 'skip' }}
      env:
        RELEASE_TYPE: ${{ steps.release_type.outputs.release_type }}
      id: release_version
      run: |
        RAW_VERSION=$(sed -rn 's/^VERSION \?= (.*)/\1/p' Makefile)

        # Remove any pre release identifier (ie: "-SNAPSHOT")
        RELEASE_VERSION=${RAW_VERSION%-*}

        if [[ $RELEASE_TYPE == "patch" ]]
        then
          RELEASE_VERSION=$(python bump.py $RELEASE_TYPE $RELEASE_VERSION)
        elif [[ $RELEASE_TYPE == "minor" ]]
        then
          RELEASE_VERSION=$RELEASE_VERSION
        fi

        echo "release_version=$RELEASE_VERSION" >> $GITHUB_OUTPUT
    
    - name: Determine next version
      if: ${{ steps.release_type.outputs.release_type != 'skip' }}
      env:
        RELEASE_TYPE: ${{ steps.release_type.outputs.release_type }}
        RELEASE_VERSION: ${{ steps.release_version.outputs.release_version }}
      id: next_version
      run: |
        if [[ $RELEASE_TYPE == "patch" ]]
        then
            NEXT_VERSION=$(python bump.py $RELEASE_TYPE $RELEASE_VERSION)
        elif [[ $RELEASE_TYPE == "minor" ]]
        then 
            NEXT_VERSION=$(python bump.py $RELEASE_TYPE $RELEASE_VERSION)
        fi

        echo "next_version=$NEXT_VERSION" >> $GITHUB_OUTPUT

    - name: Determine branch version
      if: ${{ steps.release_type.outputs.release_type != 'skip' }}
      env:
        RELEASE_VERSION: ${{ steps.release_version.outputs.release_version }}
      id: branch_version
      run: |
        echo "branch_version=$(echo $RELEASE_VERSION | sed 's/\.[0-9]*\+$//')" >> $GITHUB_OUTPUT

    - name: Determine Quay tag
      if: ${{ steps.release_type.outputs.release_type != 'skip' }}
      env:
        RELEASE_VERSION: ${{ steps.release_version.outputs.release_version }}
        BRANCH_VERSION: ${{ steps.branch_version.outputs.branch_version }}
      id: quay_tag
      run: |
        if [ -z ${{ github.event.inputs.quay_repository }} ];
        then
          QUAY_REPO="quay.io/kiali/kiali-operator"
        else
          QUAY_REPO="${{ github.event.inputs.quay_repository }}"
        fi

        QUAY_TAG="$QUAY_REPO:$RELEASE_VERSION $QUAY_REPO:$BRANCH_VERSION"
        
        echo "quay_tag=$QUAY_TAG" >> $GITHUB_OUTPUT
    
    - name: Cleanup
      run: rm bump.py minor.py

    - name: Log information
      run: |
        echo "Release type: ${{ steps.release_type.outputs.release_type }}"
      
        echo "Release version: ${{ steps.release_version.outputs.release_version }}"
     
        echo "Next version: ${{ steps.next_version.outputs.next_version }}"

        echo "Branch version: ${{ steps.branch_version.outputs.branch_version }}"
        
        echo "Quay tag": ${{ steps.quay_tag.outputs.quay_tag }}

  release:
    name: Release
    if: ${{ needs.initialize.outputs.release_type != 'skip' && ((github.event_name == 'schedule' && github.repository == 'kiali/kiali-operator') || github.event_name != 'schedule') }}
    runs-on: ubuntu-20.04
    needs: [initialize]
    env:
      RELEASE_TYPE: ${{ needs.initialize.outputs.release_type }}
      RELEASE_VERSION: ${{ needs.initialize.outputs.release_version }}
      BRANCH_VERSION: ${{ needs.initialize.outputs.branch_version }}
      NEXT_VERSION: ${{ needs.initialize.outputs.next_version }}
      RELEASE_BRANCH: ${{ github.event.inputs.release_branch || github.ref_name }}
      OPERATOR_QUAY_TAG: ${{ needs.initialize.outputs.quay_tag }}
    steps:
    - name: Checkout code
      uses: actions/checkout@v4
      with:
        ref: ${{ github.event.inputs.release_branch || github.ref_name }}
    
    - name: Set version to release
      run: sed -i -r "s/^VERSION \?= (.*)/VERSION \?= $RELEASE_VERSION/" Makefile

    - name: Build and push image
      run: |
        docker login -u ${{ secrets.QUAY_USER }} -p ${{ secrets.QUAY_PASSWORD }} quay.io
        
        make -e DOCKER_CLI_EXPERIMENTAL=enabled container-multi-arch-push-kiali-operator-quay
    
    - name: Configure git
      run: |
        git config user.email 'kiali-dev@googlegroups.com'
        
        git config user.name 'kiali-bot'

    - name: Create tag
      run: |
        # Skip OLM metadata for patch releases
        if [[ $RELEASE_TYPE == "minor" ]]
        then
          VERSION_TO_RELEASE=${RELEASE_VERSION:1}
          DATETIME_NOW="$(date --utc +'%FT%TZ')"
          CSV_UPSTREAM_FILE="./manifests/kiali-upstream/${VERSION_TO_RELEASE}/manifests/kiali.v${VERSION_TO_RELEASE}.clusterserviceversion.yaml"
          CSV_COMMUNITY_FILE="./manifests/kiali-community/${VERSION_TO_RELEASE}/manifests/kiali.v${VERSION_TO_RELEASE}.clusterserviceversion.yaml"
          for csv in ${CSV_UPSTREAM_FILE} ${CSV_COMMUNITY_FILE}
          do
            rm -f /tmp/kiali-csv-changes.txt
            sed -i "s/createdAt: .\+Z/createdAt: ${DATETIME_NOW}/gw /tmp/kiali-csv-changes.txt" ${csv}
            if [ ! -s /tmp/kiali-csv-changes.txt ]; then
              echo "It looks like 'createdAt' metadata was not changed in the new CSV file. Check the new CSV file for correctness."
              echo CSV FILE: ${csv}
              # we could abort the build here, but this would not be a blocker so we could just let the build keep going
            fi
          done

          git add $CSV_UPSTREAM_FILE $CSV_COMMUNITY_FILE
        fi

        git add Makefile
        
        git commit -m "Release $RELEASE_VERSION"
        
        git push origin $(git rev-parse HEAD):refs/tags/$RELEASE_VERSION
        
    - name: Create release
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      run: |
        gh release create $RELEASE_VERSION -t "Kiali Operator $RELEASE_VERSION"
    
    - name: Create or update version branch      
      run: git push origin $(git rev-parse HEAD):refs/heads/$BRANCH_VERSION

    - name: Configure Operator SDK
      if: ${{ needs.initialize.outputs.release_type == 'minor' }}
      run: |
        make get-operator-sdk

    - name: Create a PR to prepare for next version
      env:
        BUILD_TAG: kiali-operator-release-${{ github.run_number }}-main
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      if: ${{ needs.initialize.outputs.release_type == 'minor' }}
      run: |
        export PATH="$PATH:$GITHUB_WORKSPACE/_output/operator-sdk-install"

        sed -i -r "s/^VERSION \?= (.*)/VERSION \?= $NEXT_VERSION-SNAPSHOT/" Makefile      
        
        # Using versions without the prefix 'v'        
        ./manifests/create-new-version.sh -nv ${NEXT_VERSION:1} -ov ${RELEASE_VERSION:1} -om kiali-upstream/
        ./manifests/create-new-version.sh -nv ${NEXT_VERSION:1} -ov ${RELEASE_VERSION:1} -om kiali-community/

        git add Makefile manifests/

        git commit -m "Prepare for next version"
        
        git push origin $(git rev-parse HEAD):refs/heads/$BUILD_TAG
        
        gh pr create -t "Prepare for next version" -b "Please, merge to update version numbers and prepare for release $NEXT_VERSION." -H $BUILD_TAG -B $RELEASE_BRANCH