Jenkinsfile.deploy

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

// As Cekit is not compatible with podman, we use docker in that pipeline

IMAGES = [
            "kogito-quarkus-ubi8", 
            "kogito-quarkus-jvm-ubi8",
            "kogito-quarkus-ubi8-s2i",
            "kogito-springboot-ubi8",
            "kogito-springboot-ubi8-s2i",
            "kogito-data-index",
            "kogito-jobs-service",
            "kogito-management-console"
         ]

// Should be a single pipeline (not multibranch)
pipeline {
    agent {
        label 'kogito-image-slave && !master'
    }

    // Needed for local build
    tools {
        jdk 'kie-jdk11'
    }

    parameters {
        string(name: 'DISPLAY_NAME', defaultValue: '', description: 'Setup a specific build display name')
        
        string(name: 'BUILD_BRANCH_NAME', defaultValue: 'master', description: 'Which branch to build ? Set if you are not on a multibranch pipeline.')
        string(name: 'GIT_AUTHOR', defaultValue: 'kiegroup', description: 'Which Git author repository ?')

        booleanParam(name: 'IMAGE_USE_OPENSHIFT_REGISTRY', defaultValue: false, description: 'Set to true if image should be deployed in Openshift registry.In this case, IMAGE_REGISTRY_CREDENTIALS, IMAGE_REGISTRY and IMAGE_NAMESPACE parameters will be ignored')
        string(name: 'IMAGE_REGISTRY_CREDENTIALS', defaultValue: '', description: 'Image registry credentials to use to deploy images. Will be ignored if no IMAGE_REGISTRY is given')
        string(name: 'IMAGE_REGISTRY', defaultValue: '', description: 'Image registry to use to deploy images')
        string(name: 'IMAGE_NAMESPACE', defaultValue: 'kiegroup', description: 'Image namespace to use to deploy images')
        string(name: 'IMAGE_NAME_SUFFIX', defaultValue: '', description: 'Image name suffix to use to deploy images. In case you need to change the final image name, you can add a suffix to it.')
        string(name: 'IMAGE_TAG', defaultValue: '', description: 'Image tag to use to deploy images')

        string(name: 'MAVEN_ARTIFACT_REPOSITORY', defaultValue: '', description: 'Maven repository where the build artifacts are present')

        booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: 'Skip tests')
    }

    environment {
        JAVA_HOME = "${GRAALVM_HOME}"

        OPENSHIFT_API = credentials("OPENSHIFT_API")
        OPENSHIFT_REGISTRY = credentials("OPENSHIFT_REGISTRY")
        OPENSHIFT_CREDS_KEY = "OPENSHIFT_CREDS"
    }

    stages {
        stage('Initialization') {
            steps {
                script {  
                    clean()

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

                    checkout(githubscm.resolveRepository("kogito-images", params.GIT_AUTHOR, params.BUILD_BRANCH_NAME, false))

                    // Set the mirror url only if no artifact repository is given
                    if (params.MAVEN_ARTIFACT_REPOSITORY == '' 
                            && env.MAVEN_MIRROR_REPOSITORY != null
                            && env.MAVEN_MIRROR_REPOSITORY != ''){
                        echo "Set Maven mirror url"
                        env.MAVEN_MIRROR_URL = env.MAVEN_MIRROR_REPOSITORY
                    }
                }
            }
        }
        stage('Update Maven information') {
            steps {
                script {
                    // Update artifacts
                    updateArtifactCmd = "python3 scripts/update-maven-information.py"
                    if(params.MAVEN_ARTIFACT_REPOSITORY != ''){
                        updateArtifactCmd += " --repo-url ${params.MAVEN_ARTIFACT_REPOSITORY}"
                    }
                    sh updateArtifactCmd

                    // Debug purpose in case of issue
                    sh "cat modules/kogito-data-index/module.yaml"
                    sh "cat modules/kogito-jobs-service/module.yaml"
                    sh "cat modules/kogito-management-console/module.yaml"
                }
            }
        }
        stage('Setup tests repository') {
            when {
                expression {
                    return params.MAVEN_ARTIFACT_REPOSITORY != ''
                }
            }
            steps {
                script {
                    // Update repo in tests
                    sh "python3 scripts/update-tests-maven-repo.py --repo-url ${params.MAVEN_ARTIFACT_REPOSITORY}"

                    // Debug purpose in case of issue
                    sh "cat tests/test-apps/clone-repo.sh"
                    sh "cat tests/features/kogito-quarkus-ubi8-s2i.feature"
                    sh "cat tests/features/kogito-springboot-ubi8-s2i.feature"
                }
            }
        }
        stage('Validate CeKit Image and Modules descriptors') {
            steps {
                sh """
                    curl -Ls https://github.com/kiegroup/kie-cloud-tools/releases/download/1.0-SNAPSHOT/cekit-image-validator-runner.tgz --output cekit-image-validator-runner.tgz
                    tar -xzvf cekit-image-validator-runner.tgz
                    chmod +x cekit-image-validator-runner
                """
                sh "./cekit-image-validator-runner modules/"
                sh """
                    ./cekit-image-validator-runner image.yaml
                    ./cekit-image-validator-runner kogito-data-index-overrides.yaml
                    ./cekit-image-validator-runner kogito-jobs-service-overrides.yaml
                    ./cekit-image-validator-runner kogito-management-console-overrides.yaml
                    ./cekit-image-validator-runner kogito-quarkus-jvm-overrides.yaml
                    ./cekit-image-validator-runner kogito-quarkus-overrides.yaml
                    ./cekit-image-validator-runner kogito-quarkus-s2i-overrides.yaml
                    ./cekit-image-validator-runner kogito-springboot-overrides.yaml
                    ./cekit-image-validator-runner kogito-springboot-s2i-overrides.yaml
                """
            }
        }
        stage('Prepare offline kogito-examples') {
            when {
                expression {
                    return !params.SKIP_TESTS;
                }
            }
            steps {
                sh "make clone-repos"
            }
        }
        stage('Build and Test Images'){
            steps{
                script {
                    build_stages = [:]
                    IMAGES.each{ image -> build_stages[image] = {
                            initWorkspace(image)
                            dir(getWorkspacePath(image)){
                                try{
                                    sh "make ${image} ignore_test=${params.SKIP_TESTS} cekit_option='--work-dir .'"
                                }
                                finally{
                                    junit testResults: 'target/test/results/*.xml', allowEmptyResults: true
                                }
                            
                            }
                        }
                    }
                    parallel build_stages
                }
            }
        }
        stage('Tagging') {
            steps {
                script {
                    tagImages()
                }
            }
        }
        stage('Pushing') {
            steps {
                script {
                    if (isDeployImageInOpenshiftRegistry()) {
                        loginOpenshiftRegistry()
                    } else if (getDeployImageRegistryCredentials() != ''){
                        loginContainerRegistry(getDeployImageRegistry(), getDeployImageRegistryCredentials())
                    }
                    pushImages()
                }
            }
        }
    }
    post {
        always {
            script{
                clean()
            }
        }
    }
}

