Jenkinsfile

/*
 * The Jenkins job should be configured with the following properties:
 *
 * - Disable concurrent builds
 * - Parameters (all must be trimmed; all are strings):
 *   - RELEASE_TYPE
 *      defaultValue: auto
 *      description: Valid values are: auto, minor, snapshot.0, snapshot.1, edge. When "auto" is
 *                   specified, the type of the release will be determined based on the current date.
 *   - BACKEND_RELEASING_BRANCH
 *      defaultValue: refs/heads/master
 *      description: Branch of the backend to release
 *   - UI_RELEASING_BRANCH
 *      defaultValue: refs/heads/master
 *      description: Branch of the UI to release
 *   - SITE_RELEASING_BRANCH
 *      defaultValue: refs/heads/master
 *      description: Branch of the website to release
 *   - OPERATOR_RELEASING_BRANCH
 *      defaultValue: refs/heads/master
 *      description: Branch of the operator to release
 *   - BACKEND_GITHUB_URI
 *      defaultValue: git@github.com:kiali/kiali.git
 *      description: SSH Url of the kiali-backend GitHub repository
 *   - UI_GITHUB_URI
 *      defaultValue: git@github.com:kiali/kiali-ui.git
 *      description: SSH Url of the kiali-ui GitHub repository
 *   - OPERATOR_REPO
 *      defaultValue: kiali/kiali-operator
 *      description: The GitHub repo of the kiali-operator sources, in owner/repo format.
 *   - SITE_REPO
 *      defaultValue: kiali/kiali.io
 *      description: The GitHub repo of the website sources, in owner/repo format.
 *   - HELM_REPO
 *      defaultValue: kiali/helm-charts
 *      description: The GitHub repo of the Helm charts sources, in owner/repo format.
 *   - QUAY_NAME
 *      defaultValue: quay.io/kiali/kiali
 *      description: The name of the Quay repository to push the release
 *   - QUAY_OPERATOR_NAME
 *      defaultValue: quay.io/kiali/kiali-operator
 *      description: The name of the Quay repository to push the operator release
 *   - BACKEND_PULL_URI
 *      defaultValue: https://api.github.com/repos/kiali/kiali/pulls
 *      description: The URL of the GitHub API to use to create pull requests for the back-end (changes to prepare for next version)
 *   - UI_PULL_URI
 *      defaultValue: https://api.github.com/repos/kiali/kiali-ui/pulls
 *      description: The URL of the GitHub API to use to create pull requests for the UI (changes to prepare for next version)
 *   - NPM_DRY_RUN
 *      defaultValue: n
 *      description: Set to "y" if you want to make a "dry run" of the front-end release process
 *   - SKIP_UI_RELEASE
 *      defaultValue: n
 *      description: Set to 'y' if you don't want to release the UI
 *   - SKIP_BACKEND_RELEASE
 *      defaultValue: n
 *      description: Set to 'y' if you don't want to release the backend
 *   - SKIP_OPERATOR_RELEASE
 *      defaultValue: n
 *      description: Set to 'y' if you don't want to release the operator
 *   - SKIP_HELM_RELEASE
 *      defaultValue: n
 *      description: Set to 'y' if you don't want to release the helm charts
 *   - SKIP_SITE_RELEASE
 *      defaultValue: n
 *      description: Set to 'y' if you don't want to release the website
 *   - UI_VERSION
 *       defaultValue: ''
 *       description: If you are skipping UI release. Specify the UI version to package, or leave
 *                    unset to use the version present in the main Makefile (e.g. leave unset for patch releases)
 *   - NPM_CONFIG_REGISTRY
 *       defaultValue: ''
 *       description: Registry to use for fetching packages. This is not used for publishing releases.
 *                    Do not include the trailing slash.
 */

