Jenkinsfile.nightly

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

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

// Deploy jobs
RUNTIMES_DEPLOY = 'kogito-runtimes-deploy'
OPTAPLANNER_DEPLOY = 'optaplanner-deploy'
APPS_DEPLOY = 'kogito-apps-deploy'
EXAMPLES_DEPLOY = 'kogito-examples-deploy'
IMAGES_DEPLOY = 'kogito-images-deploy'
EXAMPLES_IMAGES_DEPLOY = 'kogito-examples-images-deploy'
OPERATOR_DEPLOY = 'kogito-operator-deploy'
EXAMPLES_IMAGES_PROMOTE = 'kogito-examples-images-promote'

// Promote jobs
IMAGES_PROMOTE = 'kogito-images-promote'
OPERATOR_PROMOTE = 'kogito-operator-promote'

// Map of executed jobs
// See https://javadoc.jenkins.io/plugin/workflow-support/org/jenkinsci/plugins/workflow/support/steps/build/RunWrapper.html
// for more options on built job entity
JOBS = [:]

FAILED_STAGES = [:]
UNSTABLE_STAGES = [:]

defaultImageParamsPrefix = 'IMAGE'
kogitoImagesParamsPrefix = 'KOGITO_IMAGES'
examplesImagesParamsPrefix = 'EXAMPLES_IMAGES'
baseImageParamsPrefix = 'BASE_IMAGE'
promoteImageParamsPrefix = 'PROMOTE_IMAGE'

