Jenkinsfile.release

import org.jenkinsci.plugins.workflow.libs.Library

@Library('jenkins-pipeline-shared-libraries')_

kogitoRuntimesRepo = 'kogito-runtimes'
kogitoAppsRepo = 'kogito-apps'
kogitoExamplesRepo = 'kogito-examples'

ARTIFACTS_STAGING_STAGE = 'stage.artifacts.staging'
ARTIFACTS_RELEASE_STAGE = 'stage.artifacts.release'

JOB_PROPERTY_PREFIX = 'build'
JOB_RESULT_PROPERTY_KEY = 'result'
JOB_URL_PROPERTY_KEY = 'absoluteUrl'
JOB_DECISION_PROPERTY_KEY = 'decision'
JOB_DECISION_MESSAGE_PROPERTY_KEY = 'decisionMessage'

releaseProperties = [:]

pipeline {
    agent {
        label 'kie-rhel8 && !built-in'
    }

    // parameters {
    // For parameters, check into ./dsl/jobs.groovy file
    // }

    environment {
        // Some generated env is also defined into ./dsl/jobs.groovy file

        KOGITO_CI_EMAIL_TO = credentials("${JENKINS_EMAIL_CREDS_ID}")
    }

    stages {
        stage('Initialize') {
            steps {
                script {
                    // Restore config from previous run
                    if (params.RESTORE_FROM_PREVIOUS_JOB) {
                        releaseProperties = readPropertiesFromUrl(params.RESTORE_FROM_PREVIOUS_JOB, 'release.properties')
                        echo "Release properties imported from previous job: ${releaseProperties}"
                    }

                    assert getDroolsVersion()
                    assert getKogitoVersion()

                    currentBuild.displayName = getDisplayName()

                    sendNotification("Release Pipeline has started...\nKogito version = ${getKogitoVersion()}\n=> ${env.BUILD_URL}")

                    // Safety measure to not publish to main JBoss
                    if (getGitAuthor() != 'kiegroup' && !getArtifactsRepositoryParam()) {
                        sendNotification("Git Author is different from `kiegroup` and no `ARTIFACTS_REPOSITORY` parameter has been provided. Are you sure you want to continue ? => ${env.BUILD_URL}input")
                        input message: 'Should the pipeline continue with no `ARTIFACTS_REPOSITORY` defined ?', ok: 'Yes'
                    }
                }
            }
            post {
                always {
                    setReleasePropertyIfneeded('kogito.version', getKogitoVersion())
                }
            }
        }

        stage('Build & Deploy Kogito Runtimes') {
            steps {
                script {
                    def buildParams = getDefaultBuildParams(getKogitoVersion())
                    addSkipTestsParam(buildParams)
                    addStringParam(buildParams, 'DROOLS_VERSION', getDroolsVersion())

                    buildJob(getDeployJobName(kogitoRuntimesRepo), buildParams)
                }
            }
        }

        stage('Build & Deploy Kogito Apps') {
            steps {
                script {
                    def buildParams = getDefaultBuildParams(getKogitoVersion())
                    addSkipTestsParam(buildParams)

                    buildJob(getDeployJobName(kogitoAppsRepo), buildParams)
                }
            }
        }

        stage('Build & Deploy Kogito Examples') {
            steps {
                script {
                    def buildParams = getDefaultBuildParams(getKogitoVersion())
                    addSkipTestsParam(buildParams)
                    addStringParam(buildParams, 'DROOLS_VERSION', getDroolsVersion())

                    buildJob(getDeployJobName(kogitoExamplesRepo), buildParams)
                }
            }
        }

        stage('Artifacts\' staging finalization') {
            steps {
                script {
                    if (!areArtifactsStaged()) {
                        sendNotification("All artifacts have been staged. You can find them here: ${getStagingRepository()}")
                    }
                    setArtifactsStaged()
                }
            }
        }

        stage('Are staged artifacts released?') {
            when {
                // Execute only if artifacts repository was not given, which means the staging repository has been created
                expression { return !getArtifactsRepositoryParam() && !areArtifactsReleased() }
            }
            steps {
                script {
                    String body = "${getKogitoVersion()} artifacts are ready for release.\n" +
                                 "Please release the staging repositories and then confirm here: ${env.BUILD_URL}input"
                    sendNotification(body)
                    input message: 'Has the staging repository been released ?', ok: 'Yes'

                    sendNotification('Artifacts have been released. Finalizing now the release ...')
                    setArtifactsReleased()
                }
            }
        }

        stage('Promote Kogito Runtimes') {
            when {
                expression { return isJobConsideredOk(getDeployJobName(kogitoRuntimesRepo)) }
            }
            steps {
                script {
                    def buildParams = getDefaultBuildParams(getKogitoVersion())
                    addDeployBuildUrlParam(buildParams, getDeployJobName(kogitoRuntimesRepo))
                    addStringParam(buildParams, 'DROOLS_VERSION', getDroolsVersion())

                    buildJob(getPromoteJobName(kogitoRuntimesRepo), buildParams)
                }
            }
        }

        stage('Promote Kogito Apps') {
            when {
                expression { return isJobConsideredOk(getDeployJobName(kogitoAppsRepo)) }
            }
            steps {
                script {
                    def buildParams = getDefaultBuildParams(getKogitoVersion())
                    addDeployBuildUrlParam(buildParams, getDeployJobName(kogitoAppsRepo))

                    buildJob(getPromoteJobName(kogitoAppsRepo), buildParams)
                }
            }
        }

        stage('Promote Kogito Examples') {
            when {
                expression { return isJobConsideredOk(getDeployJobName(kogitoExamplesRepo)) }
            }
            steps {
                script {
                    def buildParams = getDefaultBuildParams(getKogitoVersion())
                    addStringParam(buildParams, 'DROOLS_VERSION', getDroolsVersion())
                    addDeployBuildUrlParam(buildParams, getDeployJobName(kogitoExamplesRepo))
                    addBooleanParam(buildParams, 'UPDATE_STABLE_BRANCH', isDeployAsLatest())

                    buildJob(getPromoteJobName(kogitoExamplesRepo), buildParams)
                }
            }
        }

        stage('Setup next snapshot version') {
            steps {
                script {
                    def buildParams = []
                    addStringParam(buildParams, 'KOGITO_VERSION', util.getNextVersion(getKogitoVersion(), 'micro'))
                    addStringParam(buildParams, 'DROOLS_VERSION', util.getNextVersion(getDroolsVersion(), 'micro'))
                    addBooleanParam(buildParams, 'SKIP_CLOUD_SETUP_BRANCH', true)

                    build(job: '../setup-branch/0-setup-branch', wait: false, parameters: buildParams, propagate: false)
                }
            }
        }

        stage('Start Cloud release') {
            when {
                expression { isCloudRelease() }
            }
            steps {
                script {
                    def buildParams = getDefaultBuildParams(getKogitoVersion())
                    addStringParam(buildParams, 'KOGITO_VERSION', getKogitoVersion())
                    addBooleanParam(buildParams, 'DEPLOY_AS_LATEST', isDeployAsLatest())
                    addSkipTestsParam(buildParams)

                    build(job: './0-kogito-release-cloud', wait: false, parameters: buildParams, propagate: false)
                }
            }
        }
    }
    post {
        always {
            script {
                saveReleaseProperties()
            }
            cleanWs()
        }
        success {
            script {
                sendSuccessfulReleaseNotification()
            }
        }
        unsuccessful {
            sendErrorNotification()
        }
    }
}

