Jenkinsfile.deploy

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

import org.kie.jenkins.MavenCommand
import org.kie.jenkins.MavenStagingHelper

deployProperties = [:]

pipeline {
    agent {
        label 'kie-rhel7 && kie-mem16g'
    }

    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

        // Keep here for visitibility
        MAVEN_OPTS = '-Xms1024m -Xmx4g'

        BOT_BRANCH_HASH = "${util.generateHash(10)}"
        MAVEN_DEPLOY_LOCAL_DIR = "${WORKSPACE}/maven_deploy_dir"
    }

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

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

                    if (isRelease() || isCreatePr()) {
                        // Verify version is set
                        assert getProjectVersion()
                        assert getOptaPlannerVersion()

                        if(isRelease()) {
                            // Verify if on right release branch
                            assert getBuildBranch() == util.getReleaseBranchFromVersion(getProjectVersion())
                        }
                    }

                    checkoutRepo()
                }
            }
            post {
                success {
                    script {
                        setDeployPropertyIfNeeded('git.branch', getBuildBranch())
                        setDeployPropertyIfNeeded('git.author', getGitAuthor())
                        setDeployPropertyIfNeeded('project.version', getProjectVersion())
                        setDeployPropertyIfNeeded('release', isRelease())
                        setDeployPropertyIfNeeded('optaplanner.version', getOptaPlannerVersion())
                    }
                }
            }
        }

        stage('Prepare for PR') {
            when {
                expression { return isRelease() || isCreatePr() }
            }
            steps {
                prepareForPR()
            }
        }
        stage('Update project version') {
            when {
                expression { return getProjectVersion() != '' }
            }
            steps {
                script {
                    maven.mvnVersionsUpdateParentAndChildModules(getMavenCommand(), getProjectVersion(), !isRelease())
                    // Update Optaplanner version
                    maven.mvnSetVersionProperty(getMavenCommand(), 'version.org.optaplanner', getOptaPlannerVersion())
                }
            }
        }
        stage('Build kogito-apps') {
            steps {
                script {
                    getMavenCommand().skipTests(params.SKIP_TESTS).run('clean install')
                }
            }
            post {
                always {
                    saveReports(params.SKIP_TESTS)
                }
            }
        }
        stage('Deploy artifacts') {
            steps {
                script {
                    if (env.MAVEN_DEPLOY_REPOSITORY && env.MAVEN_REPO_CREDS_ID) {
                        // Deploy to specific repository with credentials
                        runMavenDeployLocally()
                        maven.uploadLocalArtifacts(env.MAVEN_REPO_CREDS_ID, getLocalDeploymentFolder(), getMavenRepoZipUrl())
                    } else if(!isRelease() || env.MAVEN_DEPLOY_REPOSITORY) {
                        runMavenDeploy()
                    } else {
                        // Deploy locally and then to staging
                        runMavenDeployLocally()
                        runMavenStage()
                    }
                }
            }
        }
        stage('Create PR') {
            when {
                expression { return isRelease() || isCreatePr()  }
            }
            steps {
                commitAndCreatePR()
            }
            post {
                success {
                    script {
                        setDeployPropertyIfNeeded("${getRepoName()}.pr.source.uri", "https://github.com/${getBotAuthor()}/${getRepoName()}")
                        setDeployPropertyIfNeeded("${getRepoName()}.pr.source.ref", getBotBranch())
                        setDeployPropertyIfNeeded("${getRepoName()}.pr.target.uri", "https://github.com/${getGitAuthor()}/${getRepoName()}")
                        setDeployPropertyIfNeeded("${getRepoName()}.pr.target.ref", getBuildBranch())
                    }
                }
            }
        }
    }
    post {
        always {
            script {
                def propertiesStr = deployProperties.collect { entry ->  "${entry.key}=${entry.value}" }.join('\n')
                writeFile(text: propertiesStr, file: 'deployment.properties')
                archiveArtifacts(artifacts: 'deployment.properties')
            }
        }
        cleanup {
            script {
                util.cleanNode('docker')
            }
        }
    }
}

