Merge branch 'master-main'

Former-commit-id: bee6c5bf8ea694a56a15d8faee82a116c8ded96e

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributing to Milvus
 
-First of all, thanks for taking the time to contribute to Milvus! It's people like you that help Milvus come to fruition.
+First of all, thanks for taking the time to contribute to Milvus! It's people like you that help Milvus come to fruition. :tada:
 
 The following are a set of guidelines for contributing to Milvus. Following these guidelines helps contributing to this project easy and transparent. These are mostly guideline, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request.
 
@@ -11,8 +11,8 @@ As for everything else in the project, the contributions to Milvus are governed
 Before you make any contributions, make sure you follow this list.
 
 - Read [Contributing to Milvus](CONTRIBUTING.md).
-- Check if the changes are consistent with the [coding style](CONTRIBUTING.md#coding-style).
-- Run [unit tests](CONTRIBUTING.md#run-unit-test).
+- Check if the changes are consistent with the [coding style](CONTRIBUTING.md#coding-style), and format your code accordingly.
+- Run [unit tests](CONTRIBUTING.md#run-unit-test-with-code-coverage) and check your code coverage rate.
 
 ## What contributions can I make?
 
@@ -68,15 +68,51 @@ And we made the following changes based on the guide:
 - 120-character line length
 - Camel-Cased file names
 
+### Format code
 
-## Run unit test
-
-We use Google Test framework for test running.
-To run unit test for Milvus under C++, please use the following command:
-
+Install clang-format
 ```shell
-# Run unit test for Milvus
-$ ./build.sh -u
+$ sudo apt-get install clang-format
+$ rm cmake_build/CMakeCache.txt
+```
+Check code style
+```shell
+$ ./build.sh -l
+```
+To format the code
+```shell
+$ cd cmake_build
+$ make clang-format
 ```
 
+## Run unit test with code coverage
+
+Before submitting your PR, make sure you have run unit test, and your code coverage rate is >= 90%.
+
+Install lcov
+```shell
+$ sudo apt-get install lcov
+```
+Run unit test and generate code for code coverage check
+```shell 
+$ ./build.sh -u -c
+```
+
+Run MySQL docker
+```shell 
+docker pull mysql:latest
+docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:latest
+```
+
+Run code coverage
+
+```shell  
+$ ./coverage.sh -u root -p 123456 -t 127.0.0.1
+```
+
+Or start your own MySQL server, and then run code coverage
+
+```shell
+$ ./coverage.sh -u ${MYSQL_USERNAME} -p ${MYSQL_PASSWORD} -t ${MYSQL_SERVER_IP}
+```
 

README.md

@@ -1,11 +1,11 @@
-![Milvuslogo](https://milvus.io/docs/assets/milvus_logo.png)
+![Milvuslogo](https://github.com/milvus-io/docs/blob/branch-0.5.0/assets/milvus_logo.png)
 
 ![LICENSE](https://img.shields.io/badge/license-Apache--2.0-brightgreen)
 ![Language](https://img.shields.io/badge/language-C%2B%2B-blue)
 [![@milvusio](https://img.shields.io/twitter/follow/milvusio.svg?style=social&label=Follow)](https://twitter.com/milvusio)
 
 - [Slack Community](https://join.slack.com/t/milvusio/shared_invite/enQtNzY1OTQ0NDI3NjMzLWNmYmM1NmNjOTQ5MGI5NDhhYmRhMGU5M2NhNzhhMDMzY2MzNDdlYjM5ODQ5MmE3ODFlYzU3YjJkNmVlNDQ2ZTk)
-- [Twitter](https://twitter.com/milvus_io)
+- [Twitter](https://twitter.com/milvusio)
 - [Blog](https://www.milvus.io/blog/)
 - [CSDN](https://zilliz.blog.csdn.net/)
 - [中文官网](https://www.milvus.io/zh-CN/)
@@ -13,14 +13,12 @@
 
 # Welcome to Milvus
 
-Firstly, welcome, and thanks for your interest in [Milvus](https://milvus.io)! No matter who you are, what you do, we greatly appreciate your contribution to help us reinvent data science with Milvus.
+Firstly, welcome, and thanks for your interest in [Milvus](https://milvus.io)! ​​No matter who you are, what you do, we greatly appreciate your contribution to help us reinvent data science with Milvus.
 
 ## What is Milvus
 
 Milvus is an open source vector search engine that supports similarity search of large-scale vectors. Built on optimized indexing algorithm, it is compatible with major AI/ML models.
 
-Milvus was developed by ZILLIZ, a tech startup that intends to reinvent data science, with the purpose of providing enterprises with efficient and scalable similarity search and analysis of feature vectors and unstructured data. 
-
 Milvus provides stable Python, C++ and Java APIs.
 
 Keep up-to-date with newest releases and latest updates by reading Milvus [release notes](https://milvus.io/docs/en/Releases/v0.4.0/).
@@ -31,14 +29,14 @@ Keep up-to-date with newest releases and latest updates by reading Milvus [relea
 
 - Intelligent index
 
-  With a “Decide Your Own Algorithm” approach, you can embed machine learning and advanced algorithms into Milvus without the headache of complex data engineering or migrating data between disparate systems. Milvus is built on optimized indexing algorithm based on quantization indexing, tree-based and graph indexing methods.
+  With a "Decide Your Own Algorithm" approach, you can embed machine learning and advanced algorithms into Milvus without the headache of complex data engineering or migrating data between disparate systems. Milvus is built on optimized indexing algorithm based on quantization indexing, tree-based and graph indexing methods.
 
 - Strong scalability
 
   The data is stored and computed on a distributed architecture. This lets you scale data sizes up and down without redesigning the system.
 
 ## Architecture
-![Milvus_arch](https://milvus.io/docs/assets/milvus_arch.png)
+![Milvus_arch](https://github.com/milvus-io/docs/blob/branch-0.5.0/assets/milvus_arch.jpg)
 
 ## Get started
 
@@ -75,55 +73,6 @@ $ ./build.sh -t Release
 
 When the build is completed, all the stuff that you need in order to run Milvus will be installed under `[Milvus root path]/core/milvus`.
 
-#### Code format and linting
-
-Install clang-format
-```shell
-$ sudo apt-get install clang-format
-$ rm cmake_build/CMakeCache.txt
-```
-Check code style
-```shell
-$ ./build.sh -l
-```
-To format the code
-```shell
-$ cd cmake_build
-$ make clang-format
-```
-
-#### Run unit test
-
-```shell
-$ ./build.sh -u
-```
-
-#### Run code coverage
-
-Install lcov
-```shell
-$ sudo apt-get install lcov
-```
-```shell  
-$ ./build.sh -u -c
-```
-Run MySQL docker
-```shell 
-docker pull mysql:latest
-docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:latest
-```
-Run code coverage
-
-```shell  
-$ ./coverage.sh -u root -p 123456 -t 127.0.0.1
-```
-
-Or start your own MySQL server, and then run code coverage
-
-```shell
-$ ./coverage.sh -u ${MYSQL_USERNAME} -p ${MYSQL_PASSWORD} -t ${MYSQL_SERVER_IP}
-```
-
 #### Launch Milvus server
 
 ```shell

ci/function/file_transfer.groovy

@@ -0,0 +1,10 @@
+def FileTransfer (sourceFiles, remoteDirectory, remoteIP, protocol = "ftp", makeEmptyDirs = true) {
+    if (protocol == "ftp") {
+        ftpPublisher masterNodeName: '', paramPublish: [parameterName: ''], alwaysPublishFromMaster: false, continueOnError: false, failOnError: true, publishers: [
+            [configName: "${remoteIP}", transfers: [
+                [asciiMode: false, cleanRemote: false, excludes: '', flatten: false, makeEmptyDirs: "${makeEmptyDirs}", noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: "${remoteDirectory}", remoteDirectorySDF: false, removePrefix: '', sourceFiles: "${sourceFiles}"]], usePromotionTimestamp: true, useWorkspaceInPromotion: false, verbose: true
+                ]
+            ]
+    }
+}
+return this

ci/jenkinsfile/cleanup_dev.groovy

@@ -0,0 +1,13 @@
+try {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+} catch (exc) {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+    throw exc
+}
+

ci/jenkinsfile/cleanup_staging.groovy

@@ -0,0 +1,13 @@
+try {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+} catch (exc) {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+    throw exc
+}
+

ci/jenkinsfile/cluster_cleanup_dev.groovy

@@ -0,0 +1,13 @@
+try {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster"
+    }
+} catch (exc) {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster"
+    }
+    throw exc
+}
+

ci/jenkinsfile/cluster_deploy2dev.groovy

@@ -0,0 +1,24 @@
+try {
+    sh 'helm init --client-only --skip-refresh --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'
+    sh 'helm repo add milvus https://registry.zilliz.com/chartrepo/milvus'
+    sh 'helm repo update'
+    dir ("milvus-helm") {
+        checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+        dir ("milvus/milvus-cluster") {
+            sh "helm install --wait --timeout 300 --set roServers.image.tag=${DOCKER_VERSION} --set woServers.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP -f ci/values.yaml --name ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster --namespace milvus-cluster --version 0.5.0 . "
+        }
+    }
+    /*
+    timeout(time: 2, unit: 'MINUTES') {
+        waitUntil {
+            def result = sh script: "nc -z -w 3 ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster-milvus-cluster-proxy.milvus-cluster.svc.cluster.local 19530", returnStatus: true
+            return !result
+        }
+    }
+    */
+} catch (exc) {
+    echo 'Helm running failed!'
+    sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster"
+    throw exc
+}
+

ci/jenkinsfile/cluster_dev_test.groovy

@@ -0,0 +1,12 @@
+timeout(time: 25, unit: 'MINUTES') {
+    try {
+        dir ("${PROJECT_NAME}_test") {
+            checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            sh 'python3 -m pip install -r requirements_cluster.txt'
+            sh "pytest . --alluredir=cluster_test_out --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster-milvus-cluster-proxy.milvus-cluster.svc.cluster.local"
+        }
+    } catch (exc) {
+        echo 'Milvus Cluster Test Failed !'
+        throw exc
+    }
+}

ci/jenkinsfile/deploy2dev.groovy

@@ -0,0 +1,16 @@
+try {
+    sh 'helm init --client-only --skip-refresh --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'
+    sh 'helm repo add milvus https://registry.zilliz.com/chartrepo/milvus'
+    sh 'helm repo update'
+    dir ("milvus-helm") {
+        checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+        dir ("milvus/milvus-gpu") {
+            sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/values.yaml --namespace milvus-1 --version 0.5.0 ."
+        }
+    }
+} catch (exc) {
+    echo 'Helm running failed!'
+    sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    throw exc
+}
+

ci/jenkinsfile/deploy2staging.groovy

@@ -0,0 +1,16 @@
+try {
+    sh 'helm init --client-only --skip-refresh --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'
+    sh 'helm repo add milvus https://registry.zilliz.com/chartrepo/milvus'
+    sh 'helm repo update'
+    dir ("milvus-helm") {
+        checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+        dir ("milvus/milvus-gpu") {
+            sh "helm install --wait --timeout 300 --set engine.image.repository=\"zilliz.azurecr.cn/milvus/engine\" --set engine.image.tag=${DOCKER_VERSION} --set expose.type=loadBalancer --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/values.yaml --namespace milvus-1 --version 0.5.0 ."
+        }
+    }
+} catch (exc) {
+    echo 'Helm running failed!'
+    sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    throw exc
+}
+

ci/jenkinsfile/dev_test.groovy

@@ -0,0 +1,28 @@
+timeout(time: 30, unit: 'MINUTES') {
+    try {
+        dir ("${PROJECT_NAME}_test") {
+            checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            sh 'python3 -m pip install -r requirements.txt -i http://pypi.douban.com/simple --trusted-host pypi.douban.com'
+            sh "pytest . --alluredir=\"test_out/dev/single/sqlite\" --level=1 --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-1.svc.cluster.local"
+        }
+        // mysql database backend test
+        load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+
+        if (!fileExists('milvus-helm')) {
+            dir ("milvus-helm") {
+                checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            }
+        }
+        dir ("milvus-helm") {
+            dir ("milvus/milvus-gpu") {
+                sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/db_backend/mysql_values.yaml --namespace milvus-2 --version 0.5.0 ."
+            }
+        }
+        dir ("${PROJECT_NAME}_test") {
+            sh "pytest . --alluredir=\"test_out/dev/single/mysql\" --level=1 --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-2.svc.cluster.local"
+        }
+    } catch (exc) {
+        echo 'Milvus Test Failed !'
+        throw exc
+    }
+}

ci/jenkinsfile/dev_test_all.groovy

@@ -0,0 +1,29 @@
+timeout(time: 60, unit: 'MINUTES') {
+    try {
+        dir ("${PROJECT_NAME}_test") {
+            checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            sh 'python3 -m pip install -r requirements.txt -i http://pypi.douban.com/simple --trusted-host pypi.douban.com'
+            sh "pytest . --alluredir=\"test_out/dev/single/sqlite\" --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-1.svc.cluster.local"
+        }
+
+        // mysql database backend test
+        load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+
+        if (!fileExists('milvus-helm')) {
+            dir ("milvus-helm") {
+                checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            }
+        }
+        dir ("milvus-helm") {
+            dir ("milvus/milvus-gpu") {
+                sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/db_backend/mysql_values.yaml --namespace milvus-2 --version 0.4.0 ."
+            }
+        }
+        dir ("${PROJECT_NAME}_test") {
+            sh "pytest . --alluredir=\"test_out/dev/single/mysql\" --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-2.svc.cluster.local"
+        }
+    } catch (exc) {
+        echo 'Milvus Test Failed !'
+        throw exc
+    }
+}

ci/jenkinsfile/milvus_build.groovy

@@ -0,0 +1,30 @@
+container('milvus-build-env') {
+    timeout(time: 120, unit: 'MINUTES') {
+        gitlabCommitStatus(name: 'Build Engine') {
+            dir ("milvus_engine") {
+                try {
+                    checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'SubmoduleOption',disableSubmodules: false,parentCredentials: true,recursiveSubmodules: true,reference: '',trackingSubmodules: false]], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+
+                    dir ("core") {
+                        sh "git config --global user.email \"test@zilliz.com\""
+                        sh "git config --global user.name \"test\""
+                        withCredentials([usernamePassword(credentialsId: "${params.JFROG_USER}", usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
+                            sh "./build.sh -l"
+                            sh "rm -rf cmake_build"
+                            sh "export JFROG_ARTFACTORY_URL='${params.JFROG_ARTFACTORY_URL}' \
+                            && export JFROG_USER_NAME='${USERNAME}' \
+                            && export JFROG_PASSWORD='${PASSWORD}' \
+                            && export FAISS_URL='http://192.168.1.105:6060/jinhai/faiss/-/archive/branch-0.2.1/faiss-branch-0.2.1.tar.gz' \
+                            && ./build.sh -t ${params.BUILD_TYPE} -d /opt/milvus -j -u -c"
+
+                            sh "./coverage.sh -u root -p 123456 -t 192.168.1.194"
+                        }
+                    }
+                } catch (exc) {
+                    updateGitlabCommitStatus name: 'Build Engine', state: 'failed'
+                    throw exc
+                }
+            }
+        }
+    }
+}

ci/jenkinsfile/milvus_build_no_ut.groovy

@@ -0,0 +1,28 @@
+container('milvus-build-env') {
+    timeout(time: 120, unit: 'MINUTES') {
+        gitlabCommitStatus(name: 'Build Engine') {
+            dir ("milvus_engine") {
+                try {
+                    checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'SubmoduleOption',disableSubmodules: false,parentCredentials: true,recursiveSubmodules: true,reference: '',trackingSubmodules: false]], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+
+                    dir ("core") {
+                        sh "git config --global user.email \"test@zilliz.com\""
+                        sh "git config --global user.name \"test\""
+                        withCredentials([usernamePassword(credentialsId: "${params.JFROG_USER}", usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
+                            sh "./build.sh -l"
+                            sh "rm -rf cmake_build"
+                            sh "export JFROG_ARTFACTORY_URL='${params.JFROG_ARTFACTORY_URL}' \
+                            && export JFROG_USER_NAME='${USERNAME}' \
+                            && export JFROG_PASSWORD='${PASSWORD}' \
+                            && export FAISS_URL='http://192.168.1.105:6060/jinhai/faiss/-/archive/branch-0.2.1/faiss-branch-0.2.1.tar.gz' \
+                            && ./build.sh -t ${params.BUILD_TYPE} -j -d /opt/milvus"
+                        }
+                    }
+                } catch (exc) {
+                    updateGitlabCommitStatus name: 'Build Engine', state: 'failed'
+                    throw exc
+                }
+            }
+        }
+    }
+}

ci/jenkinsfile/nightly_publish_docker.groovy

@@ -0,0 +1,38 @@
+container('publish-docker') {
+    timeout(time: 15, unit: 'MINUTES') {
+        gitlabCommitStatus(name: 'Publish Engine Docker') {
+            try {
+                dir ("${PROJECT_NAME}_build") {
+                    checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:build/milvus_build.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+                    dir ("docker/deploy/ubuntu16.04/free_version") {
+                        sh "curl -O -u anonymous: ftp://192.168.1.126/data/${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}/${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz"
+                        sh "tar zxvf ${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz"
+                        try {
+                            def customImage = docker.build("${PROJECT_NAME}/engine:${DOCKER_VERSION}")
+                            docker.withRegistry('https://registry.zilliz.com', "${params.DOCKER_PUBLISH_USER}") {
+                                customImage.push()
+                            }
+                            docker.withRegistry('https://zilliz.azurecr.cn', "${params.AZURE_DOCKER_PUBLISH_USER}") {
+                                customImage.push()
+                            }
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'success'
+                                echo "Docker Pull Command: docker pull registry.zilliz.com/${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'canceled'
+                            throw exc
+                        } finally {
+                            sh "docker rmi ${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+                        }
+                    }
+                }
+            } catch (exc) {
+                updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'failed'
+                echo 'Publish docker failed!'
+                throw exc
+            }
+        }
+    }
+}
+

ci/jenkinsfile/notify.groovy

@@ -0,0 +1,15 @@
+def notify() {
+    if (!currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+        // 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'
+    }
+}
+return this
+

ci/jenkinsfile/packaged_milvus.groovy

@@ -0,0 +1,44 @@
+container('milvus-build-env') {
+    timeout(time: 5, unit: 'MINUTES') {
+        dir ("milvus_engine") {
+            dir ("core") {
+                gitlabCommitStatus(name: 'Packaged Engine') {
+                    if (fileExists('milvus')) {
+                        try {
+                            sh "tar -zcvf ./${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz ./milvus"
+                            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+                            fileTransfer.FileTransfer("${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz", "${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                echo "Download Milvus Engine Binary Viewer \"http://192.168.1.126:8080/${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}/${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz\""
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Packaged Engine', state: 'failed'
+                            throw exc
+                        }
+                    } else {
+                        updateGitlabCommitStatus name: 'Packaged Engine', state: 'failed'
+                        error("Milvus binary directory don't exists!")
+                    }
+                }
+
+                gitlabCommitStatus(name: 'Packaged Engine lcov') {
+                    if (fileExists('lcov_out')) {
+                        try {
+                            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+                            fileTransfer.FileTransfer("lcov_out/", "${PROJECT_NAME}/lcov/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                echo "Milvus lcov out Viewer \"http://192.168.1.126:8080/${PROJECT_NAME}/lcov/${JOB_NAME}-${BUILD_ID}/lcov_out/\""
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Packaged Engine lcov', state: 'failed'
+                            throw exc
+                        }
+                    } else {
+                        updateGitlabCommitStatus name: 'Packaged Engine lcov', state: 'failed'
+                        error("Milvus lcov out directory don't exists!")
+                    }
+                }
+            }
+        }
+    }
+}

ci/jenkinsfile/packaged_milvus_no_ut.groovy

@@ -0,0 +1,26 @@
+container('milvus-build-env') {
+    timeout(time: 5, unit: 'MINUTES') {
+        dir ("milvus_engine") {
+            dir ("core") {
+                gitlabCommitStatus(name: 'Packaged Engine') {
+                    if (fileExists('milvus')) {
+                        try {
+                            sh "tar -zcvf ./${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz ./milvus"
+                            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+                            fileTransfer.FileTransfer("${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz", "${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                echo "Download Milvus Engine Binary Viewer \"http://192.168.1.126:8080/${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}/${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz\""
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Packaged Engine', state: 'failed'
+                            throw exc
+                        }
+                    } else {
+                        updateGitlabCommitStatus name: 'Packaged Engine', state: 'failed'
+                        error("Milvus binary directory don't exists!")
+                    }
+                }
+            }
+        }
+    }
+}

ci/jenkinsfile/publish_docker.groovy

@@ -0,0 +1,35 @@
+container('publish-docker') {
+    timeout(time: 15, unit: 'MINUTES') {
+        gitlabCommitStatus(name: 'Publish Engine Docker') {
+            try {
+                dir ("${PROJECT_NAME}_build") {
+                    checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:build/milvus_build.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+                    dir ("docker/deploy/ubuntu16.04/free_version") {
+                        sh "curl -O -u anonymous: ftp://192.168.1.126/data/${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}/${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz"
+                        sh "tar zxvf ${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz"
+                        try {
+                            def customImage = docker.build("${PROJECT_NAME}/engine:${DOCKER_VERSION}")
+                            docker.withRegistry('https://registry.zilliz.com', "${params.DOCKER_PUBLISH_USER}") {
+                                customImage.push()
+                            }
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'success'
+                                echo "Docker Pull Command: docker pull registry.zilliz.com/${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'canceled'
+                            throw exc
+                        } finally {
+                            sh "docker rmi ${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+                        }
+                    }
+                }
+            } catch (exc) {
+                updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'failed'
+                echo 'Publish docker failed!'
+                throw exc
+            }
+        }
+    }
+}
+

ci/jenkinsfile/staging_test.groovy

@@ -0,0 +1,31 @@
+timeout(time: 40, unit: 'MINUTES') {
+    try {
+        dir ("${PROJECT_NAME}_test") {
+            checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            sh 'python3 -m pip install -r requirements.txt'
+            def service_ip = sh (script: "kubectl get svc --namespace milvus-1 ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine --template \"{{range .status.loadBalancer.ingress}}{{.ip}}{{end}}\"",returnStdout: true).trim()
+            sh "pytest . --alluredir=\"test_out/staging/single/sqlite\" --ip ${service_ip}"
+        }
+
+        // mysql database backend test
+        load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_staging.groovy"
+
+        if (!fileExists('milvus-helm')) {
+            dir ("milvus-helm") {
+                checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            }
+        }
+        dir ("milvus-helm") {
+            dir ("milvus/milvus-gpu") {
+                sh "helm install --wait --timeout 300 --set engine.image.repository=\"zilliz.azurecr.cn/milvus/engine\" --set engine.image.tag=${DOCKER_VERSION} --set expose.type=loadBalancer --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/db_backend/mysql_values.yaml --namespace milvus-2 --version 0.5.0 ."
+            }
+        }
+        dir ("${PROJECT_NAME}_test") {
+            def service_ip = sh (script: "kubectl get svc --namespace milvus-2 ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine --template \"{{range .status.loadBalancer.ingress}}{{.ip}}{{end}}\"",returnStdout: true).trim()
+            sh "pytest . --alluredir=\"test_out/staging/single/mysql\" --ip ${service_ip}"
+        }
+    } catch (exc) {
+        echo 'Milvus Test Failed !'
+        throw exc
+    }
+}

ci/jenkinsfile/upload_dev_cluster_test_out.groovy

@@ -0,0 +1,14 @@
+timeout(time: 5, unit: 'MINUTES') {
+    dir ("${PROJECT_NAME}_test") {
+        if (fileExists('cluster_test_out')) {
+            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+            fileTransfer.FileTransfer("cluster_test_out/", "${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                echo "Milvus Dev Test Out Viewer \"ftp://192.168.1.126/data/${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}\""
+            }
+        } else {
+            error("Milvus Dev Test Out directory don't exists!")
+        }
+    }
+}
+

ci/jenkinsfile/upload_dev_test_out.groovy

@@ -0,0 +1,13 @@
+timeout(time: 5, unit: 'MINUTES') {
+    dir ("${PROJECT_NAME}_test") {
+        if (fileExists('test_out/dev')) {
+            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+            fileTransfer.FileTransfer("test_out/dev/", "${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                echo "Milvus Dev Test Out Viewer \"ftp://192.168.1.126/data/${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}\""
+            }
+        } else {
+            error("Milvus Dev Test Out directory don't exists!")
+        }
+    }
+}

ci/jenkinsfile/upload_staging_test_out.groovy

@@ -0,0 +1,13 @@
+timeout(time: 5, unit: 'MINUTES') {
+    dir ("${PROJECT_NAME}_test") {
+        if (fileExists('test_out/staging')) {
+            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+            fileTransfer.FileTransfer("test_out/staging/", "${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                echo "Milvus Dev Test Out Viewer \"ftp://192.168.1.126/data/${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}\""
+            }
+        } else {
+            error("Milvus Dev Test Out directory don't exists!")
+        }
+    }
+}

ci/main_jenkinsfile

@@ -0,0 +1,383 @@
+pipeline {
+    agent none
+
+    options {
+        timestamps()
+    }
+
+    environment {
+        PROJECT_NAME = "milvus"
+        LOWER_BUILD_TYPE = BUILD_TYPE.toLowerCase()
+        SEMVER = "${env.gitlabSourceBranch == null ? params.ENGINE_BRANCH.substring(params.ENGINE_BRANCH.lastIndexOf('/') + 1) : env.gitlabSourceBranch}"
+        GITLAB_AFTER_COMMIT = "${env.gitlabAfter == null ? null : env.gitlabAfter}"
+        SUFFIX_VERSION_NAME = "${env.gitlabAfter == null ? null : env.gitlabAfter.substring(0, 6)}"
+        DOCKER_VERSION_STR = "${env.gitlabAfter == null ? "${SEMVER}-${LOWER_BUILD_TYPE}" : "${SEMVER}-${LOWER_BUILD_TYPE}-${SUFFIX_VERSION_NAME}"}"
+    }
+
+    stages {
+        stage("Ubuntu 16.04") {
+            environment {
+                PACKAGE_VERSION = VersionNumber([
+                    versionNumberString : '${SEMVER}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}'
+                ]);
+
+                DOCKER_VERSION = VersionNumber([
+                    versionNumberString : '${DOCKER_VERSION_STR}'
+                ]);
+            }
+
+            stages {
+                stage("Run Build") {
+                    agent {
+                        kubernetes {
+                            cloud 'build-kubernetes'
+                            label 'build'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  name: milvus-build-env
+  labels:
+    app: milvus
+    componet: build-env
+spec:
+  containers:
+  - name: milvus-build-env
+    image: registry.zilliz.com/milvus/milvus-build-env:v0.13
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "28Gi"
+        cpu: "10.0"
+        nvidia.com/gpu: 1
+      requests:
+        memory: "14Gi"
+        cpu: "5.0"
+"""
+                        }
+                    }
+                    stages {
+                        stage('Build') {
+                            steps {
+                                gitlabCommitStatus(name: 'Build') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/milvus_build.groovy"
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/packaged_milvus.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'canceled'
+                                echo "Milvus Build aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'failed'
+                                echo "Milvus Build failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Publish docker and helm") {
+                    agent {
+                        kubernetes {
+                            label 'publish'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-docker
+    image: registry.zilliz.com/library/zilliz_docker:v1.0.0
+    securityContext:
+      privileged: true
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: docker-sock
+      mountPath: /var/run/docker.sock
+  volumes:
+  - name: docker-sock
+    hostPath:
+      path: /var/run/docker.sock
+"""
+                        }
+                    }
+                    stages {
+                        stage('Publish Docker') {
+                            steps {
+                                gitlabCommitStatus(name: 'Publish Docker') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/publish_docker.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'canceled'
+                                echo "Milvus Publish Docker aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'failed'
+                                echo "Milvus Publish Docker failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Deploy to Development") {
+                    parallel {
+                        stage("Single Node") {
+                            agent {
+                                kubernetes {
+                                    label 'dev-test'
+                                    defaultContainer 'jnlp'
+                                    yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.2
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: test-cluster-config
+"""
+                                }
+                            }
+
+                            stages {
+                                stage("Deploy to Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy to Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/deploy2dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage("Dev Test") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy Test') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/dev_test.groovy"
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_test_out.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage ("Cleanup Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Cleanup Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            post {
+                                always {
+                                    container('milvus-testframework') {
+                                        script {
+                                            load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                        }
+                                    }
+                                }
+                                success {
+                                    script {
+                                        echo "Milvus Single Node CI/CD success !"
+                                    }
+                                }
+                                aborted {
+                                    script {
+                                        echo "Milvus Single Node CI/CD aborted !"
+                                    }
+                                }
+                                failure {
+                                    script {
+                                        echo "Milvus Single Node CI/CD failure !"
+                                    }
+                                }
+                            }
+                        }
+
+//                         stage("Cluster") {
+//                             agent {
+//                                 kubernetes {
+//                                     label 'dev-test'
+//                                     defaultContainer 'jnlp'
+//                                     yaml """
+// apiVersion: v1
+// kind: Pod
+// metadata:
+//   labels:
+//     app: milvus
+//     componet: test
+// spec:
+//   containers:
+//   - name: milvus-testframework
+//     image: registry.zilliz.com/milvus/milvus-test:v0.2
+//     command:
+//     - cat
+//     tty: true
+//     volumeMounts:
+//     - name: kubeconf
+//       mountPath: /root/.kube/
+//       readOnly: true
+//   volumes:
+//   - name: kubeconf
+//     secret:
+//       secretName: test-cluster-config
+// """
+//                                 }
+//                             }
+//                             stages {
+//                                 stage("Deploy to Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy to Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_deploy2dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage("Dev Test") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy Test') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_dev_test.groovy"
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_cluster_test_out.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage ("Cleanup Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Cleanup Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                             }
+//                             post {
+//                                 always {
+//                                     container('milvus-testframework') {
+//                                         script {
+//                                             load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                         }
+//                                     }
+//                                 }
+//                                 success {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD success !"
+//                                     }
+//                                 }
+//                                 aborted {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD aborted !"
+//                                     }
+//                                 }
+//                                 failure {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD failure !"
+//                                     }
+//                                 }
+//                             }
+//                        }
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            script {
+                if (env.gitlabAfter != null) {
+                    if (!currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                        // 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'
+                    }
+                }
+            }
+        }
+
+        success {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'success'
+                echo "Milvus CI/CD success !"
+            }
+        }
+
+        aborted {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'canceled'
+                echo "Milvus CI/CD aborted !"
+            }
+        }
+
+        failure {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'failed'
+                echo "Milvus CI/CD failure !"
+            }
+        }
+    }
+}
+

ci/main_jenkinsfile_no_ut

@@ -0,0 +1,383 @@
+pipeline {
+    agent none
+
+    options {
+        timestamps()
+    }
+
+    environment {
+        PROJECT_NAME = "milvus"
+        LOWER_BUILD_TYPE = BUILD_TYPE.toLowerCase()
+        SEMVER = "${env.gitlabSourceBranch == null ? params.ENGINE_BRANCH.substring(params.ENGINE_BRANCH.lastIndexOf('/') + 1) : env.gitlabSourceBranch}"
+        GITLAB_AFTER_COMMIT = "${env.gitlabAfter == null ? null : env.gitlabAfter}"
+        SUFFIX_VERSION_NAME = "${env.gitlabAfter == null ? null : env.gitlabAfter.substring(0, 6)}"
+        DOCKER_VERSION_STR = "${env.gitlabAfter == null ? "${SEMVER}-${LOWER_BUILD_TYPE}" : "${SEMVER}-${LOWER_BUILD_TYPE}-${SUFFIX_VERSION_NAME}"}"
+    }
+
+    stages {
+        stage("Ubuntu 16.04") {
+            environment {
+                PACKAGE_VERSION = VersionNumber([
+                    versionNumberString : '${SEMVER}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}'
+                ]);
+
+                DOCKER_VERSION = VersionNumber([
+                    versionNumberString : '${DOCKER_VERSION_STR}'
+                ]);
+            }
+
+            stages {
+                stage("Run Build") {
+                    agent {
+                        kubernetes {
+                            cloud 'build-kubernetes'
+                            label 'build'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  name: milvus-build-env
+  labels:
+    app: milvus
+    componet: build-env
+spec:
+  containers:
+  - name: milvus-build-env
+    image: registry.zilliz.com/milvus/milvus-build-env:v0.13
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "28Gi"
+        cpu: "10.0"
+        nvidia.com/gpu: 1
+      requests:
+        memory: "14Gi"
+        cpu: "5.0"
+"""
+                        }
+                    }
+                    stages {
+                        stage('Build') {
+                            steps {
+                                gitlabCommitStatus(name: 'Build') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/milvus_build_no_ut.groovy"
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/packaged_milvus_no_ut.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'canceled'
+                                echo "Milvus Build aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'failed'
+                                echo "Milvus Build failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Publish docker and helm") {
+                    agent {
+                        kubernetes {
+                            label 'publish'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-docker
+    image: registry.zilliz.com/library/zilliz_docker:v1.0.0
+    securityContext:
+      privileged: true
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: docker-sock
+      mountPath: /var/run/docker.sock
+  volumes:
+  - name: docker-sock
+    hostPath:
+      path: /var/run/docker.sock
+"""
+                        }
+                    }
+                    stages {
+                        stage('Publish Docker') {
+                            steps {
+                                gitlabCommitStatus(name: 'Publish Docker') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/publish_docker.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'canceled'
+                                echo "Milvus Publish Docker aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'failed'
+                                echo "Milvus Publish Docker failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Deploy to Development") {
+                    parallel {
+                        stage("Single Node") {
+                            agent {
+                                kubernetes {
+                                    label 'dev-test'
+                                    defaultContainer 'jnlp'
+                                    yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.2
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: test-cluster-config
+"""
+                                }
+                            }
+
+                            stages {
+                                stage("Deploy to Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy to Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/deploy2dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage("Dev Test") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy Test') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/dev_test.groovy"
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_test_out.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage ("Cleanup Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Cleanup Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            post {
+                                always {
+                                    container('milvus-testframework') {
+                                        script {
+                                            load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                        }
+                                    }
+                                }
+                                success {
+                                    script {
+                                        echo "Milvus Single Node CI/CD success !"
+                                    }
+                                }
+                                aborted {
+                                    script {
+                                        echo "Milvus Single Node CI/CD aborted !"
+                                    }
+                                }
+                                failure {
+                                    script {
+                                        echo "Milvus Single Node CI/CD failure !"
+                                    }
+                                }
+                            }
+                        }
+
+//                         stage("Cluster") {
+//                             agent {
+//                                 kubernetes {
+//                                     label 'dev-test'
+//                                     defaultContainer 'jnlp'
+//                                     yaml """
+// apiVersion: v1
+// kind: Pod
+// metadata:
+//   labels:
+//     app: milvus
+//     componet: test
+// spec:
+//   containers:
+//   - name: milvus-testframework
+//     image: registry.zilliz.com/milvus/milvus-test:v0.2
+//     command:
+//     - cat
+//     tty: true
+//     volumeMounts:
+//     - name: kubeconf
+//       mountPath: /root/.kube/
+//       readOnly: true
+//   volumes:
+//   - name: kubeconf
+//     secret:
+//       secretName: test-cluster-config
+// """
+//                                 }
+//                             }
+//                             stages {
+//                                 stage("Deploy to Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy to Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_deploy2dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage("Dev Test") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy Test') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_dev_test.groovy"
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_cluster_test_out.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage ("Cleanup Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Cleanup Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                             }
+//                             post {
+//                                 always {
+//                                     container('milvus-testframework') {
+//                                         script {
+//                                             load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                         }
+//                                     }
+//                                 }
+//                                 success {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD success !"
+//                                     }
+//                                 }
+//                                 aborted {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD aborted !"
+//                                     }
+//                                 }
+//                                 failure {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD failure !"
+//                                     }
+//                                 }
+//                             }
+//                         }
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            script {
+                if (env.gitlabAfter != null) {
+                    if (!currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                        // 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'
+                    }
+                }
+            }
+        }
+
+        success {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'success'
+                echo "Milvus CI/CD success !"
+            }
+        }
+
+        aborted {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'canceled'
+                echo "Milvus CI/CD aborted !"
+            }
+        }
+
+        failure {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'failed'
+                echo "Milvus CI/CD failure !"
+            }
+        }
+    }
+}
+

ci/nightly_main_jenkinsfile

@@ -0,0 +1,478 @@
+pipeline {
+    agent none
+
+    options {
+        timestamps()
+    }
+
+    environment {
+        PROJECT_NAME = "milvus"
+        LOWER_BUILD_TYPE = BUILD_TYPE.toLowerCase()
+        SEMVER = "${env.gitlabSourceBranch == null ? params.ENGINE_BRANCH.substring(params.ENGINE_BRANCH.lastIndexOf('/') + 1) : env.gitlabSourceBranch}"
+        GITLAB_AFTER_COMMIT = "${env.gitlabAfter == null ? null : env.gitlabAfter}"
+        SUFFIX_VERSION_NAME = "${env.gitlabAfter == null ? null : env.gitlabAfter.substring(0, 6)}"
+        DOCKER_VERSION_STR = "${env.gitlabAfter == null ? '${SEMVER}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, \"yyyyMMdd\"}' : '${SEMVER}-${LOWER_BUILD_TYPE}-${SUFFIX_VERSION_NAME}'}"
+    }
+
+    stages {
+        stage("Ubuntu 16.04") {
+            environment {
+                PACKAGE_VERSION = VersionNumber([
+                    versionNumberString : '${SEMVER}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}'
+                ]);
+
+                DOCKER_VERSION = VersionNumber([
+                    versionNumberString : '${DOCKER_VERSION_STR}'
+                ]);
+            }
+
+            stages {
+                stage("Run Build") {
+                    agent {
+                        kubernetes {
+                            cloud 'build-kubernetes'
+                            label 'build'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  name: milvus-build-env
+  labels:
+    app: milvus
+    componet: build-env
+spec:
+  containers:
+  - name: milvus-build-env
+    image: registry.zilliz.com/milvus/milvus-build-env:v0.13
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "28Gi"
+        cpu: "10.0"
+        nvidia.com/gpu: 1
+      requests:
+        memory: "14Gi"
+        cpu: "5.0"
+"""
+                        }
+                    }
+                    stages {
+                        stage('Build') {
+                            steps {
+                                gitlabCommitStatus(name: 'Build') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/milvus_build.groovy"
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/packaged_milvus.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'canceled'
+                                echo "Milvus Build aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'failed'
+                                echo "Milvus Build failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Publish docker and helm") {
+                    agent {
+                        kubernetes {
+                            label 'publish'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-docker
+    image: registry.zilliz.com/library/zilliz_docker:v1.0.0
+    securityContext:
+      privileged: true
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: docker-sock
+      mountPath: /var/run/docker.sock
+  volumes:
+  - name: docker-sock
+    hostPath:
+      path: /var/run/docker.sock
+"""
+                        }
+                    }
+                    stages {
+                        stage('Publish Docker') {
+                            steps {
+                                gitlabCommitStatus(name: 'Publish Docker') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/nightly_publish_docker.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'canceled'
+                                echo "Milvus Publish Docker aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'failed'
+                                echo "Milvus Publish Docker failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Deploy to Development") {
+                    parallel {
+                        stage("Single Node") {
+                            agent {
+                                kubernetes {
+                                    label 'dev-test'
+                                    defaultContainer 'jnlp'
+                                    yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.2
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: test-cluster-config
+"""
+                                }
+                            }
+
+                            stages {
+                                stage("Deploy to Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy to Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/deploy2dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage("Dev Test") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy Test') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/dev_test_all.groovy"
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_test_out.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage ("Cleanup Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Cleanup Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            post {
+                                always {
+                                    container('milvus-testframework') {
+                                        script {
+                                            load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                        }
+                                    }
+                                }
+                                success {
+                                    script {
+                                        echo "Milvus Deploy to Dev Single Node CI/CD success !"
+                                    }
+                                }
+                                aborted {
+                                    script {
+                                        echo "Milvus Deploy to Dev Single Node CI/CD aborted !"
+                                    }
+                                }
+                                failure {
+                                    script {
+                                        echo "Milvus Deploy to Dev Single Node CI/CD failure !"
+                                    }
+                                }
+                            }
+                        }
+
+//                         stage("Cluster") {
+//                             agent {
+//                                 kubernetes {
+//                                     label 'dev-test'
+//                                     defaultContainer 'jnlp'
+//                                     yaml """
+// apiVersion: v1
+// kind: Pod
+// metadata:
+//   labels:
+//     app: milvus
+//     componet: test
+// spec:
+//   containers:
+//   - name: milvus-testframework
+//     image: registry.zilliz.com/milvus/milvus-test:v0.2
+//     command:
+//     - cat
+//     tty: true
+//     volumeMounts:
+//     - name: kubeconf
+//       mountPath: /root/.kube/
+//       readOnly: true
+//   volumes:
+//   - name: kubeconf
+//     secret:
+//       secretName: test-cluster-config
+// """
+//                                 }
+//                             }
+//                             stages {
+//                                 stage("Deploy to Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy to Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_deploy2dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage("Dev Test") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy Test') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_dev_test.groovy"
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_cluster_test_out.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage ("Cleanup Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Cleanup Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                             }
+//                             post {
+//                                 always {
+//                                     container('milvus-testframework') {
+//                                         script {
+//                                             load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                         }
+//                                     }
+//                                 }
+//                                 success {
+//                                     script {
+//                                         echo "Milvus Deploy to Dev Cluster CI/CD success !"
+//                                     }
+//                                 }
+//                                 aborted {
+//                                     script {
+//                                         echo "Milvus Deploy to Dev Cluster CI/CD aborted !"
+//                                     }
+//                                 }
+//                                 failure {
+//                                     script {
+//                                         echo "Milvus Deploy to Dev Cluster CI/CD failure !"
+//                                     }
+//                                 }
+//                             }
+//                         }
+                    }
+                }
+
+                stage("Deploy to Staging") {
+                    parallel {
+                        stage("Single Node") {
+                            agent {
+                                kubernetes {
+                                    label 'dev-test'
+                                    defaultContainer 'jnlp'
+                                    yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.2
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: aks-gpu-cluster-config
+"""
+                                }
+                            }
+
+                            stages {
+                                stage("Deploy to Staging") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy to Staging') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/deploy2staging.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage("Staging Test") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Staging Test') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/staging_test.groovy"
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/upload_staging_test_out.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage ("Cleanup Staging") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Cleanup Staging') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_staging.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            post {
+                                always {
+                                    container('milvus-testframework') {
+                                        script {
+                                            load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_staging.groovy"
+                                        }
+                                    }
+                                }
+                                success {
+                                    script {
+                                        echo "Milvus Deploy to Staging Single Node CI/CD success !"
+                                    }
+                                }
+                                aborted {
+                                    script {
+                                        echo "Milvus Deploy to Staging Single Node CI/CD aborted !"
+                                    }
+                                }
+                                failure {
+                                    script {
+                                        echo "Milvus Deploy to Staging Single Node CI/CD failure !"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            script {
+                if (!currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                    // 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'
+                }
+            }
+        }
+
+        success {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'success'
+                echo "Milvus CI/CD success !"
+            }
+        }
+
+        aborted {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'canceled'
+                echo "Milvus CI/CD aborted !"
+            }
+        }
+
+        failure {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'failed'
+                echo "Milvus CI/CD failure !"
+            }
+        }
+    }
+}
+

ci/pod_containers/milvus-engine-build.yaml

@@ -0,0 +1,13 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: build-env
+spec:
+  containers:
+  - name: milvus-build-env
+    image: registry.zilliz.com/milvus/milvus-build-env:v0.9
+    command:
+    - cat
+    tty: true

ci/pod_containers/milvus-testframework.yaml

@@ -0,0 +1,13 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: testframework
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.1
+    command:
+    - cat
+    tty: true

ci/pod_containers/publish-docker.yaml

@@ -0,0 +1,22 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-docker
+    image: registry.zilliz.com/library/zilliz_docker:v1.0.0
+    securityContext:
+      privileged: true
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: docker-sock
+      mountPath: /var/run/docker.sock
+  volumes:
+  - name: docker-sock
+    hostPath:
+      path: /var/run/docker.sock

core/build.sh

@@ -1,11 +1,12 @@
 #!/bin/bash
 
+BUILD_OUTPUT_DIR="cmake_build"
 BUILD_TYPE="Debug"
 BUILD_UNITTEST="OFF"
 INSTALL_PREFIX=$(pwd)/milvus
 MAKE_CLEAN="OFF"
 BUILD_COVERAGE="OFF"
-DB_PATH="/opt/milvus"
+DB_PATH="/tmp/milvus"
 PROFILING="OFF"
 USE_JFROG_CACHE="OFF"
 RUN_CPPLINT="OFF"
@@ -40,8 +41,8 @@ do
                 RUN_CPPLINT="ON"
                 ;;
              r)
-                if [[ -d cmake_build ]]; then
-                    rm ./cmake_build -r
+                if [[ -d ${BUILD_OUTPUT_DIR} ]]; then
+                    rm ./${BUILD_OUTPUT_DIR} -r
                     MAKE_CLEAN="ON"
                 fi
                 ;;
@@ -62,7 +63,7 @@ do
 
 parameter:
 -p: install prefix(default: $(pwd)/milvus)
--d: db path(default: /opt/milvus)
+-d: db data path(default: /tmp/milvus)
 -t: build type(default: Debug)
 -u: building unit test options(default: OFF)
 -l: run cpplint, clang-format and clang-tidy(default: OFF)
@@ -84,11 +85,11 @@ usage:
         esac
 done
 
-if [[ ! -d cmake_build ]]; then
-    mkdir cmake_build
+if [[ ! -d ${BUILD_OUTPUT_DIR} ]]; then
+    mkdir ${BUILD_OUTPUT_DIR}
 fi
 
-cd cmake_build
+cd ${BUILD_OUTPUT_DIR}
 
 CMAKE_CMD="cmake \
 -DBUILD_UNIT_TEST=${BUILD_UNITTEST} \
@@ -114,6 +115,7 @@ if [[ ${RUN_CPPLINT} == "ON" ]]; then
     make lint
     if [ $? -ne 0 ]; then
         echo "ERROR! cpplint check failed"
+        rm -f CMakeCache.txt
         exit 1
     fi
     echo "cpplint check passed!"
@@ -122,6 +124,7 @@ if [[ ${RUN_CPPLINT} == "ON" ]]; then
     make check-clang-format
     if [ $? -ne 0 ]; then
         echo "ERROR! clang-format check failed"
+        rm -f CMakeCache.txt
         exit 1
     fi
     echo "clang-format check passed!"
@@ -130,9 +133,12 @@ if [[ ${RUN_CPPLINT} == "ON" ]]; then
 #    make check-clang-tidy
 #    if [ $? -ne 0 ]; then
 #        echo "ERROR! clang-tidy check failed"
+#        rm -f CMakeCache.txt
 #        exit 1
 #    fi
 #    echo "clang-tidy check passed!"
+
+    rm -f CMakeCache.txt
 else
     # compile and build
     make -j 4 || exit 1

core/cmake/DefineOptions.cmake

@@ -56,7 +56,7 @@ define_option(MILVUS_VERBOSE_THIRDPARTY_BUILD
         "Show output from ExternalProjects rather than just logging to files" ON)
 
 define_option(MILVUS_BOOST_VENDORED "Use vendored Boost instead of existing Boost. \
-Note that this requires linking Boost statically" ON)
+Note that this requires linking Boost statically" OFF)
 
 define_option(MILVUS_BOOST_HEADER_ONLY "Use only BOOST headers" OFF)
 

core/conf/server_config.template

@@ -30,6 +30,8 @@ metric_config:
 cache_config:
   cpu_cache_capacity: 16            # GB, CPU memory used for cache
   cpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered
+  gpu_cache_capacity: 4             # GB, GPU memory used for cache
+  gpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered
   cache_insert_data: false          # whether to load inserted data into cache
 
 engine_config:

core/src/CMakeLists.txt

@@ -96,9 +96,9 @@ set(prometheus_lib
         )
 
 set(boost_lib
-        boost_system_static
-        boost_filesystem_static
-        boost_serialization_static
+        libboost_system.a
+        libboost_filesystem.a
+        libboost_serialization.a
         )
 
 set(cuda_lib

core/src/main.cpp

@@ -50,7 +50,7 @@ print_banner() {
     std::cout << "  / /|_/ // // /_| |/ / /_/ /\\ \\    " << std::endl;
     std::cout << " /_/  /_/___/____/___/\\____/___/     " << std::endl;
     std::cout << std::endl;
-    std::cout << "Welcome to use Milvus by Zilliz!" << std::endl;
+    std::cout << "Welcome to Milvus!" << std::endl;
     std::cout << "Milvus " << BUILD_TYPE << " version: v" << MILVUS_VERSION << ", built at " << BUILD_TIME << std::endl;
     std::cout << std::endl;
 }

core/src/server/Config.h

@@ -62,7 +62,7 @@ static const char* CONFIG_CACHE = "cache_config";
 static const char* CONFIG_CACHE_CPU_CACHE_CAPACITY = "cpu_cache_capacity";
 static const char* CONFIG_CACHE_CPU_CACHE_CAPACITY_DEFAULT = "16";
 static const char* CONFIG_CACHE_GPU_CACHE_CAPACITY = "gpu_cache_capacity";
-static const char* CONFIG_CACHE_GPU_CACHE_CAPACITY_DEFAULT = "0";
+static const char* CONFIG_CACHE_GPU_CACHE_CAPACITY_DEFAULT = "4";
 static const char* CONFIG_CACHE_CPU_CACHE_THRESHOLD = "cpu_mem_threshold";
 static const char* CONFIG_CACHE_CPU_CACHE_THRESHOLD_DEFAULT = "0.85";
 static const char* CONFIG_CACHE_GPU_CACHE_THRESHOLD = "gpu_mem_threshold";

core/ubuntu_build_deps.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
 
-sudo apt-get install -y gfortran libmysqlclient-dev mysql-client libcurl4-openssl-dev
+sudo apt-get install -y gfortran libmysqlclient-dev mysql-client libcurl4-openssl-dev libboost-system-dev libboost-filesystem-dev libboost-serialization-dev
 
 sudo ln -s /usr/lib/x86_64-linux-gnu/libmysqlclient.so /usr/lib/x86_64-linux-gnu/libmysqlclient_r.so

core/unittest/CMakeLists.txt

@@ -92,8 +92,8 @@ set(common_files
 
 set(unittest_libs
         sqlite
-        boost_system_static
-        boost_filesystem_static
+        libboost_system.a
+        libboost_filesystem.a
         lz4
         mysqlpp
         yaml-cpp

docker/docker-compose-monitor.yml

@@ -42,15 +42,15 @@ services:
 
     milvus_server:
         runtime: nvidia
-        image: registry.zilliz.com/milvus/engine:branch-0.4.0-release
+        image: milvusdb/milvus:latest
         restart: always
         links:
             - prometheus
         environment:
             WEB_APP: host.docker.internal
         volumes:
-            - ../cpp/conf/server_config.yaml:/opt/milvus/conf/server_config.yaml
-            - ../cpp/conf/log_config.conf:/opt/milvus/conf/log_config.conf
+            - ../core/conf/server_config.yaml:/opt/milvus/conf/server_config.yaml
+            - ../core/conf/log_config.conf:/opt/milvus/conf/log_config.conf
         ports:
             - "8080:8080"
             - "19530:19530"