node('kiali-build && fedora') {
  def (backendForkUri, uiForkUri) = ['git@github.com:kiali-bot/kiali.git', 'git@github.com:kiali-bot/kiali-ui.git']
  def (backendDir, uiDir) = ['src/github.com/kiali/kiali', 'src/github.com/kiali/kiali-ui']
  def (backendMakefile, uiMakefile) = ['deploy/jenkins-ci/Makefile', 'Makefile.jenkins']
  def buildUi = params.SKIP_UI_RELEASE != "y"
  def buildBackend = params.SKIP_BACKEND_RELEASE != "y"
  def buildOperator = params.SKIP_OPERATOR_RELEASE != "y"
  def buildHelm = params.SKIP_HELM_RELEASE != "y" // Temptative value. It's re-assigned later.
  def buildSite = params.SKIP_SITE_RELEASE != "y" // Temptative value. It's re-assigned later.
  def quayTag = ""

  if ( !buildBackend && !buildUi && !buildOperator && !buildHelm && !buildSite ) {
    currentBuild.result = 'ABORTED'
    echo "Nothing to release. Stopping."
    return
  }

  try {
    cleanWs()
    stage('Checkout code') {
      if ( buildBackend || buildOperator || buildHelm || buildSite ) {
        checkout([
          $class: 'GitSCM',
          branches: [[name: params.BACKEND_RELEASING_BRANCH]],
          doGenerateSubmoduleConfigurations: false,
          extensions: [
            [$class: 'RelativeTargetDirectory', relativeTargetDir: backendDir]
          ],
          submoduleCfg: [],
          userRemoteConfigs: [[
            credentialsId: 'kiali-bot-gh-ssh',
            url: params.BACKEND_GITHUB_URI]]
        ])

        sh "cd ${backendDir}; git config user.email 'kiali-dev@googlegroups.com'"
        sh "cd ${backendDir}; git config user.name 'kiali-bot'"
      }
      if ( buildUi ) {
        checkout([
          $class: 'GitSCM',
          branches: [[name: params.UI_RELEASING_BRANCH]],
          doGenerateSubmoduleConfigurations: false,
          extensions: [
            [$class: 'RelativeTargetDirectory', relativeTargetDir: uiDir]
          ],
          submoduleCfg: [],
          userRemoteConfigs: [[
            credentialsId: 'kiali-bot-gh-ssh',
            url: params.UI_GITHUB_URI]]
        ])

        sh "cd ${uiDir}; git config user.email 'kiali-dev@googlegroups.com'"
        sh "cd ${uiDir}; git config user.name 'kiali-bot'"
      }
    }

    // Determine release type if "auto" was specified
    def releaseType = "${params.RELEASE_TYPE}"
    if ( releaseType == "auto" ) {
      releaseType = sh(
        returnStdout: true,
        script: "${backendDir}/deploy/jenkins-ci/bin/determine-release-type.sh").trim()
    }

    buildSite = params.SKIP_SITE_RELEASE != "y" && releaseType == "minor"
    buildHelm = params.SKIP_HELM_RELEASE != "y" && releaseType == "minor"
    echo "Resolved release type: ${releaseType}"
    echo "Will build Helm charts? ${buildHelm}"
    echo "Will build operator? ${buildOperator}"
    echo "Will build site? ${buildSite}"

    withEnv(["PATH+TOOLS=${env.WORKSPACE}/${backendDir}/deploy/jenkins-ci/bin",
            "GOPATH=${env.WORKSPACE}",
            "BACKEND_FORK_URI=${backendForkUri}",
            "UI_FORK_URI=${uiForkUri}",
            "RELEASE_TYPE=${releaseType}"
    ]) {
      parallel backend: {
        withEnv(["GOPATH=${env.WORKSPACE}"]) {
          stage('Build backend') {
            if ( buildBackend ) {
              sh "make -f ${backendMakefile} -C ${backendDir} backend-build-release"
            }
          }
          stage('Test backend') {
            if ( buildBackend ) {
              sh "make -f ${backendMakefile} -C ${backendDir} backend-test"
            }
          }
        }
      }, ui: {
        stage('Build UI') {
          if ( buildUi ) {
            sh "make -f ${uiMakefile} -C ${uiDir} ui-fix-version ui-build"
          }
        }
        stage('Test UI') {
          if ( buildUi ) {
            sh "make -f ${uiMakefile} -C ${uiDir} ui-test"
          }
        }
      },

      failFast: true

      stage('Release kiali-ui to NPM') {
        if ( buildUi ) {
          withCredentials([string(credentialsId: 'kiali-npm', variable: 'NPM_TOKEN')]) {
            sh "make -f ${uiMakefile} -C ${uiDir} ui-npm-publish"
          }
        }
      }

      stage('Create release cut in front-end repo') {
        if ( buildUi ) {
          withCredentials([string(credentialsId: 'kiali-bot-gh-token', variable: 'GH_TOKEN')]) {
            sshagent(['kiali-bot-gh-ssh']) {
              sh "make -f ${uiMakefile} -C ${uiDir} ui-push-version-tag ui-prepare-next-version"
            }
          }
        }
      }

      stage('Release Kiali to Container Repositories') {
        if ( buildBackend ) {
          withCredentials([usernamePassword(credentialsId: 'kiali-quay', passwordVariable: 'QUAY_PASSWORD', usernameVariable: 'QUAY_USER')]) {
            sh "make -f ${backendMakefile} -C ${backendDir} backend-push-docker"
            quayTag = sh(returnStdout: true, script: "sed -rn 's/^VERSION \\?= v(.*)/v\\1/p' ${backendDir}/Makefile").trim()
          }
        }
      }

      stage('Create release cut in back-end repo') {
        if ( buildBackend ) {
          withCredentials([string(credentialsId: 'kiali-bot-gh-token', variable: 'GH_TOKEN')]) {
            sshagent(['kiali-bot-gh-ssh']) {
              sh "make -f ${backendMakefile} -C ${backendDir} backend-push-version-tag backend-prepare-next-version"
            }
          }
        }
      }

      stage('Invoke other jobs') {
        if ( buildOperator ) {
          build(job: 'kiali-operator-release',
              parameters: [
              [$class: 'StringParameterValue', value: releaseType, name: 'RELEASE_TYPE'],
              [$class: 'StringParameterValue', value: params.OPERATOR_REPO, name: 'OPERATOR_REPO'],
              [$class: 'StringParameterValue', value: params.OPERATOR_RELEASING_BRANCH, name: 'OPERATOR_RELEASING_BRANCH'],
              [$class: 'StringParameterValue', value: params.QUAY_OPERATOR_NAME, name: 'QUAY_OPERATOR_NAME']
              ], wait: false
              )
        }
        if ( buildSite ) {
          build(job: 'kiali-website-release',
              parameters: [
              [$class: 'StringParameterValue', value: params.SITE_REPO, name: 'SITE_REPO'],
              [$class: 'StringParameterValue', value: params.SITE_RELEASING_BRANCH, name: 'SITE_RELEASING_BRANCH']
              ], wait: false
              )
        }
        if ( buildHelm ) {
          build(job: 'kiali-helm-release',
              parameters: [
              [$class: 'StringParameterValue', value: releaseType, name: 'RELEASE_TYPE'],
              [$class: 'StringParameterValue', value: params.HELM_REPO, name: 'HELM_REPO']
              ], wait: false
              )
        }
      }

      stage('Post Msg Bus Notification') {
        if ( releaseType == "minor" ) {
          build(job: 'kiali-release-notifier',
              parameters: [
              [$class: 'StringParameterValue', value: 'minor', name: 'RELEASE_TYPE'],
              [$class: 'StringParameterValue', value: "${params.QUAY_NAME}", name: 'QUAY_NAME'],
              [$class: 'StringParameterValue', value: quayTag, name: 'QUAY_TAG']
              ], wait: false
              )
        }
      }
    }
  } finally {
    cleanWs()
  }
}