Jenkinsfile.drools

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

import org.kie.jenkins.MavenCommand

pipeline {
    agent {
        label 'kie-rhel7 && kie-mem16g'
    }
    tools {
        maven 'kie-maven-3.6.2'
        jdk 'kie-jdk11'
    }
    options {
        timeout(time: 360, unit: 'MINUTES')
    }

    environment {
        // Some generated env is also defined into .jenkins/dsl/jobs.groovy file

        KOGITO_CI_EMAIL_TO = credentials("${JENKINS_EMAIL_CREDS_ID}")
        MAVEN_OPTS = '-Xms1024m -Xmx4g'

        // Set into 'Initialize' stage
        // DROOLS_VERSION
    }
    stages {
        stage('Initialize') {
            steps {
                script {
                    checkoutDroolsRepo()

                    checkoutRepo('kogito-runtimes')
                    checkoutRepo('kogito-runtimes', 'integration-tests')
                    checkoutOptaplannerRepo()
                    checkoutRepo('kogito-apps')
                    checkoutRepo('kogito-examples')
                    checkoutRepo('kogito-examples', 'kogito-examples-persistence')
                    checkoutRepo('kogito-examples', 'kogito-examples-events')

                    if (params.DROOLS_VERSION) {
                        currentBuild.displayName = "Check against ${DROOLS_VERSION}"
                    } else {
                        currentBuild.displayName = "Check against Drools snapshot"
                    }
                }
            }
        }
        stage('Retrieve drools snapshot version') {
            when { expression { return !params.DROOLS_VERSION } }
            steps {
                script {
                    dir('drools') {
                        // query mvn to get the latest version
                        env.DROOLS_VERSION = """${sh (
                                script: 'mvn org.apache.maven.plugins:maven-help-plugin:3.2.0:evaluate -Dexpression=project.version -q -DforceStdout',
                                returnStdout: true
                            ).trim()}"""
                        assert env.DROOLS_VERSION != ''
                        echo "Latest kie7 version is: ${env.DROOLS_VERSION}"
                    }
                }
            }
        }
        stage('Build kogito-runtimes') {
            steps {
                script {
                    getMavenCommandWithDroolsVersion('kogito-runtimes')
                        .run('clean install')
                }
            }
            post {
                always {
                    script {
                        cleanContainers()
                    }
                }
            }
        }
        stage('Check Runtimes integration-tests with persistence') {
            steps {
                script {
                    getMavenCommandWithDroolsVersion('integration-tests')
                        .withProfiles(['persistence'])
                        .run('clean verify')
                }
            }
            post {
                always {
                    script {
                        cleanContainers()
                    }
                }
            }
        }
        stage('Build optaplanner') {
            steps {
                script {
                    getMavenCommandWithDroolsVersion('optaplanner')
                        .run('clean install')
                }
            }
            post {
                always {
                    script {
                        cleanContainers()
                    }
                }
            }
        }
        stage('Build kogito-apps') {
            steps {
                script {
                    getMavenCommandWithDroolsVersion('kogito-apps')
                        .run('clean install')
                }
            }
            post {
                always {
                    script {
                        cleanContainers()
                    }
                }
            }
        }
        stage('Build kogito-examples') {
            steps {
                script {
                    getMavenCommandWithDroolsVersion('kogito-examples')
                        .run('clean install')
                }
            }
            post {
                always {
                    script {
                        cleanContainers()
                    }
                }
            }
        }
        stage('Build kogito-examples with persistence') {
            steps {
                script {
                    getMavenCommandWithDroolsVersion('kogito-examples-persistence')
                        .withProfiles(['persistence'])
                        .run('clean verify')
                }
            }
            post {
                always {
                    script {
                        cleanContainers()
                    }
                }
            }
        }
        stage('Build kogito-examples with events') {
            steps {
                script {
                    getMavenCommandWithDroolsVersion('kogito-examples-events')
                        .withProfiles(['events'])
                        .run('clean verify')
                }
            }
            post {
                always {
                    script {
                        cleanContainers()
                    }
                }
            }
        }
    }
    post {
        unsuccessful {
            sendNotification()
        }
        always {
            script {
                junit '**/target/surefire-reports/**/*.xml, **/target/failsafe-reports/**/*.xml'
            }
        }
        cleanup {
            script {
                util.cleanNode('docker')
            }
        }
    }
}

void sendNotification() {
    if (!params.DROOLS_VERSION) {
        emailext body: "Kogito daily Drools #${BUILD_NUMBER} was: ${currentBuild.currentResult}\nPlease look here: ${BUILD_URL}",
             subject: "[${params.BUILD_BRANCH_NAME}][d] Runtimes Drools snapshot",
             to: env.KOGITO_CI_EMAIL_TO
    }
    // Do not send a notification in case DROOLS_VERSION was given
}

void checkoutRepo(String repoName, String dirName=repoName) {
    dir(dirName) {
        checkout(githubscm.resolveRepository(repoName, params.GIT_AUTHOR, params.BUILD_BRANCH_NAME, false))
    }
}

void checkoutDroolsRepo() {
    dir('drools') {
        checkout(githubscm.resolveRepository('drools', 'kiegroup', 'master', false))
    }
}

void checkoutOptaplannerRepo() {
    String targetBranch = params.BUILD_BRANCH_NAME
    String [] versionSplit = targetBranch.split("\\.")
    if (versionSplit.length == 3
        && versionSplit[0].isNumber()
        && versionSplit[1].isNumber()
       && versionSplit[2] == 'x') {
        targetBranch = "${Integer.parseInt(versionSplit[0]) + 7}.${versionSplit[1]}.x"
    } else {
        echo "Cannot parse branch as release branch so going further with current value: ${targetBranch}"
    }
    dir('optaplanner') {
        checkout(githubscm.resolveRepository('optaplanner', params.GIT_AUTHOR, targetBranch, false))
    }
}

MavenCommand getMavenCommandWithDroolsVersion(String directory) {
    mvnCmd = new MavenCommand(this, ['-fae'])
                .withSettingsXmlId('kogito_release_settings')
                .inDirectory(directory)
                .withProperty('version.org.kie7', "${DROOLS_VERSION}")
    if (params.DROOLS_REPOSITORY) {
        mvnCmd.withDependencyRepositoryInSettings('drools_repo', params.DROOLS_REPOSITORY)
    }
    return mvnCmd
}

void cleanContainers() {
    cloud.cleanContainersAndImages('docker')
}