// Should be multibranch pipeline
pipeline {
    agent {
        label 'kie-rhel7 && !master'
    }

    options {
        timeout(time: 720, unit: 'MINUTES')
    }

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

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

        KOGITO_CI_EMAIL_TO = credentials("${JENKINS_EMAIL_CREDS_ID}")

        IMAGE_NAME_NIGHTLY_SUFFIX = 'nightly'

        TEMP_TAG = "temp-${getBuildBranch()}-tests"
        // Use branch name in nightly tag as we may have parallel master and release branch builds
        NIGHTLY_TAG = """${getBuildBranch()}-${sh(
                returnStdout: true,
                script: 'date -u "+%Y-%m-%d"'
            ).trim()}"""
}

    stages {
        stage('Initialize') {
            steps {
                script {
                    echo "temporary tag is ${env.TEMP_TAG}"
                    echo "nightly tag is ${env.NIGHTLY_TAG}"

                    currentBuild.displayName = env.NIGHTLY_TAG
                }
            }
        }

        stage('Build & Deploy Kogito Runtimes') {
            when {
                expression { return isArtifactsDeploy() }
            }
            steps {
                script {
                    echo "Call ${RUNTIMES_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()
                    addSkipTestsParam(buildParams)

                    // images and operator deploy testing will use older working artifacts if that one fails
                    buildJob(RUNTIMES_DEPLOY, buildParams, false)
                }
            }
            post {
                failure {
                    addFailedStage(RUNTIMES_DEPLOY)
                }
            }
        }

        stage('Build & Deploy OptaPlanner') {
            when {
                expression { return isArtifactsDeploy() }
            }
            steps {
                script {
                    echo "Call ${OPTAPLANNER_DEPLOY} job"

                    String optaplannerBranch = getBuildBranch()
                    String [] buildBranchSplit = optaplannerBranch.split("\\.")
                    if (buildBranchSplit.length == 3) {
                        /* The OptaPlanner major version is shifted by 7 from the Kogito major version:
                           Kogito 1.x.y -> OptaPlanner 8.x.y. */

                        int majorVersionShift = 7
                        Integer optaplannerMajorVersion = Integer.parseInt(buildBranchSplit[0]) + majorVersionShift
                        optaplannerBranch = "${optaplannerMajorVersion}.${buildBranchSplit[1]}.${buildBranchSplit[2]}"
                    }

                    def buildParams = getDefaultBuildParams(optaplannerBranch)
                    addSkipTestsParam(buildParams)
                    addSkipIntegrationTestsParam(buildParams)
                    def quickstartsBranch = optaplannerBranch == 'master' ? 'development' : optaplannerBranch
                    addStringParam(buildParams, 'QUICKSTARTS_BUILD_BRANCH_NAME', quickstartsBranch)

                    buildJob(OPTAPLANNER_DEPLOY, buildParams, false)
                }
            }
            post {
                failure {
                    addFailedStage(OPTAPLANNER_DEPLOY)
                }
            }
        }

        stage('Build & Deploy Kogito Apps') {
            when {
                expression { return isArtifactsDeploy() }
            }
            steps {
                script {
                    echo "Call ${APPS_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()
                    addSkipTestsParam(buildParams)

                    // images and operator deploy testing will use older working artifacts if that one fails
                    buildJob(APPS_DEPLOY, buildParams, false)
                }
            }
            post {
                failure {
                    addFailedStage(APPS_DEPLOY)
                }
            }
        }

        stage('Build & Deploy Kogito Examples') {
            when {
                expression { return isArtifactsDeploy() }
            }
            steps {
                script {
                    echo "Call ${EXAMPLES_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()
                    addSkipTestsParam(buildParams)

                    // images and operator deploy testing will use older working artifacts if that one fails
                    buildJob(EXAMPLES_DEPLOY, buildParams, false)
                }
            }
            post {
                failure {
                    addFailedStage(EXAMPLES_DEPLOY)
                }
            }
        }

        stage('Build & Deploy Images') {
            when {
                expression { return isImagesDeploy() }
            }
            steps {
                script {
                    echo "Call ${IMAGES_DEPLOY} job"

                    def buildParams = getDefaultBuildParams()
                    addImageBuildParams(buildParams, env.TEMP_TAG)
                    // For testing
                    addSkipTestsParam(buildParams)
                    addExamplesParam(buildParams)

                    // Ask to create the PR with changes occuring in this
                    addBooleanParam(buildParams, 'CREATE_PR', true)

                    buildJob(IMAGES_DEPLOY, buildParams, false)
                }
            }
            post {
                failure {
                    addFailedStage(IMAGES_DEPLOY)
                }
            }
        }

        stage('Build & Deploy Examples Images') {
            when {
                expression { return isExamplesImagesDeploy() }
            }
            steps {
                script {
                    echo "Call ${EXAMPLES_IMAGES_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()
                    addSkipTestsParam(buildParams)
                    addImageBuildParams(buildParams, env.TEMP_TAG)
                    addStringParam(buildParams, constructKey(defaultImageParamsPrefix, 'NAME_PREFIX'), 'examples')

                    // For BDD tests
                    addImageBuildParams(buildParams, env.TEMP_TAG, false, kogitoImagesParamsPrefix)
                    addExamplesParam(buildParams)

                    buildJob(EXAMPLES_IMAGES_DEPLOY, buildParams, false)
                }
            }
            post {
                failure {
                    addFailedStage(OPERATOR_DEPLOY)
                }
            }
        }

        stage('Build & Deploy Operator') {
            when {
                expression { return isOperatorDeploy() }
            }
            steps {
                script {
                    echo "Call ${OPERATOR_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()
                    addSkipTestsParam(buildParams)
                    addImageBuildParams(buildParams, env.TEMP_TAG)

                    // For BDD tests
                    addImageBuildParams(buildParams, env.TEMP_TAG, false, kogitoImagesParamsPrefix)
                    addImageBuildParams(buildParams, env.TEMP_TAG, false, examplesImagesParamsPrefix)
                    addStringParam(buildParams, constructKey(examplesImagesParamsPrefix, 'CACHE_MODE'), isExamplesImagesDeploy() ? 'always' : 'never')
                    addStringParam(buildParams, constructKey(examplesImagesParamsPrefix, 'NAME_PREFIX'), 'examples')
                    addExamplesParam(buildParams)

                    buildJob(OPERATOR_DEPLOY, buildParams, false)
                }
            }
            post {
                failure {
                    addFailedStage(OPERATOR_DEPLOY)
                }
            }
        }

        stage('Promote Images') {
            when {
                expression { return isImagesPromote() }
            }
            steps {
                script {
                    echo "Call ${IMAGES_PROMOTE} job"

                    def buildParams = getDefaultBuildParams()
                    addDeployBuildUrlParam(buildParams, IMAGES_DEPLOY)
                    // Base image information is given by the deploy URL
                    addImageBuildParams(buildParams, env.NIGHTLY_TAG, true, promoteImageParamsPrefix)
                    addBooleanParam(buildParams, 'DEPLOY_WITH_LATEST_TAG', isDeployImagesLatestTag())

                    buildJob(IMAGES_PROMOTE, buildParams)
                }
            }
            post {
                failure {
                    addFailedStage(IMAGES_PROMOTE)
                }
            }
        }

        stage('Promote Examples Images') {
            when {
                expression { return isExamplesImagesPromote() }
            }
            steps {
                script {
                    echo "Call ${EXAMPLES_IMAGES_PROMOTE} job"

                    def buildParams = getDefaultBuildParams()
                    addDeployBuildUrlParam(buildParams, EXAMPLES_IMAGES_DEPLOY)
                    // Base image information is given by the deploy URL
                    addImageBuildParams(buildParams, env.NIGHTLY_TAG, true, promoteImageParamsPrefix)
                    addStringParam(buildParams, constructKey(promoteImageParamsPrefix, 'NAME_PREFIX'), 'examples')
                    addBooleanParam(buildParams, 'DEPLOY_WITH_LATEST_TAG', isDeployImagesLatestTag())

                    buildJob(EXAMPLES_IMAGES_PROMOTE, buildParams)
                }
            }
            post {
                failure {
                    addFailedStage(OPERATOR_PROMOTE)
                }
            }
        }

        stage('Promote Operator') {
            when {
                expression { return isOperatorPromote() }
            }
            steps {
                script {
                    echo "Call ${OPERATOR_PROMOTE} job"

                    def buildParams = getDefaultBuildParams()
                    addDeployBuildUrlParam(buildParams, OPERATOR_DEPLOY)
                    // Base image information is given by the deploy URL
                    addImageBuildParams(buildParams, env.NIGHTLY_TAG, true, promoteImageParamsPrefix)
                    addBooleanParam(buildParams, 'DEPLOY_WITH_LATEST_TAG', isDeployImagesLatestTag())

                    buildJob(OPERATOR_PROMOTE, buildParams)
                }
            }
            post {
                failure {
                    addFailedStage(OPERATOR_PROMOTE)
                }
            }
        }
    }
    post {
        unsuccessful {
            sendPipelineErrorNotification()
        }
    }
}