void saveReports(boolean allowEmpty=false) {
    junit testResults: '**/target/surefire-reports/**/*.xml, **/target/failsafe-reports/**/*.xml', allowEmptyResults: allowEmpty
}

void checkoutRepo() {
    dir(getRepoName()) {
        deleteDir()
        checkout(githubscm.resolveRepository(getRepoName(), getGitAuthor(), getBuildBranch(), false))
    }
}

void prepareForPR() {
    dir(getRepoName()) {
        githubscm.forkRepo(getBotAuthorCredsID())
        githubscm.createBranch(getBotBranch())
    }
}

void commitAndCreatePR() {
    def commitMsg = "[${getBuildBranch()}] Update version to ${getProjectVersion()}"
    def prBody = "Generated by build ${BUILD_TAG}: ${BUILD_URL}."
    if (isRelease()) {
        prBody += '\nPlease do not merge, it should be merged automatically after testing.'
    } else {
        prBody += '\nPlease review and merge.'
    }
    dir(getRepoName()) {
        githubscm.commitChanges(commitMsg, { githubscm.findAndStageNotIgnoredFiles('pom.xml') })
        githubscm.pushObject('origin', getBotBranch(), getBotAuthorCredsID())
        deployProperties["${getRepoName()}.pr.link"] = githubscm.createPR(commitMsg, prBody, getBuildBranch(), getBotAuthorCredsID())
    }
}

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

boolean isCreatePr() {
    return params.CREATE_PR
}

String getRepoName(){
    return env.REPO_NAME
}

String getGitAuthor() {
    // GIT_AUTHOR can be env or param
    return "${GIT_AUTHOR}"
}

String getBuildBranch(){
    return params.BUILD_BRANCH_NAME
}

String getProjectVersion() {
    return params.PROJECT_VERSION
}

String getOptaPlannerVersion() {
    return params.OPTAPLANNER_VERSION
}

String getBotBranch() {
    return "${getProjectVersion()}-${env.BOT_BRANCH_HASH}"
}

String getBotAuthor(){
    return env.GIT_AUTHOR_BOT
}

String getBotAuthorCredsID(){
    return env.BOT_CREDENTIALS_ID
}

void setDeployPropertyIfNeeded(String key, def value) {
    if (value != null && value != '') {
        deployProperties[key] = value
    }
}

MavenCommand getMavenCommand(){
    MavenCommand mvnCmd = new MavenCommand(this, ['-fae'])
                .withSettingsXmlId(env.MAVEN_SETTINGS_CONFIG_FILE_ID)
                .inDirectory(getRepoName())
                .withProperty('full')
    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')
}

void runMavenDeployLocally() {
    getMavenCommand()
        .skipTests(true)
        .withLocalDeployFolder(getLocalDeploymentFolder())
        .run('clean deploy')
}

void runMavenStage() {
    MavenStagingHelper stagingHelper = getStagingHelper()
    deployProperties.putAll(stagingHelper.stageLocalArtifacts(env.NEXUS_STAGING_PROFILE_ID, getLocalDeploymentFolder()))
    stagingHelper.promoteStagingRepository(env.NEXUS_BUILD_PROMOTION_PROFILE_ID)
}

MavenStagingHelper getStagingHelper() {
    return new MavenStagingHelper(this, getMavenCommand())
                .withNexusReleaseUrl(env.NEXUS_RELEASE_URL)
                .withNexusReleaseRepositoryId(env.NEXUS_RELEASE_REPOSITORY_ID)
}

String getLocalDeploymentFolder(){
    return "${env.MAVEN_DEPLOY_LOCAL_DIR}/${getRepoName()}"
} 

String getMavenRepoZipUrl() {
     return "${env.MAVEN_DEPLOY_REPOSITORY.replaceAll('/content/', '/service/local/').replaceFirst('/*$', '')}/content-compressed"
}