def buildJob(String jobName, List buildParams, boolean shouldWait = true) {
    if (!hasJob(jobName) || (getJobResult(jobName) != 'SUCCESS' && getJobDecision(jobName) == 'retry')) {
        sendStageNotification()
        echo "Build ${jobName} with shouldWait=${shouldWait} and params ${buildParams}"
        def job = build(job: "./${jobName}", wait: shouldWait, parameters: buildParams, propagate: false)
        removeJobDecision(jobName)
        registerJobExecution(jobName, job.result, job.absoluteUrl)
    } else {
        echo 'Job was already executed. Retrieving information...'
    }

    saveReleaseProperties()

    def jobResult = getJobResult(jobName)
    def jobUrl = getJobUrl(jobName)
    def jobDecision = getJobDecision(jobName)
    if (jobResult != 'SUCCESS') {
        if (jobDecision != 'continue' && jobDecision != 'skip') {
            echo "Sending a notification about an unsuccessful job build ${jobName}."
            sendNotification("`${jobName}` finished with status `${jobResult}`.\nSee: ${jobUrl}\n\nPlease provide which action should be done (retry ? continue ? skip ? abort ?): ${env.BUILD_URL}input")

            // abort is handled automatically by the pipeline in the input
            def result = input message: "Job `${jobName}` is in status ${jobResult}. What do you want to do ?\nBeware that skipping a deploy job will not launch the promote part.", parameters: [choice(name: 'ACTION', choices: ['retry', 'continue', 'skip'].join('\n')), string(name: 'MESSAGE', description: 'If you want to add information to your action...')]
            def inputDecision = result['ACTION']
            def inputMessage = result['MESSAGE']
            registerJobDecision(jobName, inputDecision, inputMessage)

            String resultStr = "`${jobName}` failure => Decision was made to ${inputDecision}."
            if (inputMessage) {
                resultStr += "Additional Information: `${inputMessage}`"
            }
            sendNotification(resultStr)

            if (inputDecision == 'retry') {
                // If retry, remove job and build again
                return buildJob(jobName, buildParams)
            }
        } else {
            echo "Job decision was '${jobDecision}'"
        }
    } else {
        echo 'Job succeeded'
    }
}

