corda/.ci/dev/compatibility/JenkinsfileJDK11Azul

#!groovy
/**
 * Jenkins pipeline to build Corda OS release with JDK11
 */

/**
 * Kill already started job.
 * Assume new commit takes precendence and results from previous
 * unfinished builds are not required.
 * This feature doesn't play well with disableConcurrentBuilds() option
 */
@Library('corda-shared-build-pipeline-steps')
import static com.r3.build.BuildControl.killAllExistingBuildsForJob

killAllExistingBuildsForJob(env.JOB_NAME, env.BUILD_NUMBER.toInteger())

/**
 * Sense environment
 */
boolean isReleaseTag = (env.TAG_NAME =~ /^release.*JDK11$/)

/*
** calculate the stage for NexusIQ evaluation
**  * build for snapshots
**  * stage-release:  for release candidates and for health checks
**  * operate: for final release
*/
def nexusDefaultIqStage = "build"
if (isReleaseTag) {
    switch (env.TAG_NAME) {
        case ~/.*-RC\d+(-.*)?/: nexusDefaultIqStage = "stage-release"; break;
        case ~/.*-HC\d+(-.*)?/: nexusDefaultIqStage = "stage-release"; break;
        default: nexusDefaultIqStage = "release"
    }
}

/**
 * make sure calculated default value of NexusIQ stage is first in the list
 * thus making it default for the `choice` parameter
 */
def nexusIqStageChoices = [nexusDefaultIqStage].plus(
                [
                        'develop',
                        'build',
                        'stage-release',
                        'release',
                        'operate'
                ].minus([nexusDefaultIqStage]))