def buildJob(String jobName, List buildParams, boolean propagate=true) {
    echo "Build ${jobName} with params ${buildParams} and propagate = ${propagate}"

    def job = build(job: "${jobName}", wait: true, parameters: buildParams, propagate: propagate)
    JOBS[jobName] = job

    // Set Unstable if we don't propagate and job failed
    if (!propagate && !isJobSucceeded(jobName)) {
        addUnstableStage(jobName)
        unstable("Job ${jobName} finished with result ${job.getResult()}")
    }
    return job
}

def getJob(String jobName) {
    return JOBS[jobName]
}

String getJobUrl(String jobName) {
    echo "getJobUrl for ${jobName}"
    def job = getJob(jobName)
    return job ? job.getAbsoluteUrl() : ''
}

boolean isJobSucceeded(String jobName) {
    def job = getJob(jobName)
    return job ? job.getResult() == 'SUCCESS' : false
}

void addFailedStage(String jobName = '') {
    FAILED_STAGES.put("${STAGE_NAME}", jobName)
}
void addUnstableStage(String jobName = '') {
    UNSTABLE_STAGES.put("${STAGE_NAME}", jobName)
}

void sendPipelineErrorNotification() {
    String bodyMsg = "Kogito nightly job #${BUILD_NUMBER} was: ${currentBuild.currentResult}"

    paramsStr = ''
    if (params.SKIP_TESTS) {
        paramsStr += '\n- Tests skipped'
    }
    if (params.SKIP_ARTIFACTS) {
        paramsStr += '\n- Artifacts skipped'
    }
    if (params.SKIP_IMAGES) {
        paramsStr += '\n- Images skipped'
    }
    if (params.SKIP_OPERATOR) {
        paramsStr += '\n- Operator skipped'
    }
    bodyMsg += paramsStr ? "\n\nConfiguration:${paramsStr}" : '\n'

    if (FAILED_STAGES.size() > 0) {
        bodyMsg += '\nFailed stages: \n- '
        bodyMsg += FAILED_STAGES.collect { "${it.key} => ${getJobUrl(it.value)}" }.join('\n- ')
    }
    bodyMsg += '\n'
    if (UNSTABLE_STAGES.size() > 0) {
        bodyMsg += '\nUnstable stages: \n- '
        bodyMsg += UNSTABLE_STAGES.collect { "${it.key} => ${getJobUrl(it.value)}" }.join('\n- ')
    }
    bodyMsg += '\n'
    bodyMsg += "\nPlease look here: ${BUILD_URL}"
    emailext body: bodyMsg, subject: "[${getBuildBranch()}][d] Full Pipeline",
                to: env.KOGITO_CI_EMAIL_TO
}

