milvus/ci/jenkins/Jenkinsfile

#!/usr/bin/env groovy

String cron_timezone = "TZ=Asia/Shanghai"
String cron_string = BRANCH_NAME == "master" ? "H 0 * * * " : ""
cron_string =  BRANCH_NAME == "0.6.0" ? "H 1 * * * " : cron_string

pipeline {
    agent none

    triggers {
        cron """${cron_timezone}
            ${cron_string}"""
    }

    options {
        timestamps()
    }

    parameters{
        choice choices: ['Release', 'Debug'], description: '', name: 'BUILD_TYPE'
        string defaultValue: 'registry.zilliz.com', description: 'DOCKER REGISTRY URL', name: 'DOKCER_REGISTRY_URL', trim: true
        string defaultValue: 'ba070c98-c8cc-4f7c-b657-897715f359fc', description: 'DOCKER CREDENTIALS ID', name: 'DOCKER_CREDENTIALS_ID', trim: true
        string defaultValue: 'http://192.168.1.202/artifactory/milvus', description: 'JFROG ARTFACTORY URL', name: 'JFROG_ARTFACTORY_URL', trim: true
        string defaultValue: '1a527823-d2b7-44fd-834b-9844350baf14', description: 'JFROG CREDENTIALS ID', name: 'JFROG_CREDENTIALS_ID', trim: true
    }

    environment {
        PROJECT_NAME = "milvus"
        LOWER_BUILD_TYPE = params.BUILD_TYPE.toLowerCase()
        SEMVER = "${BRANCH_NAME}"
        JOBNAMES = env.JOB_NAME.split('/')
        PIPELINE_NAME = "${JOBNAMES[0]}"
    }

    stages {
        stage("Ubuntu 18.04 x86_64") {
            environment {
                OS_NAME = "ubuntu18.04"
                CPU_ARCH = "amd64"
            }

            parallel {
                stage ("GPU Version") {
                    environment {
                        BINRARY_VERSION = "gpu"
                        PACKAGE_VERSION = VersionNumber([
                            versionNumberString : '${SEMVER}-gpu-${OS_NAME}-${CPU_ARCH}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}-${BUILDS_TODAY}'
                        ]);
                        DOCKER_VERSION = "${SEMVER}-gpu-${OS_NAME}-${LOWER_BUILD_TYPE}"
                    }

                    stages {
                        stage("Run Build") {
                            agent {
                                kubernetes {
                                    label "${env.BINRARY_VERSION}-build"
                                    defaultContainer 'jnlp'
                                    yamlFile 'ci/jenkins/pod/milvus-gpu-version-build-env-pod.yaml'
                                }
                            }

                            stages {
                                stage('Build') {
                                    steps {
                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/build.groovy"
                                            }
                                        }
                                    }
                                }
                                stage('Code Coverage') {
                                    steps {
                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/coverage.groovy"
                                            }
                                        }
                                    }
                                }
                                stage('Upload Package') {
                                    steps {
                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/package.groovy"
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        stage("Publish docker images") {
                            agent {
                                kubernetes {
                                    label "${env.BINRARY_VERSION}-publish"
                                    defaultContainer 'jnlp'
                                    yamlFile 'ci/jenkins/pod/docker-pod.yaml'
                                }
                            }

                            stages {
                                stage('Publish') {
                                    steps {
                                        container('publish-images'){
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/publishImages.groovy"
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        stage("Deploy to Development") {
                            environment {
                                FROMAT_SEMVER = "${env.SEMVER}".replaceAll("\\.", "-")
                                HELM_RELEASE_NAME = "${env.PIPELINE_NAME}-${env.FROMAT_SEMVER}-${env.BUILD_NUMBER}-single-${env.BINRARY_VERSION}".toLowerCase()
                            }

                            agent {
                                kubernetes {
                                    label "${env.BINRARY_VERSION}-dev-test"
                                    defaultContainer 'jnlp'
                                    yamlFile 'ci/jenkins/pod/testEnvironment.yaml'
                                }
                            }

                            stages {
                                stage("Deploy to Dev") {
                                    steps {
                                        container('milvus-test-env') {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/deploySingle2Dev.groovy"
                                            }
                                        }
                                    }
                                }

                                stage("Dev Test") {
                                    steps {
                                        container('milvus-test-env') {
                                            script {
                                                boolean isNightlyTest = isTimeTriggeredBuild()
                                                if (isNightlyTest) {
                                                    load "${env.WORKSPACE}/ci/jenkins/step/singleDevNightlyTest.groovy"
                                                } else {
                                                    load "${env.WORKSPACE}/ci/jenkins/step/singleDevTest.groovy"
                                                }
                                            }
                                        }
                                    }
                                }

                                stage ("Cleanup Dev") {
                                    steps {
                                        container('milvus-test-env') {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
                                            }
                                        }
                                    }
                                }
                            }
                            post {
                                unsuccessful {
                                    container('milvus-test-env') {
                                        script {
                                            load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                stage ("CPU Version") {
                    environment {
                        BINRARY_VERSION = "cpu"
                        PACKAGE_VERSION = VersionNumber([
                            versionNumberString : '${SEMVER}-cpu-${OS_NAME}-${CPU_ARCH}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}-${BUILDS_TODAY}'
                        ]);
                        DOCKER_VERSION = "${SEMVER}-cpu-${OS_NAME}-${LOWER_BUILD_TYPE}"
                    }

                    stages {
                        stage("Run Build") {
                            agent {
                                kubernetes {
                                    label "${env.BINRARY_VERSION}-build"
                                    defaultContainer 'jnlp'
                                    yamlFile 'ci/jenkins/pod/milvus-cpu-version-build-env-pod.yaml'
                                }
                            }

                            stages {
                                stage('Build') {
                                    steps {
                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/build.groovy"
                                            }
                                        }
                                    }
                                }
                                stage('Code Coverage') {
                                    steps {
                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/coverage.groovy"
                                            }
                                        }
                                    }
                                }
                                stage('Upload Package') {
                                    steps {
                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/package.groovy"
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        stage("Publish docker images") {
                            agent {
                                kubernetes {
                                    label "${env.BINRARY_VERSION}-publish"
                                    defaultContainer 'jnlp'
                                    yamlFile 'ci/jenkins/pod/docker-pod.yaml'
                                }
                            }

                            stages {
                                stage('Publish') {
                                    steps {
                                        container('publish-images'){
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/publishImages.groovy"
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        stage("Deploy to Development") {
                            environment {
                                FROMAT_SEMVER = "${env.SEMVER}".replaceAll("\\.", "-")
                                HELM_RELEASE_NAME = "${env.PIPELINE_NAME}-${env.FROMAT_SEMVER}-${env.BUILD_NUMBER}-single-${env.BINRARY_VERSION}".toLowerCase()
                            }

                            agent {
                                kubernetes {
                                    label "${env.BINRARY_VERSION}-dev-test"
                                    defaultContainer 'jnlp'
                                    yamlFile 'ci/jenkins/pod/testEnvironment.yaml'
                                }
                            }

                            stages {
                                stage("Deploy to Dev") {
                                    steps {
                                        container('milvus-test-env') {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/deploySingle2Dev.groovy"
                                            }
                                        }
                                    }
                                }

                                stage("Dev Test") {
                                    steps {
                                        container('milvus-test-env') {
                                            script {
                                                boolean isNightlyTest = isTimeTriggeredBuild()
                                                if (isNightlyTest) {
                                                    load "${env.WORKSPACE}/ci/jenkins/step/singleDevNightlyTest.groovy"
                                                } else {
                                                    load "${env.WORKSPACE}/ci/jenkins/step/singleDevTest.groovy"
                                                }
                                            }
                                        }
                                    }
                                }

                                stage ("Cleanup Dev") {
                                    steps {
                                        container('milvus-test-env') {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
                                            }
                                        }
                                    }
                                }
                            }
                            post {
                                unsuccessful {
                                    container('milvus-test-env') {
                                        script {
                                            load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

boolean isTimeTriggeredBuild() {
    if (currentBuild.getBuildCauses('hudson.triggers.TimerTrigger$TimerTriggerCause').size() != 0) {
        return true
    }
    return false
}