Jenkinsfile.buildchain

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

import org.kie.jenkins.MavenCommand
import org.kie.jenkins.MavenSettingsUtils

agentLabel = "${env.ADDITIONAL_LABEL?.trim() ?: 'ubuntu'} && !built-in"
timeoutValue = env.ADDITIONAL_TIMEOUT?.trim() ?: '360'
jdkTool = env.BUILD_JDK_TOOL
sonarJdkTool = env.SONAR_JDK_TOOL
mavenTool = env.BUILD_MAVEN_TOOL

mavenDeployArtifacts = Boolean.valueOf(env.ENABLE_DEPLOY)
mavenDeployRepository = env.MAVEN_DEPLOY_REPOSITORY ?: ''
mavenDeployRepositoryCredsId = env.MAVEN_DEPLOY_REPOSITORY_CREDS_ID ?: ''
mavenDeployLocalDir = env.MAVEN_DEPLOY_LOCAL_DIR ?: ''

buildChainType = env.BUILDCHAIN_TYPE?.trim() ?: 'cross_pr'
buildChainProject = env.BUILDCHAIN_PROJECT?.trim()
defaultSettingsXmlId = isPRBuildChainType() || isFDBBuildChainType() ? 'kie-pr-settings' : 'kie-release-settings'
settingsXmlId = env.MAVEN_SETTINGS_FILE_ID ?: defaultSettingsXmlId

enableSonarCloudAnalysis = env.ENABLE_SONARCLOUD ? env.ENABLE_SONARCLOUD.toBoolean() : false
downstreamBuild = env.DOWNSTREAM_BUILD ? env.DOWNSTREAM_BUILD.toBoolean() : false

buildChainConfigRepo = env.BUILDCHAIN_CONFIG_REPO ?: 'incubator-kie-kogito-pipelines'
buildChainConfigBranch = env.BUILDCHAIN_CONFIG_BRANCH ?: '\${BRANCH:main}'
buildChainConfigGitAuthor = env.BUILDCHAIN_CONFIG_AUTHOR ?: '\${AUTHOR:apache}'
buildChainConfigDefinitionFilePath = env.BUILDCHAIN_CONFIG_FILE_PATH ?: '.ci/pull-request-config.yaml'
buildChainAction = isFDBBuildChainType() ? 'full_downstream' : buildChainType
buildChainAdditionalArguments = buildChainProject ? [ "-p ${buildChainProject}" ] : []
if (isBranchBuildChainType()) {
    buildChainAdditionalArguments.add("-b ${env.GIT_BRANCH_NAME.trim()}")
    buildChainAdditionalArguments.add("-g ${env.GIT_AUTHOR.trim()}")
    if(env.BUILDCHAIN_FULL_BRANCH_DOWNSTREAM_BUILD) {
        buildChainAdditionalArguments.add("--fullProjectDependencyTree")
    }
} else {
    buildChainAdditionalArguments.add("-u ${env.ghprbPullLink}")
}

skipTests = params.SKIP_TESTS ?: false
skipIntegrationTests = params.SKIP_INTEGRATION_TESTS ?: false

launchDownstreamJobs = env.LAUNCH_DOWNSTREAM_JOBS ? env.LAUNCH_DOWNSTREAM_JOBS.split(',') : []

notificationJobName = env.NOTIFICATION_JOB_NAME ?: 'PR'