void clean() {
    cleanWorkspaces()
    cleanImages()

    // Clean Cekit cache, in case we reuse an old node
    sh "rm -rf \$HOME/.cekit/cache"
}

void cleanImages(){
    sh "docker rm -f \$(docker ps -a -q) || date"
    sh "docker rmi -f \$(docker images -q) || date"
}

void tagImages() {
    for(String imageName : IMAGES) {
        sh "docker tag quay.io/kiegroup/${imageName}:latest ${buildImageName(imageName)}"
    }
}

void pushImages() {
    for(String imageName : IMAGES) {
        sh "docker push ${buildImageName(imageName)}"
    }
}

String buildImageName(String imageName) {
    String finalImageName = imageName
    if(getDeployImageNameSuffix() != ''){
        finalImageName += "-" + getDeployImageNameSuffix()
    }
    return "${getDeployImageRegistry()}/${getDeployImageNamespace()}/${finalImageName}:${getDeployImageTag()}"
}

void loginOpenshift(){
    withCredentials([usernamePassword(credentialsId: env.OPENSHIFT_CREDS_KEY, usernameVariable: 'OC_USER', passwordVariable: 'OC_PWD')]){
        sh "oc login --username=${OC_USER} --password=${OC_PWD} --server=${env.OPENSHIFT_API} --insecure-skip-tls-verify"
    }
}

void loginOpenshiftRegistry(){
    loginOpenshift()
    // username can be anything. See https://docs.openshift.com/container-platform/4.4/registry/accessing-the-registry.html#registry-accessing-directly_accessing-the-registry
    sh "set +x && docker login -u anything -p \$(oc whoami -t) ${env.OPENSHIFT_REGISTRY}"
}

void loginContainerRegistry(String registry, String credsId){
    withCredentials([usernamePassword(credentialsId: credsId, usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PWD')]) {
        sh "docker login -u ${REGISTRY_USER} -p ${REGISTRY_PWD} ${registry}"
    }
}

////////////////////////////////////////////////////////////////////////
// Deploy image information
////////////////////////////////////////////////////////////////////////

boolean isDeployImageInOpenshiftRegistry(){
    return params.IMAGE_USE_OPENSHIFT_REGISTRY
}

String getDeployImageRegistryCredentials(){
    return isDeployImageInOpenshiftRegistry() ? "" : params.IMAGE_REGISTRY_CREDENTIALS
}

String getDeployImageRegistry(){
    return isDeployImageInOpenshiftRegistry() ? env.OPENSHIFT_REGISTRY : params.IMAGE_REGISTRY
}

String getDeployImageNamespace(){
    return isDeployImageInOpenshiftRegistry() ? "openshift" : params.IMAGE_NAMESPACE
}

String getDeployImageNameSuffix(){
    return params.IMAGE_NAME_SUFFIX
}

String getDeployImageTag(){
    if (params.IMAGE_TAG != ""){
        return params.IMAGE_TAG
    } else {
        return sh(script: "git rev-parse --short HEAD", returnStdout: true).trim()
    }
}


////////////////////////////////////////////////////////////////////////
// Workspaces
////////////////////////////////////////////////////////////////////////

void initWorkspace(String image){
    sh "mkdir -p ${getWorkspacePath(image)}"
    sh "rsync -av --progress . ${getWorkspacePath(image)} --exclude workspaces"
}

void cleanWorkspaces(){
    sh "rm -rf ${getWorkspacesPath()}"
}

String getWorkspacesPath(){
    return "${WORKSPACE}/workspaces"
}

String getWorkspacePath(String image){
    return "${getWorkspacesPath()}/${image}"
}