Jenkinsfile.promote

import org.jenkinsci.plugins.workflow.libs.Library
@Library('jenkins-pipeline-shared-libraries')_

import org.kie.jenkins.MavenCommand

deployProperties = [:]
pipelineProperties = [:]

pipeline {
    agent {
        label 'kie-rhel7'
    }

    tools {
        maven 'kie-maven-3.6.2'
        jdk 'kie-jdk11'
    }

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

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

    environment {
        // Static env is defined into .jenkins/dsl/jobs.groovy file

        BOT_BRANCH_HASH = "${util.generateHash(10)}"
    }

    stages {
        stage('Initialization') {
            steps {
                script {
                    cleanWs()

                    if (params.DISPLAY_NAME != '') {
                        currentBuild.displayName = params.DISPLAY_NAME
                    }

                    readDeployProperties()

                    if (isRelease()) {
                        // Verify version is set and if on right release branch
                        assert getProjectVersion()
                        assert getBuildBranch() == util.getReleaseBranchFromVersion(getProjectVersion())
                    }
                }
            }
        }
        stage('Merge deploy PR and tag') {
            when {
                expression { return isRelease() }
            }
            steps {
                script {
                    dir(getRepoName()) {
                        checkoutRepo()
                        mergeAndPush(getDeployPrLink())
                        tagLatest()
                    }
                }
            }
        }
        stage('Set next snapshot version') {
            when {
                expression { return isRelease() }
            }
            steps {
                script {
                    dir('bot') {
                        prepareForPR()

                        maven.mvnVersionsSet(getMavenCommand(), getSnapshotVersion(), true)

                        commitAndCreatePR()
                    }
                    dir(getRepoName()) {
                        sh "git checkout ${getBuildBranch()}"
                        mergeAndPush(getPipelinePrLink())

                        runMavenDeploy()
                    }
                }
            }
        }
    }
    post {
        cleanup {
            script {
                util.cleanNode('docker')
            }
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
// Deployment properties
//////////////////////////////////////////////////////////////////////////////

void readDeployProperties() {
    String deployUrl = params.DEPLOY_BUILD_URL
    if (deployUrl != '') {
        if (!deployUrl.endsWith('/')) {
            deployUrl += '/'
        }
        sh "wget ${deployUrl}artifact/${PROPERTIES_FILE_NAME} -O ${PROPERTIES_FILE_NAME}"
        deployProperties = readProperties file: PROPERTIES_FILE_NAME
        // echo all properties
        echo deployProperties.collect { entry -> "${entry.key}=${entry.value}" }.join('\n')
    }
}

boolean hasDeployProperty(String key) {
    return deployProperties[key] != null
}

String getDeployProperty(String key) {
    if (hasDeployProperty(key)) {
        return deployProperties[key]
    }
    return ''
}

String getParamOrDeployProperty(String paramKey, String deployPropertyKey) {
    if (params[paramKey] != '') {
        return params[paramKey]
    }
    return getDeployProperty(deployPropertyKey)
}

//////////////////////////////////////////////////////////////////////////////
// Getter / Setter
//////////////////////////////////////////////////////////////////////////////

boolean isRelease() {
    return env.RELEASE.toBoolean()
}

String getRepoName() {
    return env.REPO_NAME
}

String getProjectVersion() {
    return getParamOrDeployProperty('PROJECT_VERSION', 'project.version')
}

String getSnapshotVersion() {
    return util.getNextVersion(getProjectVersion(), 'micro')
}

String getGitTag() {
    return params.GIT_TAG != '' ? params.GIT_TAG : getProjectVersion()
}

String getBuildBranch() {
    return params.BUILD_BRANCH_NAME
}

String getGitAuthor() {
    return env.GIT_AUTHOR
}

String getGitAuthorCredsID() {
    return env.AUTHOR_CREDS_ID
}

String getBotAuthorCredsID() {
    return env.BOT_CREDENTIALS_ID
}

String getDeployPrLink() {
    return getDeployProperty("${getRepoName()}.pr.link")
}

String getPipelinePrLink() {
    return pipelineProperties["${getRepoName()}.pr.link"]
}

void setPipelinePrLink(String value) {
    pipelineProperties["${getRepoName()}.pr.link"] = value
}

String getSnapshotBranch() {
    return "${getSnapshotVersion().toLowerCase()}-${env.BOT_BRANCH_HASH}"
}

//////////////////////////////////////////////////////////////////////////////
// Git
//////////////////////////////////////////////////////////////////////////////

void checkoutRepo() {
    deleteDir()
    checkout(githubscm.resolveRepository(getRepoName(), getGitAuthor(), getBuildBranch(), false))
    // need to manually checkout branch since on a detached branch after checkout command
    sh "git checkout ${getBuildBranch()}"
}

void mergeAndPush(String prLink) {
    if (prLink) {
        githubscm.mergePR(prLink, getGitAuthorCredsID())
        githubscm.pushObject('origin', getBuildBranch(), getGitAuthorCredsID())
    }
}

void tagLatest() {
    if (getGitTag()) {
        githubscm.tagLocalAndRemoteRepository('origin', getGitTag(), getGitAuthorCredsID(), env.BUILD_TAG, true)
    }
}

void prepareForPR() {
    checkoutRepo()
    githubscm.forkRepo(getBotAuthorCredsID())
    githubscm.createBranch(getSnapshotBranch())
}

void commitAndCreatePR() {
    def commitMsg = "[${getBuildBranch()}] Update project version to ${getSnapshotVersion()}"
    def prBody = "Generated by build ${BUILD_TAG}: ${BUILD_URL}.\nPlease do not merge, it should be merged automatically."

    githubscm.commitChanges(commitMsg, { githubscm.findAndStageNotIgnoredFiles('pom.xml') })
    githubscm.pushObject('origin', getSnapshotBranch(), getBotAuthorCredsID())
    setPipelinePrLink(githubscm.createPR(commitMsg, prBody, getBuildBranch(), getBotAuthorCredsID()))
}

MavenCommand getMavenCommand() {
    mvnCmd = new MavenCommand(this, ['-fae'])
                    .withSettingsXmlId("${env.MAVEN_SETTINGS_CONFIG_FILE_ID}")
    if (env.MAVEN_DEPENDENCIES_REPOSITORY) {
        mvnCmd.withDependencyRepositoryInSettings('deps-repo', env.MAVEN_DEPENDENCIES_REPOSITORY)
    }
    return mvnCmd
}

void runMavenDeploy() {
    mvnCmd = getMavenCommand()
    if (env.MAVEN_DEPLOY_REPOSITORY) {
        mvnCmd.withDeployRepository(env.MAVEN_DEPLOY_REPOSITORY)
    }
    mvnCmd.skipTests(true).run('clean deploy')
}