String getDeployJobName(String repository) {
    return "${repository}-deploy"
}

String getPromoteJobName(String repository) {
    return "${repository}-promote"
}

String getJobPropertySuffix(String jobName) {
    return "${JOB_PROPERTY_PREFIX}.${jobName}"
}

String getJobPropertyKey(String jobName, String key) {
    return "${getJobPropertySuffix(jobName)}.${key}"
}

def registerJobExecution(String jobName, String result, String absoluteUrl) {
    setReleasePropertyIfneeded(getJobPropertyKey(jobName, JOB_RESULT_PROPERTY_KEY), result)
    setReleasePropertyIfneeded(getJobPropertyKey(jobName, JOB_URL_PROPERTY_KEY), absoluteUrl)
}

def registerJobDecision(String jobName, String decision, String message = '') {
    setReleasePropertyIfneeded(getJobPropertyKey(jobName, JOB_DECISION_PROPERTY_KEY), decision)
    setReleasePropertyIfneeded(getJobPropertyKey(jobName, JOB_DECISION_MESSAGE_PROPERTY_KEY), message)
}

def removeJobDecision(String jobName) {
    removeReleaseProperty(getJobPropertyKey(jobName, JOB_DECISION_PROPERTY_KEY))
    removeReleaseProperty(getJobPropertyKey(jobName, JOB_DECISION_MESSAGE_PROPERTY_KEY))
}

List getAllJobNames() {
    return releaseProperties.findAll { it.key.startsWith(JOB_PROPERTY_PREFIX) }.collect { it.key.split('\\.')[1] }.unique()
}

boolean hasJob(String jobName) {
    return releaseProperties.any { it.key.startsWith(getJobPropertySuffix(jobName)) }
}

String getJobUrl(String jobName) {
    echo "getJobUrl for ${jobName}"
    return getReleaseProperty(getJobPropertyKey(jobName, JOB_URL_PROPERTY_KEY)) ?: ''
}

String getJobResult(String jobName) {
    echo "getJobResult for ${jobName}"
    return getReleaseProperty(getJobPropertyKey(jobName, JOB_RESULT_PROPERTY_KEY)) ?: ''
}

String getJobDecision(String jobName) {
    echo "getJobDecision for ${jobName}"
    return getReleaseProperty(getJobPropertyKey(jobName, JOB_DECISION_PROPERTY_KEY)) ?: ''
}

boolean isJobConsideredOk(String jobName) {
    String result = getJobResult(jobName)
    String decision = getJobDecision(jobName)
    return result == 'SUCCESS' || (result == 'UNSTABLE' &&  decision == 'continue')
}

void saveReleaseProperties() {
    def propertiesStr = releaseProperties.collect { entry -> "${entry.key}=${entry.value}" }.join('\n')
    writeFile( file : 'release.properties' , text : propertiesStr)
    archiveArtifacts artifacts: 'release.properties'
}

void sendSuccessfulReleaseNotification() {
    String bodyMsg = 'Release is successful with those jobs:\n'
    getAllJobNames().findAll { isJobConsideredOk(it) }.each {
        bodyMsg += "- ${it}\n"
    }
    bodyMsg += "\nPlease look here: ${BUILD_URL} for more information"
    sendNotification(bodyMsg)
}