List getDefaultBuildParams(String buildBranchName = '') {
    buildBranchName = buildBranchName ?: getBuildBranch()
    List params = []
    addStringParam(params, 'DISPLAY_NAME', env.NIGHTLY_TAG)

    return params
}

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

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

void addExamplesParam(buildParams) {
    addStringParam(buildParams, 'EXAMPLES_URI', "https://github.com/${getGitAuthor()}/kogito-examples")
    addStringParam(buildParams, 'EXAMPLES_REF', getBuildBranch())
}

void addImageBuildParams(List buildParams, String tag, boolean isFinalImage = false, String paramsPrefix = defaultImageParamsPrefix) {
    addBooleanParam(buildParams, constructKey(paramsPrefix, 'USE_OPENSHIFT_REGISTRY'), !isFinalImage && params.USE_TEMP_OPENSHIFT_REGISTRY)
    addStringParam(buildParams, constructKey(paramsPrefix, 'REGISTRY_CREDENTIALS'), env.IMAGE_REGISTRY_CREDENTIALS)
    addStringParam(buildParams, constructKey(paramsPrefix, 'REGISTRY'), env.IMAGE_REGISTRY)
    addStringParam(buildParams, constructKey(paramsPrefix, 'NAMESPACE'), env.IMAGE_NAMESPACE)
    addStringParam(buildParams, constructKey(paramsPrefix, 'NAME_SUFFIX'), env.IMAGE_NAME_NIGHTLY_SUFFIX)
    addStringParam(buildParams, constructKey(paramsPrefix, 'TAG'), tag)
}

void addDeployBuildUrlParam(buildParams, jobName) {
    addStringParam(buildParams, 'DEPLOY_BUILD_URL', getJobUrl(jobName))
}

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

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

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

String getBuildBranch() {
    return env.GIT_BRANCH_NAME
}

String getGitAuthor() {
    return env.GIT_AUTHOR
}

boolean isDeployImagesLatestTag() {
    return getBuildBranch() == env.BRANCH_FOR_LATEST
}

boolean isArtifactsDeploy() {
    return !params.SKIP_ARTIFACTS
}

boolean isImagesDeploy() {
    return !params.SKIP_IMAGES
}

boolean isExamplesImagesDeploy() {
    return !params.SKIP_EXAMPLES_IMAGES
}

boolean isOperatorDeploy() {
    return !params.SKIP_OPERATOR
}

boolean isImagesPromote() {
    return isImagesDeploy() && isJobSucceeded(IMAGES_DEPLOY)
}

boolean isExamplesImagesPromote() {
    return isExamplesImagesDeploy() && isJobSucceeded(EXAMPLES_IMAGES_DEPLOY)
}

boolean isOperatorPromote() {
    return isOperatorDeploy() && isJobSucceeded(OPERATOR_DEPLOY)
}

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