pipeline {
    agent { label 'k8s' }
    options {
        timestamps()
        timeout(time: 3, unit: 'HOURS')
        buildDiscarder(logRotator(daysToKeepStr: '14', artifactDaysToKeepStr: '14'))
    }

    parameters {
        choice choices: nexusIqStageChoices, description: 'NexusIQ stage for code evaluation', name: 'nexusIqStage'
    }

    environment {
        DOCKER_TAG_TO_USE = "${env.GIT_COMMIT.subSequence(0, 8)}JDK11"
        EXECUTOR_NUMBER = "${env.EXECUTOR_NUMBER}"
        BUILD_ID = "${env.BUILD_ID}-${env.JOB_NAME}"
        ARTIFACTORY_CREDENTIALS = credentials('artifactory-credentials')
        ARTIFACTORY_BUILD_NAME = "Corda / Publish / Publish JDK 11 Release to Artifactory".replaceAll("/", "::")
        CORDA_ARTIFACTORY_USERNAME = "${env.ARTIFACTORY_CREDENTIALS_USR}"
        CORDA_ARTIFACTORY_PASSWORD = "${env.ARTIFACTORY_CREDENTIALS_PSW}"
    }

    stages {
        /*
        * Temporarily disable Sonatype checks for regression builds
        */
        stage('Sonatype Check') {
            when {
                expression { isReleaseTag }
            }
            steps {
                sh "./gradlew --no-daemon clean jar"
                script {
                    sh "./gradlew --no-daemon properties | grep -E '^(version|group):' >version-properties"
                    /* every build related to Corda X.Y (GA, RC, HC, patch or snapshot) uses the same NexusIQ application */
                    def version = sh (returnStdout: true, script: "grep ^version: version-properties | sed -e 's/^version: \\([0-9]\\+\\(\\.[0-9]\\+\\)\\+\\).*\$/\\1/'").trim()
                    def groupId = sh (returnStdout: true, script: "grep ^group: version-properties | sed -e 's/^group: //'").trim()
                    def artifactId = 'corda'
                    nexusAppId = "${groupId}-${artifactId}-${version}"
                }
                nexusPolicyEvaluation (
                        failBuildOnNetworkError: false,
                        iqApplication: selectedApplication(nexusAppId), // application *has* to exist before a build starts!
                        iqScanPatterns: [[scanPattern: 'node/capsule/build/libs/corda*.jar']],
                        iqStage: params.nexusIqStage
                )
            }
        }

        stage('Generate Build Image') {
            steps {
                withCredentials([string(credentialsId: 'container_reg_passwd', variable: 'DOCKER_PUSH_PWD')]) {
                    sh "./gradlew " +
                            "-Dkubenetize=true " +
                            "-Ddocker.push.password=\"\${DOCKER_PUSH_PWD}\" " +
                            "-Ddocker.work.dir=\"/tmp/\${EXECUTOR_NUMBER}\" " +
                            "-Ddocker.build.tag=\"\${DOCKER_TAG_TO_USE}\" " +
                            "-Ddocker.buildbase.tag=11latest " +
                            "-Ddocker.container.env.parameter.CORDA_ARTIFACTORY_USERNAME=\"\${ARTIFACTORY_CREDENTIALS_USR}\" " +
                            "-Ddocker.container.env.parameter.CORDA_ARTIFACTORY_PASSWORD=\"\${ARTIFACTORY_CREDENTIALS_PSW}\" " +
                            "-Ddocker.dockerfile=DockerfileJDK11Azul" +
                            " clean preAllocateForAllParallelUnitTest preAllocateForAllParallelIntegrationTest " +
                            " preAllocateForAllParallelSlowIntegrationTest preAllocateForAllParallelSmokeTest " +
                            " pushBuildImage --stacktrace"
                }
                sh "kubectl auth can-i get pods"
            }
        }

        stage('Testing phase') {
            parallel {
                stage('Unit Test') {
                    steps {
                        sh "./gradlew " +
                                "-DbuildId=\"\${BUILD_ID}\" " +
                                "-Dkubenetize=true " +
                                "-Ddocker.run.tag=\"\${DOCKER_TAG_TO_USE}\" " +
                                "-Dartifactory.username=\"\${ARTIFACTORY_CREDENTIALS_USR}\" " +
                                "-Dartifactory.password=\"\${ARTIFACTORY_CREDENTIALS_PSW}\" " +
                                "-Dgit.branch=\"\${GIT_BRANCH}\" " +
                                "-Dgit.target.branch=\"\${GIT_BRANCH}\" " +
                                " allParallelUnitTest --stacktrace"
                    }
                }
                stage('Integration Test') {
                    steps {
                        sh "./gradlew " +
                                "-DbuildId=\"\${BUILD_ID}\" " +
                                "-Dkubenetize=true " +
                                "-Ddocker.run.tag=\"\${DOCKER_TAG_TO_USE}\" " +
                                "-Dartifactory.username=\"\${ARTIFACTORY_CREDENTIALS_USR}\" " +
                                "-Dartifactory.password=\"\${ARTIFACTORY_CREDENTIALS_PSW}\" " +
                                "-Dgit.branch=\"\${GIT_BRANCH}\" " +
                                "-Dgit.target.branch=\"\${GIT_BRANCH}\" " +
                                " allParallelIntegrationTest --stacktrace"
                    }
                }
                stage('Smoke Test') {
                    steps {
                        sh "./gradlew " +
                                "-DbuildId=\"\${BUILD_ID}\" " +
                                "-Dkubenetize=true " +
                                "-Ddocker.run.tag=\"\${DOCKER_TAG_TO_USE}\" " +
                                "-Dartifactory.username=\"\${ARTIFACTORY_CREDENTIALS_USR}\" " +
                                "-Dartifactory.password=\"\${ARTIFACTORY_CREDENTIALS_PSW}\" " +
                                "-Dgit.branch=\"\${GIT_BRANCH}\" " +
                                "-Dgit.target.branch=\"\${GIT_BRANCH}\" " +
                                " allParallelSmokeTest --stacktrace"
                    }
                }
                stage('Slow Integration Test') {
                    steps {
                        sh "./gradlew " +
                                "-DbuildId=\"\${BUILD_ID}\" " +
                                "-Dkubenetize=true " +
                                "-Ddocker.run.tag=\"\${DOCKER_TAG_TO_USE}\" " +
                                "-Dartifactory.username=\"\${ARTIFACTORY_CREDENTIALS_USR}\" " +
                                "-Dartifactory.password=\"\${ARTIFACTORY_CREDENTIALS_PSW}\" " +
                                "-Dgit.branch=\"\${GIT_BRANCH}\" " +
                                "-Dgit.target.branch=\"\${GIT_BRANCH}\" " +
                                " allParallelSlowIntegrationTest --stacktrace"
                    }
                }
            }
        }

        stage('Publish to Artifactory') {
            agent {
                dockerfile {
                    reuseNode true
                    additionalBuildArgs "--build-arg USER=stresstester"
                    filename '.ci/dev/compatibility/DockerfileJDK11'
                }
            }
            when {
                expression { isReleaseTag }
            }
            steps {
                rtServer(
                        id: 'R3-Artifactory',
                        url: 'https://software.r3.com/artifactory',
                        credentialsId: 'artifactory-credentials'
                )
                rtGradleDeployer(
                        id: 'deployer',
                        serverId: 'R3-Artifactory',
                        repo: 'corda-releases'
                )
                rtGradleRun(
                        usesPlugin: true,
                        useWrapper: true,
                        switches: '-s --info',
                        tasks: 'artifactoryPublish',
                        deployerId: 'deployer',
                        buildName: env.ARTIFACTORY_BUILD_NAME
                )
                rtPublishBuildInfo(
                        serverId: 'R3-Artifactory',
                        buildName: env.ARTIFACTORY_BUILD_NAME
                )
            }
        }
    }

    post {
        always {
            archiveArtifacts artifacts: '**/pod-logs/**/*.log', fingerprint: false
            junit testResults: '**/build/test-results-xml/**/*.xml', keepLongStdio: true
        }
        cleanup {
            deleteDir() /* clean up our workspace */
        }
    }
}