pipeline {
    agent {
        docker { 
            image env.AGENT_DOCKER_BUILDER_IMAGE
            label util.avoidFaultyNodes(agentLabel)
            args env.AGENT_DOCKER_BUILDER_ARGS
        }
    }
    options {
        timestamps()
        timeout(time: timeoutValue, unit: 'MINUTES')
    }
    stages {
        stage('Initialize') {
            steps {
                script {
                    sh 'printenv > env_props'
                    archiveArtifacts artifacts: 'env_props'
                    util.waitForDocker()
                    sh 'ls -last /var/run/docker.sock'

                    if (mavenDeployArtifacts) {
                        assert mavenDeployRepository : 'Please provide the maven deploy repository'
                        assert mavenDeployRepositoryCredsId : 'Please provide the maven deploy repository credentials'
                    }

                    currentBuild.displayName = params.DISPLAY_NAME ?: env.GIT_BRANCH_NAME ?: currentBuild.displayName
                }
            }
        }
        stage('Perform build steps') {
            stages {
                stage('Install build-chain tool') {
                    steps {
                        script {
                            println '[INFO] Getting build-chain version from composite action file'
                            def buildChainVersion = buildChain.getBuildChainVersionFromCompositeActionFile()
                            if ([null, 'null'].contains(buildChainVersion)) {
                                def errorMessage = "[ERROR] The build-chain version can't be recovered. Please contact administrator"
                                println errorMessage
                                error(errorMessage)
                            }
                            println "[INFO] build-chain version recovered '${buildChainVersion}'"
                            sh "npm install -g @kie/build-chain-action@${buildChainVersion}${env.NPM_REGISTRY_URL ? " -registry=${NPM_REGISTRY_URL}" : ''}"

                            sh "npm list -g | grep build-chain"
                            sh 'sudo alternatives --install /usr/local/bin/build-chain build-chain ${NODE_HOME}/bin/build-chain 1'
                            sh 'build-chain || true'
                        }
                    }
                }
                stage('Build projects') {
                    steps {
                        script {
                            env.BUILD_MVN_OPTS_CURRENT = "${env.BUILD_MVN_OPTS_CURRENT ?: ''} ${getBuildMavenOptsCurrent()}"
                            echo "BUILD_MVN_OPTS_CURRENT = ${BUILD_MVN_OPTS_CURRENT}"
                            Closure buildchainCommandClosure = {
                                configFileProvider([configFile(fileId: settingsXmlId, variable: 'MAVEN_SETTINGS_FILE')]) {
                                    withCredentials([string(credentialsId: "${BUILDCHAIN_CONFIG_GIT_TOKEN_CREDENTIALS_ID}", variable: 'GITHUB_TOKEN')]) {
                                        env.BUILD_MVN_OPTS = "${env.BUILD_MVN_OPTS ?: ''} -s ${MAVEN_SETTINGS_FILE} -Dmaven.wagon.http.ssl.insecure=true -Dmaven.test.failure.ignore=true"
                                        echo "BUILD_MVN_OPTS = ${BUILD_MVN_OPTS}"

                                        sh getBuildChainCommandline(true)
                                    }
                                }
                            }
                            if (mavenDeployArtifacts) {
                                withCredentials([usernamePassword(credentialsId: mavenDeployRepositoryCredsId, usernameVariable: 'REPOSITORY_USER', passwordVariable: 'REPOSITORY_TOKEN')]) {
                                    env.DEPLOY_MVN_OPTS = "${env.DEPLOY_MVN_OPTS ?: ''} -DdeployAtEnd -Dapache.repository.username=${REPOSITORY_USER} -Dapache.repository.password=${REPOSITORY_TOKEN} -DretryFailedDeploymentCount=5"
                                    echo "DEPLOY_MVN_OPTS = ${DEPLOY_MVN_OPTS}"
                                    // for buildchain not to leak credentials this needs to stay in withCredentials scope
                                    buildchainCommandClosure()
                                }
                            } else {
                                buildchainCommandClosure()
                            }
                        }
                    }
                    post {
                        always {
                            script {
                                // Remove `node_modules` to avoid heap space issues with junit command thereafter
                                // Related to https://github.com/jenkinsci/junit-plugin/issues/478 and https://github.com/jenkinsci/junit-plugin/issues/467
                                sh 'find . -type d -name node_modules -exec rm -rf {} \\; || true'

                                junit(testResults: '**/junit.xml, **/target/surefire-reports/**/*.xml, **/target/failsafe-reports/**/*.xml, **/target/invoker-reports/**/*.xml', allowEmptyResults: true)
                                archiveArtifacts(artifacts: '**/cypress/screenshots/**,**/cypress/videos/**', fingerprint: false, allowEmptyArchive: true)
                            }
                        }
                        unsuccessful {
                            script {
                                util.archiveConsoleLog('', 300)
                            }
                        }
                    }
                }
                stage('Sonar analysis') {
                    when {
                        expression { return enableSonarCloudAnalysis }
                    }
                    steps {
                        script {
                            dir(getProjectFolder()) {
                                configFileProvider([configFile(fileId: settingsXmlId, variable: 'MAVEN_SETTINGS_FILE')]) {
                                    withCredentials([string(credentialsId: 'SONARCLOUD_TOKEN', variable: 'TOKEN')]) {
                                        new MavenCommand(this)
                                            .withProperty('sonar.login', "${TOKEN}")
                                            .withProperty('sonar.organization', 'apache') // override what's in pom.xml for now
                                            .withProperty('sonar.projectKey', env.SONAR_PROJECT_KEY)
                                            .withLogFileName('sonar_analysis.maven.log')
                                            .withSettingsXmlFile(MAVEN_SETTINGS_FILE)
                                            .run("-e -nsu validate -Psonarcloud-analysis -Denforcer.skip=true ${env.SONARCLOUD_ANALYSIS_MVN_OPTS ?: ''}")
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        stage('Trigger downstream jobs') {
            when {
                expression { return launchDownstreamJobs }
            }
            steps {
                script {
                    launchDownstreamJobs.each {
                        echo "Launch downstream jobs with path ${it}"
                        build(job: "${it}", wait: false, parameters: [], propagate: false)
                    }
                }
            }
        }
    }
    post {
        unsuccessful {
            script {
                if (isPRBuildChainType()) {
                    pullrequest.postComment(util.getMarkdownTestSummary(notificationJobName, getReproducer(true), "${BUILD_URL}", 'GITHUB'), "${BUILDCHAIN_CONFIG_GIT_TOKEN_CREDENTIALS_ID}")
                } else if (shouldNotify()) {
                    withCredentials([string(credentialsId: "${JENKINS_EMAIL_CREDS_ID}", variable: 'KOGITO_CI_EMAIL_TO')]) {
                        mailer.sendMarkdownTestSummaryNotification(env.NOTIFICATION_JOB_NAME ?: '', "[${env.GIT_BRANCH_NAME}] ${getRepoNameCamelCase(env.REPO_NAME)}", [env.KOGITO_CI_EMAIL_TO], getReproducer())
                    }
                }
            }
        }
        cleanup {
            cleanWs()
        }
    }
}

boolean isPRBuildChainType() {
    return buildChainType == 'cross_pr'
}

boolean isFDBBuildChainType() {
    return buildChainType == 'full_downstream'
}

boolean isSingleBuildChainType() {
    return buildChainType == 'single'
}

boolean isBranchBuildChainType() {
    return buildChainType == 'branch'
}

String getBuildMavenOptsCurrent() {
    List opts_current = []
    enableSonarCloudAnalysis ? opts_current.add('-Prun-code-coverage') : null
    skipTests ? opts_current.add('-DskipTests') : null
    skipIntegrationTests ? opts_current.add('-DskipITs') : null

    return opts_current.join(' ')
}

boolean shouldNotify() {
    return env.ENABLE_NOTIFICATION
}

String getProjectFolder() {
    def project = (buildChainProject ? util.getProjectGroupName(buildChainProject) : util.getProjectTriggeringJob())[1]

    // First guessing whether there is a clone defined into the buildchain config
    // If not, fallback to simple folder structure
    String projectFolder = "bc/apache_${project}/${project}"
    if (!fileExists(projectFolder)) {
        projectFolder = "bc/apache_${project}"
    }

    return projectFolder
}

String getBuildChainCommandline(boolean includeToken=false) {
    return "build-chain build ${buildChainAction} ${includeToken ? "--token ${GITHUB_TOKEN} " : ''}-f 'https://raw.githubusercontent.com/${buildChainConfigGitAuthor}/${buildChainConfigRepo}/${buildChainConfigBranch}/${buildChainConfigDefinitionFilePath}' -o 'bc' ${buildChainAdditionalArguments.join(' ')} --skipParallelCheckout"
}

String getReproducer(boolean isGH = false) {
    String reproducer = """
${env.QUARKUS_BRANCH ? "export QUARKUS_BRANCH=${env.QUARKUS_BRANCH}" : ''}
${env.BUILD_MVN_OPTS_CURRENT ? "export BUILD_MVN_OPTS_CURRENT=${env.BUILD_MVN_OPTS_CURRENT}" : ''}
${getBuildChainCommandline()}

NOTE: To install the build-chain tool, please refer to https://github.com/kiegroup/github-action-build-chain#local-execution
"""

    if(isGH) {
        return """
<details>
<summary><b>Reproducer</b></summary>
${reproducer}
</details>
"""
    } else {
        return """
```spoiler Reproducer
${reproducer}
```
"""
    }
}

String getRepoNameCamelCase(String repo) {
    List words = repo.split('-') as List
    return words.collect { it.isEmpty() ? it : it.substring(0, 1).toUpperCase() + it.substring(1).toLowerCase() }.join(' ')
}

String getMavenDeployLocalDir() {
    return mavenDeployLocalDir ?: "${WORKSPACE}/maven_deploy_dir"
}