#!/usr/bin/env groovy

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

pipeline {
    agent none

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

    options {
        timestamps()
    }

    parameters{
        choice choices: ['Release', 'Debug'], description: 'Build Type', 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.201/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"
        MILVUS_ROOT_PATH="/var/lib"
        MILVUS_INSTALL_PREFIX="${env.MILVUS_ROOT_PATH}/${env.PROJECT_NAME}"
        LOWER_BUILD_TYPE = params.BUILD_TYPE.toLowerCase()
        SEMVER = "${BRANCH_NAME.contains('/') ? BRANCH_NAME.substring(BRANCH_NAME.lastIndexOf('/') + 1) : BRANCH_NAME}"
        PIPELINE_NAME = "${env.JOB_NAME.contains('/') ? env.JOB_NAME.getAt(0..(env.JOB_NAME.indexOf('/') - 1)) : env.JOB_NAME}"
    }

    stages {
        stage ('Milvus Build and Test') {
            matrix {
                agent none
                axes {
                    axis {
                        name 'OS_NAME'
                        values 'ubuntu18.04', 'centos7'
                    }

                    axis {
                        name 'CPU_ARCH'
                        values 'amd64'
                    }

                    axis {
                        name 'BINARY_VERSION'
                        values 'gpu', 'cpu'
                    }
                }

                stages {
                    stage("Milvus CI") {
                        environment {
                            PACKAGE_VERSION = VersionNumber([
                                versionNumberString : '${SEMVER}-${BINARY_VERSION}-${OS_NAME}-${CPU_ARCH}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}-${BUILDS_TODAY}'
                            ]);
                            DOCKER_VERSION = "${SEMVER}-${BINARY_VERSION}-${OS_NAME}-${LOWER_BUILD_TYPE}"
                        }

                        stages {
                            stage('Run Build') {
                                when {
                                    allOf {
                                        anyOf {
                                            changeset 'ci/**'
                                            changeset 'core/**'
                                            changeset 'docker/**'
                                            changeset 'test/**'
                                        }
                                        not {
                                            anyOf {
                                                changeset '**/*.md'
                                            }
                                        }
                                    }
                                }
                                agent {
                                    kubernetes {
                                        label "${OS_NAME}-${BINARY_VERSION}-build-${env.PIPELINE_NAME}-${env.BUILD_NUMBER}"
                                        defaultContainer 'jnlp'
                                        yamlFile "ci/jenkins/pod/milvus-${BINARY_VERSION}-version-${OS_NAME}-build-env-pod.yaml"
                                    }
                                }

                                stages {
                                    stage('Build') {
                                        steps {
                                            container("milvus-${BINARY_VERSION}-build-env") {
                                                script {
                                                    load "${env.WORKSPACE}/ci/jenkins/step/build.groovy"
                                                }
                                            }
                                        }
                                    }

                                    stage('Code Coverage') {
                                        steps {
                                            container("milvus-${BINARY_VERSION}-build-env") {
                                                script {
                                                    if ("${BINARY_VERSION}" == "gpu") {
                                                        load "${env.WORKSPACE}/ci/jenkins/step/coverage.groovy"
                                                    } else {
                                                        echo "Skip Code Coverage"
                                                    }
                                                }
                                            }
                                        }
                                    }

                                    stage('Upload Package') {
                                        steps {
                                            container("milvus-${BINARY_VERSION}-build-env") {
                                                script {
                                                    load "${env.WORKSPACE}/ci/jenkins/step/package.groovy"
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            stage('Publish docker images') {
                                when {
                                    allOf {
                                        anyOf {
                                            changeset 'ci/**'
                                            changeset 'core/**'
                                            changeset 'docker/**'
                                            changeset 'test/**'
                                        }
                                        not {
                                            anyOf {
                                                changeset '**/*.md'
                                            }
                                        }
                                    }
                                }
                                agent {
                                    kubernetes {
                                        label "${OS_NAME}-${BINARY_VERSION}-publish-${env.PIPELINE_NAME}-${env.BUILD_NUMBER}"
                                        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') {
                                when {
                                    allOf {
                                        anyOf {
                                            changeset 'ci/**'
                                            changeset 'core/**'
                                            changeset 'docker/**'
                                            changeset 'test/**'
                                        }
                                        not {
                                            anyOf {
                                                changeset '**/*.md'
                                            }
                                        }
                                    }
                                }
                                environment {
                                    FROMAT_SEMVER = "${env.SEMVER}".replaceAll("\\.", "-").replaceAll("_", "-")
                                    FORMAT_OS_NAME = "${OS_NAME}".replaceAll("\\.", "-").replaceAll("_", "-")
                                    HELM_RELEASE_NAME = "${env.PIPELINE_NAME}-${env.FROMAT_SEMVER}-${env.BUILD_NUMBER}-single-${FORMAT_OS_NAME}-${BINARY_VERSION}".toLowerCase()
                                }

                                agent {
                                    kubernetes {
                                        label "${OS_NAME}-${BINARY_VERSION}-dev-test-${env.PIPELINE_NAME}-${env.BUILD_NUMBER}"
                                        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"
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }

                                post {
                                    cleanup {
                                        container('milvus-test-env') {
                                            script {
                                                load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    post {
        unsuccessful {
            script {
                boolean isNightlyTest = isTimeTriggeredBuild()
                if (isNightlyTest) {
                    // Send an email only if the build status has changed from green/unstable to red
                    emailext subject: '$DEFAULT_SUBJECT',
                    body: '$DEFAULT_CONTENT',
                    recipientProviders: [
                        [$class: 'DevelopersRecipientProvider'],
                        [$class: 'RequesterRecipientProvider']
                    ],
                    replyTo: '$DEFAULT_REPLYTO',
                    to: '$DEFAULT_RECIPIENTS'
                }
            }
        }
    }
}

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