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)}"
        GITHUB_CLI_VERSION = '0.11.1'
    }

    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 getOptaPlannerVersion()

                        assert getBuildBranch() == util.getReleaseBranchFromVersion(getProjectVersion())
                    }

                    installGithubCLI()
                }
            }
        }
        stage('Merge deploy PR and tag') {
            when {
                expression { return isRelease() }
            }
            steps{
                script {
                    dir(getRepoName()) {
                        checkoutRepo()
                        mergeAndPush(getDeployPrLink())
                        tagLatest()

                        if(params.UPDATE_STABLE_BRANCH) {
                            githubscm.createBranch('stable')
                            forcePushProtectedBranch('stable', 'master')
                        }
                    }
                }
            }
        }
        stage('Set examples next snapshot version'){
            when {
                expression { return isRelease() }
            }
            steps {
                script {
                    dir('bot') {
                        prepareForPR()

                        maven.mvnVersionsUpdateParentAndChildModules(getMavenCommand(), getSnapshotVersion(), true)
                        maven.mvnSetVersionProperty(getMavenCommand(),'version.org.optaplanner', util.getNextVersion(getOptaPlannerVersion(), 'micro'))

                        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 getOptaPlannerVersion() {
    return getParamOrDeployProperty('OPTAPLANNER_VERSION', 'optaplanner.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 addNotIgnoredPoms() {
    // based on https://stackoverflow.com/a/59888964/8811872
    sh '''
    find . -type f -name 'pom.xml' > found_poms.txt
    poms_to_add=""
    while IFS= read -r pom; do
        if ! git check-ignore -q "\$pom"; then
            poms_to_add="\$poms_to_add \$pom"
        fi
    done < found_poms.txt
    rm found_poms.txt
    git add \$poms_to_add
    '''
}

void commitAndCreatePR() {
    def commitMsg = "[${getBuildBranch()}] Update version to ${getSnapshotVersion()}"
    def prBody = "Generated by build ${BUILD_TAG}: ${BUILD_URL}.\nPlease do not merge, it should be merged automatically."
    // Not using githubscm.commitChanges() because globbing won't work.
    // See: https://github.com/kiegroup/kogito-runtimes/pull/570#discussion_r449268738
    addNotIgnoredPoms()
    sh "git commit -m '${commitMsg}'"
    githubscm.pushObject('origin', getSnapshotBranch(), getBotAuthorCredsID())
    setPipelinePrLink(githubscm.createPR(commitMsg, prBody, getBuildBranch(), getBotAuthorCredsID()))
}

void installGithubCLI() {
    sh """
    wget https://github.com/cli/cli/releases/download/v${env.GITHUB_CLI_VERSION}/gh_${env.GITHUB_CLI_VERSION}_linux_amd64.tar.gz
    tar xzf gh_${env.GITHUB_CLI_VERSION}_linux_amd64.tar.gz
    mv gh_${env.GITHUB_CLI_VERSION}_linux_amd64/bin/gh .
    rm -r gh_${env.GITHUB_CLI_VERSION}_linux_amd64*
    """
}

void setDefaultBranch(String defaultBranch) {
    withCredentials([string(credentialsId: env.GITHUB_TOKEN_CREDS_ID, variable: 'GITHUB_TOKEN')]) {
        // gh command from https://github.com/cli/cli/issues/929#issuecomment-629253585
        def newDefaultBranch = sh(script: "../gh api -XPATCH 'repos/${getGitAuthor()}/${getRepoName()}' -f default_branch=${defaultBranch} | jq '.default_branch'", returnStdout: true).trim()
        if (newDefaultBranch == "\"${defaultBranch}\"") {
            echo "[INFO] ${getGitAuthor()}/${getRepoName()}'s default branch has been updated to ${newDefaultBranch}."
        } else {
            error 'Couldn\'t update default branch.'
        }
    }
}

void forcePushProtectedBranch(String defaultBranch, String tempBranch) {
    setDefaultBranch(tempBranch)
    withCredentials([usernamePassword(credentialsId: getGitAuthorCredsID(), usernameVariable: 'GIT_USERNAME', passwordVariable: 'GIT_PASSWORD')]) {
        sh """
        git config --local credential.helper \"!f() { echo username=\\$GIT_USERNAME; echo password=\\$GIT_PASSWORD; }; f\"
        git push --delete origin ${defaultBranch}
        git push origin ${defaultBranch}
        """
    }
    setDefaultBranch(defaultBranch)
}

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