Jenkinsfile

#!groovy

pipeline {
    agent {
        node {
            label 'maven'
        }
    }

    parameters{
        string (defaultValue: 'image-registry.openshift-image-registry.svc:5000', name:'IMAGE_REGISTRY', description:'container image registry')
        string (defaultValue: 'rh-dev', name:'IMAGE_NAMESPACE', description:'namespace where image is deployed')
        string (defaultValue: 'rh-dev', name:'DEV_PROJECT', description:'build or development project')
        string (defaultValue: 'rh-test', name:'TEST_PROJECT', description:'Test project')
        string (defaultValue: 'rh-prod', name:'PROD_PROJECT', description:'Production project')
        string (defaultValue: 'https://github.com/jeanNyil/rh-build-quarkus-camel-demos.git', name:'GIT_REPO', description:'Git source')
        string (defaultValue: 'master', name:'GIT_BRANCH', description:'Git branch in the source git')
        booleanParam (defaultValue: false, name:'SELECT_DEPLOY_TO_PROD', description:'Approval to deploy to Production (default: no deployment to production)')
    }

    environment {
        MODULE_NAME = 'camel-quarkus-jsonvalidation-api'
    }

    stages {

        stage ('source') {
            steps {
                git url: params.GIT_REPO, branch: params.GIT_BRANCH
            }
        }

        stage('Build Service') {
            when {
                expression {
                    params.SELECT_DEPLOY_TO_PROD == false
                }
            }
            steps {
                // echo "Building.. ${MODULE_NAME} "
                // build(env.MODULE_NAME)

                echo "Building and deploying ${MODULE_NAME} to ${DEV_PROJECT}"
                deploy(env.MODULE_NAME, params.DEV_PROJECT)
            }
        }

        stage('Dev-Env smoke-test') {
            when {
                expression {
                    params.SELECT_DEPLOY_TO_PROD == false
                }
            }
            steps {
                script {

                    echo "Waiting for deployment to complete prior starting smoke testing"
                    sleep 60
                    retry(5) {
                        serviceName = 'camel-quarkus-jsonvalidation-api'
                        smokeTestUriOperation = '/openapi.json'
                        makeGetRequest("http://${serviceName}.${DEV_PROJECT}.svc:8080${smokeTestUriOperation}")
                    }
                }
            }
        }

        stage('Pushing to Test') {
            when {
                expression {
                    params.SELECT_DEPLOY_TO_PROD == false
                }
            }
            environment {
                srcTag = '1.0.0'
                destTag = '1.0.0-promoteTest'
            }
            steps {
                echo "Deploy ${MODULE_NAME} to ${TEST_PROJECT} "
                promoteServiceSetup(env.MODULE_NAME,params.IMAGE_REGISTRY, params.IMAGE_NAMESPACE, env.destTag, params.TEST_PROJECT)
                promoteService(params.IMAGE_NAMESPACE, params.TEST_PROJECT,env.MODULE_NAME, env.srcTag, env.destTag)
            }
        }

        stage('Test-Env smoke-test') {
            when {
                expression {
                    params.SELECT_DEPLOY_TO_PROD == false
                }
            }
            steps {
                script {
                    retry(5) {
                        serviceName = 'camel-quarkus-jsonvalidation-api'
                        smokeTestUriOperation = '/openapi.json'
                        makeGetRequest("http://${serviceName}.${TEST_PROJECT}.svc:8080${smokeTestUriOperation}")
                    }
                }
            }
        }

        stage('Wait for user to select module to push to production.') {
            when {
                expression {
                    params.SELECT_DEPLOY_TO_PROD == true
                }
            }
            steps {
                script {
                    try {
                        timeout (time:2, unit:'HOURS') {
                            env.userProdApproval = input(id: 'userInput', message: "Do you approve this build to promote to production?")
                            env.userProdApproval = 'Approved'
                        }
                    } catch (exception) {
                        env.userProdApproval='---'
                    }

                    println("User approval to production " + env.userProdApproval);
                }
            }
        }

        stage('Pushing to Prod') {
            environment {
                srcTag = '1.0.0'
                destTag = '1.0.0-promoteProd'
            }
            when {
                expression {
                env.userProdApproval == 'Approved'
                }
            }
            steps {
                echo "Deploy ${MODULE_NAME} to ${PROD_PROJECT} "
                promoteServiceSetup(env.MODULE_NAME,params.IMAGE_REGISTRY, params.IMAGE_NAMESPACE, env.destTag, params.PROD_PROJECT)
                promoteService(params.IMAGE_NAMESPACE, params.PROD_PROJECT, env.MODULE_NAME,  env.srcTag, env.destTag)
            }
        }
        
        stage('Prod-Env smoke-test') {
            when {
                expression {
                    env.userProdApproval == 'Approved'
                }
            }
            steps {
                script {
                    retry(5) {
                        serviceName = 'camel-quarkus-jsonvalidation-api'
                        smokeTestUriOperation = '/openapi.json'
                        makeGetRequest("http://${serviceName}.${PROD_PROJECT}.svc:8080${smokeTestUriOperation}")
                    }
                }
            }
        }
    }
}