void sendErrorNotification() {
    sendNotification("Kogito release job #${BUILD_NUMBER} was: ${currentBuild.currentResult}\nPlease look here: ${BUILD_URL}")
}

void sendStageNotification() {
    sendNotification("${env.STAGE_NAME}")
}

void sendNotification(String body) {
    echo 'Send Notification'
    echo body
    emailext body: body, subject: "[${env.GIT_BRANCH_NAME}] Release Pipeline",
                to: env.KOGITO_CI_EMAIL_TO
}

def readPropertiesFromUrl(String url, String propsFilename) {
    if (!url.endsWith('/')) {
        url += '/'
    }
    sh "wget ${url}artifact/${propsFilename} -O ${propsFilename}"
    def props = readProperties file: propsFilename
    echo props.collect { entry -> "${entry.key}=${entry.value}" }.join('\n')
    return props
}

List getDefaultBuildParams(String version) {
    List buildParams = []
    addDisplayNameParam(buildParams, getDisplayName(version))
    addStringParam(buildParams, 'PROJECT_VERSION', version)
    addStringParam(buildParams, 'KOGITO_PR_BRANCH', "kogito-${version}")
    return buildParams
}

void addDisplayNameParam(buildParams, name = '') {
    name = name ?: getDisplayName()
    addStringParam(buildParams, 'DISPLAY_NAME', name)
}

void addDeployBuildUrlParam(buildParams, jobName) {
    addDeployBuildUrlParamOrClosure(buildParams, jobName)
}

void addDeployBuildUrlParamOrClosure(buildParams, jobName, closure = null) {
    String url = getJobUrl(jobName)
    if (url) {
        addStringParam(buildParams, 'DEPLOY_BUILD_URL', getJobUrl(jobName))
    } else if (closure) {
        closure()
    }
}

void addSkipTestsParam(buildParams) {
    addBooleanParam(buildParams, 'SKIP_TESTS', params.SKIP_TESTS)
}

void addStringParam(List buildParams, String key, String value) {
    buildParams.add(string(name: key, value: value))
}

void addBooleanParam(List buildParams, String key, boolean value) {
    buildParams.add(booleanParam(name: key, value: value))
}

String constructKey(String prefix, String paramId) {
    return prefix ? "${prefix}_${paramId}" : paramId
}

String getDisplayName(version = '') {
    version = version ?: getKogitoVersion()
    return "Release ${version}"
}

String getKogitoVersion() {
    return params.KOGITO_VERSION ?: getReleaseProperty('kogito.version')
}

String getDroolsVersion() {
    return params.DROOLS_VERSION ?: getReleaseProperty('drools.version')
}

String getGitAuthor() {
    return env.GIT_AUTHOR
}

String getArtifactsRepositoryParam() {
    return env['ARTIFACTS_REPOSITORY'] ?: ''
}

String getStagingRepository() {
    return getArtifactsRepositoryParam() ?: env.DEFAULT_STAGING_REPOSITORY
}

boolean isDeployAsLatest() {
    return params.DEPLOY_AS_LATEST || getReleaseProperty('deploy.latest')?.toBoolean()
}

boolean isCloudRelease() {
    return !params.SKIP_CLOUD_RELEASE
}

void setReleasePropertyIfneeded(String key, def value) {
    if (value) {
        releaseProperties[key] = value
    }
}

void removeReleaseProperty(String key) {
    if (hasReleaseProperty(key)) {
        releaseProperties.remove(key)
    }
}

boolean hasReleaseProperty(String key) {
    return releaseProperties.containsKey(key)
}

def getReleaseProperty(String key) {
    return hasReleaseProperty(key) ? releaseProperties[key] : ''
}

boolean areArtifactsStaged() {
    return hasReleaseProperty(ARTIFACTS_STAGING_STAGE)
}

void setArtifactsStaged() {
    setReleasePropertyIfneeded(ARTIFACTS_STAGING_STAGE, true)
}

boolean areArtifactsReleased() {
    return hasReleaseProperty(ARTIFACTS_RELEASE_STAGE)
}

void setArtifactsReleased() {
    setReleasePropertyIfneeded(ARTIFACTS_RELEASE_STAGE, true)
}