Jenkinsfile.pr.bdd-tests

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

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

changeAuthor = env.ghprbPullAuthorLogin ?: CHANGE_AUTHOR
changeBranch = env.ghprbSourceBranch ?: BRANCH_NAME
changeTarget = env.ghprbTargetBranch ?: CHANGE_TARGET
changeId = env.ghprbPullId ?: CHANGE_ID

RUNTIMES_DEPLOY = 'kogito-runtimes-deploy'
APPS_DEPLOY = 'kogito-apps-deploy'
EXAMPLES_DEPLOY = 'kogito-examples-deploy'
IMAGES_DEPLOY = 'kogito-images-deploy'
OPERATOR_DEPLOY = 'kogito-operator-deploy'
OPTAPLANNER_DEPLOY = 'optaplanner-deploy'

// 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'

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

    environment {
        IMAGE_NAME_SUFFIX = "${getPRRepoName()}-pr-${changeId}-bdd-tests"
        BUILD_NAME = "${getPRRepoName()}-pr-${changeId}-bdd-tests"
        TEMP_TAG = "temp-${env.BUILD_NAME}"
    }

    stages {
        stage('Initialize') {
            steps {
                script {
                    echo "temporary tag is ${env.TEMP_TAG}"
                    echo "build name is ${env.BUILD_NAME}"

                    currentBuild.displayName = env.BUILD_NAME
                }
            }
        }

        stage('Build & Deploy Kogito Runtimes') {
            steps {
                script {
                    echo "Call ${RUNTIMES_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()
                    addAuthorBranchParamsIfExist(buildParams, 'kogito-runtimes')

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

        stage('Build & Deploy OptaPlanner') {
            steps {
                script {
                    echo "Call ${OPTAPLANNER_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()

                    def targetBranch = (changeTarget != 'master') ? getOptaPlannerBranch() : ''
                    addAuthorBranchParamsIfExist(buildParams, 'optaplanner', targetBranch)
                    addStringParam(buildParams, 'PR_TARGET_BRANCH', targetBranch)
                    addStringParam(buildParams, 'QUICKSTARTS_BUILD_BRANCH_NAME', targetBranch)

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

        stage('Build & Deploy Kogito Apps') {
            steps {
                script {
                    echo "Call ${APPS_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()
                    addAuthorBranchParamsIfExist(buildParams, 'kogito-apps')

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

        stage('Build & Deploy Kogito Examples') {
            steps {
                script {
                    echo "Call ${EXAMPLES_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()
                    addAuthorBranchParamsIfExist(buildParams, 'kogito-examples')

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

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

                    def buildParams = getDefaultBuildParams()
                    addAuthorBranchParamsIfExist(buildParams, 'kogito-images')
                    addImageBuildParams(buildParams)
                    addExamplesParams(buildParams)

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

        // We don't build separately the examples images for this pipeline, that will be done as part of the

        stage('Build & Deploy Operator') {
            steps {
                script {
                    echo "Call ${OPERATOR_DEPLOY} job"
                    def buildParams = getDefaultBuildParams()
                    addAuthorBranchParamsIfExist(buildParams, 'kogito-operator')
                    addImageBuildParams(buildParams)
                    addBooleanParam(buildParams, 'SKIP_NATIVE_TESTS', true) // No native tests for PR BDD tests

                    // For BDD tests
                    addImageBuildParams(buildParams, kogitoImagesParamsPrefix)
                    addImageBuildParams(buildParams, examplesImagesParamsPrefix)
                    addStringParam(buildParams, constructKey(examplesImagesParamsPrefix, 'CACHE_MODE'), 'never')
                    addStringParam(buildParams, constructKey(examplesImagesParamsPrefix, 'NAME_PREFIX'), 'examples')

                    addExamplesParams(buildParams)

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

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()
        unstable("Job ${jobName} finished with result ${job.getResult()}")
    }
    return job
}

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

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)
}

List getDefaultBuildParams() {
    List params = []
    addStringParam(params, 'DISPLAY_NAME', env.BUILD_NAME)
    return params
}

boolean doesBranchExist(String repo, String author, String branch) {
    return githubscm.getRepositoryScm(repo, author, branch) != null
}

void addAuthorBranchParamsIfExist(List params, String repo, String targetBranch = '') {
    targetBranch = targetBranch ?: changeTarget
    if (doesBranchExist(repo, changeAuthor, changeBranch)) {
        addStringParam(params, 'GIT_AUTHOR', changeAuthor)
        addStringParam(params, 'BUILD_BRANCH_NAME', changeBranch)
    // set build branch to kiegroup's version branch
    } else if (targetBranch != 'master' && doesBranchExist(repo, 'kiegroup', targetBranch)) {
        addStringParam(params, 'BUILD_BRANCH_NAME', targetBranch)
    }
}

String getOptaPlannerBranch() {
    /* The OptaPlanner major version is shifted by 7 from the Kogito major version:
       Kogito 1.x.y -> OptaPlanner 8.x.y. */
    int majorVersionShift = 7
    String [] changeTargetSplit = changeTarget.split("\\.")
    if (changeTargetSplit.length == 3) {
        Integer optaplannerMajorVersion = Integer.parseInt(changeTargetSplit[0]) + majorVersionShift
        return "${optaplannerMajorVersion}.${changeTargetSplit[1]}.${changeTargetSplit[2]}"
    }
    return changeTarget
}

void addExamplesParams(List buildParams) {
    def author = ''
    def branch = ''
    if (doesBranchExist('kogito-examples', changeAuthor, changeBranch)) {
        author = changeAuthor
        branch = changeBranch
    } else if (doesBranchExist('kogito-examples', 'kiegroup', changeTarget)) {
        author = 'kiegroup'
        branch = changeTarget
    } else {
        author = 'kiegroup'
        branch = 'master'
    }
    addStringParam(buildParams, 'EXAMPLES_URI', "https://github.com/${author}/kogito-examples")
    addStringParam(buildParams, 'EXAMPLES_REF', branch)
}

void addImageBuildParams(List buildParams, String paramsPrefix = defaultImageParamsPrefix) {
    addBooleanParam(buildParams, constructKey(paramsPrefix, 'USE_OPENSHIFT_REGISTRY'), true)
    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'), env.TEMP_TAG)
}

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 getPRRepoName() {
    return env.ghprbGhRepository.split('/')[1]
}

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