def promoteServiceSetup(svcName, registry, imageNameSpace, tagName, projName) {
    try {
        sh """
            oc delete -f ${svcName}/target/kubernetes/openshift.yml -n ${projName} 2> /dev/null
        """
    } catch (Exception e) {
        echo "skip dc/svc/route cleanup related exception, the resources may not exist. " + e.getMessage();
    }

    try {
        echo "Creating the ${svcName} OpenShift resources in ${projName} namespace ..."
        sh """ 
            oc replace --force -f ${svcName}/target/kubernetes/openshift.yml -n ${projName} 2> /dev/null
        """
    } catch (Exception e) {
        echo "skip dc/svc/route creation related exception, the resources may already exist. " + e.getMessage();
    }

    try {
        echo "Delete unnecessary ${svcName} OpenShift resources (bc and is) in ${projName} namespace ..."
        sh """ 
            oc delete bc ${svcName} -n ${projName} 2> /dev/null
            oc delete is ${svcName} -n ${projName} 2> /dev/null
            oc delete is openjdk-11 -n ${projName} 2> /dev/null
        """
    } catch (Exception e) {
        echo "skip unnecessary bc/is cleanup related exception, the resources may not exist. " + e.getMessage();
    }

    echo "Preparing the ${svcName} deploymentConfig resource in ${projName} namespace ..."
    sh """ 
        oc rollout pause dc ${svcName} -n ${projName}  2> /dev/null
        oc patch dc ${svcName} -p '{"spec": {"template": {"spec": {"containers": [{"name": "${svcName}","image": "${registry}/${imageNameSpace}/${svcName}:${tagName}"}]}}}}' -n ${projName} 2> /dev/null
        oc patch dc ${svcName} -p '{"spec": {"template": {"spec": {"containers": [{"name": "${svcName}","imagePullPolicy": "Always"}]}}}}' -n ${projName} 2> /dev/null
        oc set triggers dc ${svcName} --remove-all -n ${projName} 2> /dev/null
        oc set triggers dc ${svcName} --from-config -n ${projName} 2> /dev/null
        oc rollout resume dc ${svcName} -n ${projName}  2> /dev/null
    """
}

def promoteService (imageNamespace, projName, svcName, sourceTag, destinationTag) {
    script {
         openshift.withCluster() {
             openshift.withProject( imageNamespace ) {
                 echo "tagging the build for ${projName} ${sourceTag} to ${destinationTag} in ${imageNamespace} "
                 openshift.tag("${svcName}:${sourceTag}", "${svcName}:${destinationTag}")
             }
         }
         echo "deploying the ${svcName} to ${projName} "
         openshift.withCluster() {
             openshift.withProject( projName) {
                def dply = openshift.selector("dc", svcName)
                echo "waiting for ... "+ dply.rollout().status()
             }
         }
     }//script
}

def build(folderName) {
    sh """
        cd ${folderName}
        ./mvnw package
    """
}

def deploy(folderName, projName) {
    sh """
        cd ${folderName}
        oc project ${projName}
        ./mvnw package -Dquarkus.openshift.deploy=true -Dquarkus.openshift.replicas=1
    """
}

def makeGetRequest(url) {
    sh"""
        set -e -x
        curl -k -f -w "SmokeTest: %{http_code}\n" -o /dev/null -s ${url}
    """
}