update build.groovy

ci/jenkins/Jenkinsfile

@@ -33,275 +33,161 @@ pipeline {
     }
 
     stages {
-        stage("Ubuntu 18.04 x86_64") {
+        stage ('Milvus Build and Test') {
-            environment {
+            matrix {
-                OS_NAME = "ubuntu18.04"
+                agent none
-                CPU_ARCH = "amd64"
+                axes {
-            }
+                    axis {
-
+                        name 'OS_NAME'
-            parallel {
+                        values 'ubuntu18.04', 'centos7'
-                stage ("GPU Version") {
-                    environment {
-                        BINRARY_VERSION = "gpu"
-                        PACKAGE_VERSION = VersionNumber([
-                            versionNumberString : '${SEMVER}-gpu-${OS_NAME}-${CPU_ARCH}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}-${BUILDS_TODAY}'
-                        ]);
-                        DOCKER_VERSION = "${SEMVER}-gpu-${OS_NAME}-${LOWER_BUILD_TYPE}"
                     }
 
-                    stages {
+                    axis {
-                        stage("Run Build") {
+                        name 'CPU_ARCH'
-                            agent {
+                        values 'amd64'
-                                kubernetes {
+                    }
-                                    label "${env.BINRARY_VERSION}-build"
-                                    defaultContainer 'jnlp'
-                                    yamlFile 'ci/jenkins/pod/milvus-gpu-version-build-env-pod.yaml'
-                                }
-                            }
 
-                            stages {
+                    axis {
-                                stage('Build') {
+                        name 'BINRARY_VERSION'
-                                    steps {
+                        values 'gpu', 'cpu'
-                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/build.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-                                stage('Code Coverage') {
-                                    steps {
-                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/coverage.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-                                stage('Upload Package') {
-                                    steps {
-                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/package.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        stage("Publish docker images") {
-                            agent {
-                                kubernetes {
-                                    label "${env.BINRARY_VERSION}-publish"
-                                    defaultContainer 'jnlp'
-                                    yamlFile 'ci/jenkins/pod/docker-pod.yaml'
-                                }
-                            }
-
-                            stages {
-                                stage('Publish') {
-                                    steps {
-                                        container('publish-images') {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/publishImages.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        stage("Deploy to Development") {
-                            environment {
-                                FROMAT_SEMVER = "${env.SEMVER}".replaceAll("\\.", "-")
-                                HELM_RELEASE_NAME = "${env.PIPELINE_NAME}-${env.FROMAT_SEMVER}-${env.BUILD_NUMBER}-single-${env.BINRARY_VERSION}".toLowerCase()
-                            }
-
-                            agent {
-                                kubernetes {
-                                    label "${env.BINRARY_VERSION}-dev-test"
-                                    defaultContainer 'jnlp'
-                                    yamlFile 'ci/jenkins/pod/testEnvironment.yaml'
-                                }
-                            }
-
-                            stages {
-                                stage("Deploy to Dev") {
-                                    steps {
-                                        container('milvus-test-env') {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/deploySingle2Dev.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-
-                                stage("Dev Test") {
-                                    steps {
-                                        container('milvus-test-env') {
-                                            script {
-                                                boolean isNightlyTest = isTimeTriggeredBuild()
-                                                if (isNightlyTest) {
-                                                    load "${env.WORKSPACE}/ci/jenkins/step/singleDevNightlyTest.groovy"
-                                                } else {
-                                                    load "${env.WORKSPACE}/ci/jenkins/step/singleDevTest.groovy"
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-
-                                stage ("Cleanup Dev") {
-                                    steps {
-                                        container('milvus-test-env') {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            post {
-                                unsuccessful {
-                                    container('milvus-test-env') {
-                                        script {
-                                            load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
-                                        }
-                                    }
-                                }
-                            }
-                        }
                     }
                 }
 
-                stage ("CPU Version") {
+                stages {
-                    environment {
+                    stage("Milvus CI") {
-                        BINRARY_VERSION = "cpu"
+                        environment {
-                        PACKAGE_VERSION = VersionNumber([
+                            PACKAGE_VERSION = VersionNumber([
-                            versionNumberString : '${SEMVER}-cpu-${OS_NAME}-${CPU_ARCH}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}-${BUILDS_TODAY}'
+                                versionNumberString : '${SEMVER}-${BINRARY_VERSION}-${OS_NAME}-${CPU_ARCH}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}-${BUILDS_TODAY}'
-                        ]);
+                            ]);
-                        DOCKER_VERSION = "${SEMVER}-cpu-${OS_NAME}-${LOWER_BUILD_TYPE}"
+                            DOCKER_VERSION = "${SEMVER}-${BINRARY_VERSION}-${OS_NAME}-${LOWER_BUILD_TYPE}"
-                    }
-
-                    stages {
-                        stage("Run Build") {
-                            agent {
-                                kubernetes {
-                                    label "${env.BINRARY_VERSION}-build"
-                                    defaultContainer 'jnlp'
-                                    yamlFile 'ci/jenkins/pod/milvus-cpu-version-build-env-pod.yaml'
-                                }
-                            }
-
-                            stages {
-                                stage('Build') {
-                                    steps {
-                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/build.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-                                stage('Code Coverage') {
-                                    steps {
-                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/coverage.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-                                stage('Upload Package') {
-                                    steps {
-                                        container("milvus-${env.BINRARY_VERSION}-build-env") {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/package.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
                         }
 
-                        stage("Publish docker images") {
+                        stages {
-                            agent {
+                            stage('Run Build') {
-                                kubernetes {
+                                agent {
-                                    label "${env.BINRARY_VERSION}-publish"
+                                    kubernetes {
-                                    defaultContainer 'jnlp'
+                                        label "${OS_NAME}-${BINRARY_VERSION}-build"
-                                    yamlFile 'ci/jenkins/pod/docker-pod.yaml'
+                                        defaultContainer 'jnlp'
-                                }
+                                        yamlFile "ci/jenkins/pod/milvus-${BINRARY_VERSION}-version-${OS_NAME}-build-env-pod.yaml"
-                            }
-
-                            stages {
-                                stage('Publish') {
-                                    steps {
-                                        container('publish-images'){
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/publishImages.groovy"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        stage("Deploy to Development") {
-                            environment {
-                                FROMAT_SEMVER = "${env.SEMVER}".replaceAll("\\.", "-")
-                                HELM_RELEASE_NAME = "${env.PIPELINE_NAME}-${env.FROMAT_SEMVER}-${env.BUILD_NUMBER}-single-${env.BINRARY_VERSION}".toLowerCase()
-                            }
-
-                            agent {
-                                kubernetes {
-                                    label "${env.BINRARY_VERSION}-dev-test"
-                                    defaultContainer 'jnlp'
-                                    yamlFile 'ci/jenkins/pod/testEnvironment.yaml'
-                                }
-                            }
-
-                            stages {
-                                stage("Deploy to Dev") {
-                                    steps {
-                                        container('milvus-test-env') {
-                                            script {
-                                                load "${env.WORKSPACE}/ci/jenkins/step/deploySingle2Dev.groovy"
-                                            }
-                                        }
                                     }
                                 }
 
-                                stage("Dev Test") {
+                                stages {
-                                    steps {
+                                    stage('Build') {
-                                        container('milvus-test-env') {
+                                        steps {
-                                            script {
+                                            container("milvus-${BINRARY_VERSION}-build-env") {
-                                                boolean isNightlyTest = isTimeTriggeredBuild()
+                                                script {
-                                                if (isNightlyTest) {
+                                                    load "${env.WORKSPACE}/ci/jenkins/step/build.groovy"
-                                                    load "${env.WORKSPACE}/ci/jenkins/step/singleDevNightlyTest.groovy"
+                                                }
-                                                } else {
+                                            }
-                                                    load "${env.WORKSPACE}/ci/jenkins/step/singleDevTest.groovy"
+                                        }
+                                    }
+
+                                    stage('Code Coverage') {
+                                        steps {
+                                            container("milvus-${BINRARY_VERSION}-build-env") {
+                                                script {
+                                                    if ("${BINRARY_VERSION}" == "gpu") {
+                                                        load "${env.WORKSPACE}/ci/jenkins/step/coverage.groovy"
+                                                    } else {
+                                                        echo "Skip Code Coverage"
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    stage('Upload Package') {
+                                        steps {
+                                            container("milvus-${BINRARY_VERSION}-build-env") {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkins/step/package.groovy"
                                                 }
                                             }
                                         }
                                     }
                                 }
+                            }
 
-                                stage ("Cleanup Dev") {
+                            stage('Publish docker images') {
-                                    steps {
+                                agent {
-                                        container('milvus-test-env') {
+                                    kubernetes {
-                                            script {
+                                        label "${OS_NAME}-${BINRARY_VERSION}-publish"
-                                                load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
+                                        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"
+                                                }
                                             }
                                         }
                                     }
                                 }
                             }
-                            post {
+
-                                unsuccessful {
+                            stage('Deploy to Development') {
-                                    container('milvus-test-env') {
+                                environment {
-                                        script {
+                                    FROMAT_SEMVER = "${env.SEMVER}".replaceAll("\\.", "-")
-                                            load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
+                                    FORMAT_OS_NAME = "${OS_NAME}".replaceAll("\\.", "-")
+                                    HELM_RELEASE_NAME = "${env.PIPELINE_NAME}-${env.FROMAT_SEMVER}-${env.BUILD_NUMBER}-single-${FORMAT_OS_NAME}-${BINRARY_VERSION}".toLowerCase()
+                                }
+
+                                agent {
+                                    kubernetes {
+                                        label "${OS_NAME}-${BINRARY_VERSION}-dev-test"
+                                        defaultContainer 'jnlp'
+                                        yamlFile 'ci/jenkins/pod/testEnvironment.yaml'
+                                    }
+                                }
+
+                                stages {
+                                    stage('Deploy to Dev') {
+                                        steps {
+                                            container('milvus-test-env') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkins/step/deploySingle2Dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    stage('Dev Test') {
+                                        steps {
+                                            container('milvus-test-env') {
+                                                script {
+                                                    boolean isNightlyTest = isTimeTriggeredBuild()
+                                                    if (isNightlyTest) {
+                                                        load "${env.WORKSPACE}/ci/jenkins/step/singleDevNightlyTest.groovy"
+                                                    } else {
+                                                        load "${env.WORKSPACE}/ci/jenkins/step/singleDevTest.groovy"
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    stage('Cleanup Dev') {
+                                        steps {
+                                            container('milvus-test-env') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                post {
+                                    unsuccessful {
+                                        container('milvus-test-env') {
+                                            script {
+                                                load "${env.WORKSPACE}/ci/jenkins/step/cleanupSingleDev.groovy"
+                                            }
                                         }
                                     }
                                 }

ci/jenkins/pod/milvus-cpu-version-centos7-build-env-pod.yaml

@@ -0,0 +1,38 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: milvus-cpu-build-env
+  labels:
+    app: milvus
+    componet: cpu-build-env
+spec:
+  containers:
+  - name: milvus-cpu-build-env
+    image: registry.zilliz.com/milvus/milvus-cpu-build-env:v0.7.0-centos7
+    env:
+    - name: POD_IP
+      valueFrom:
+        fieldRef:
+          fieldPath: status.podIP
+    - name: OS_NAME
+      value: "centos7"
+    - name: BUILD_ENV_IMAGE_ID
+      value: "225b4d9c26d67b70b476964b4dd6e216de4b464d7a973a8c0c7ed1313c4d81ad"
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "12Gi"
+        cpu: "8.0"
+      requests:
+        memory: "8Gi"
+        cpu: "4.0"
+  - name: milvus-mysql
+    image: mysql:5.6
+    env:
+    - name: MYSQL_ROOT_PASSWORD
+      value: 123456
+    ports:
+    - containerPort: 3306
+      name: mysql

ci/jenkins/pod/milvus-cpu-version-ubuntu18.04-build-env-pod.yaml

@@ -8,12 +8,14 @@ metadata:
 spec:
   containers:
   - name: milvus-cpu-build-env
-    image: registry.zilliz.com/milvus/milvus-cpu-build-env:v0.6.0-ubuntu18.04
+    image: registry.zilliz.com/milvus/milvus-cpu-build-env:v0.7.0-ubuntu18.04
     env:
     - name: POD_IP
       valueFrom:
         fieldRef:
           fieldPath: status.podIP
+    - name: OS_NAME
+      value: "ubuntu18.04"
     - name: BUILD_ENV_IMAGE_ID
       value: "23476391bec80c64f10d44a6370c73c71f011a6b95114b10ff82a60e771e11c7"
     command:

ci/jenkins/pod/milvus-gpu-version-centos7-build-env-pod.yaml

@@ -0,0 +1,39 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: milvus-gpu-build-env
+  labels:
+    app: milvus
+    componet: gpu-build-env
+spec:
+  containers:
+  - name: milvus-gpu-build-env
+    image: registry.zilliz.com/milvus/milvus-gpu-build-env:v0.7.0-centos7
+    env:
+    - name: POD_IP
+      valueFrom:
+        fieldRef:
+          fieldPath: status.podIP
+    - name: OS_NAME
+      value: "centos7"
+    - name: BUILD_ENV_IMAGE_ID
+      value: "a5ec9914737ea4727d88ae36b4a73ca5d817f19438ba913cc1de6a1ee2ed2336"
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "12Gi"
+        cpu: "8.0"
+        nvidia.com/gpu: 1
+      requests:
+        memory: "8Gi"
+        cpu: "4.0"
+  - name: milvus-mysql
+    image: mysql:5.6
+    env:
+    - name: MYSQL_ROOT_PASSWORD
+      value: 123456
+    ports:
+    - containerPort: 3306
+      name: mysql

ci/jenkins/pod/milvus-gpu-version-ubuntu18.04-build-env-pod.yaml

@@ -8,12 +8,14 @@ metadata:
 spec:
   containers:
   - name: milvus-gpu-build-env
-    image: registry.zilliz.com/milvus/milvus-gpu-build-env:v0.6.0-ubuntu18.04
+    image: registry.zilliz.com/milvus/milvus-gpu-build-env:v0.7.0-ubuntu18.04
     env:
     - name: POD_IP
       valueFrom:
         fieldRef:
           fieldPath: status.podIP
+    - name: OS_NAME
+      value: "ubuntu18.04"
     - name: BUILD_ENV_IMAGE_ID
       value: "da9023b0f858f072672f86483a869aa87e90a5140864f89e5a012ec766d96dea"
     command:

ci/jenkins/step/build.groovy

@@ -2,10 +2,11 @@ timeout(time: 60, unit: 'MINUTES') {
     dir ("ci/scripts") {
         withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
             def checkResult = sh(script: "./check_ccache.sh -l ${params.JFROG_ARTFACTORY_URL}/ccache", returnStatus: true)
-            if ("${env.BINRARY_VERSION}" == "gpu") {
+            
-                sh ". ./before-install.sh && ./build.sh -t ${params.BUILD_TYPE} -o ${env.MILVUS_INSTALL_PREFIX} -l -g -x -u -c"
+            if ("${BINRARY_VERSION}" == "gpu") {
+                sh "/bin/bash --login -c \". ./before-install.sh && ./build.sh -t ${params.BUILD_TYPE} -o ${env.MILVUS_INSTALL_PREFIX} -l -g -u -c\""
             } else {
-                sh ". ./before-install.sh && ./build.sh -t ${params.BUILD_TYPE} -o ${env.MILVUS_INSTALL_PREFIX} -l -u -c"
+                sh "/bin/bash --login -c \". ./before-install.sh && ./build.sh -t ${params.BUILD_TYPE} -o ${env.MILVUS_INSTALL_PREFIX} -l -u -c\""
             }
             sh "./update_ccache.sh -l ${params.JFROG_ARTFACTORY_URL}/ccache -u ${USERNAME} -p ${PASSWORD}"
         }

ci/jenkins/step/deploySingle2Dev.groovy

@@ -3,7 +3,7 @@ sh 'helm repo update'
 dir ('milvus-helm') {
     checkout([$class: 'GitSCM', branches: [[name: "0.6.0"]], userRemoteConfigs: [[url: "https://github.com/milvus-io/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.6.0:refs/remotes/origin/0.6.0"]]])
     dir ("milvus") {
-        sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.HELM_RELEASE_NAME} -f ci/db_backend/sqlite_${env.BINRARY_VERSION}_values.yaml -f ci/filebeat/values.yaml --namespace milvus ."
+        sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.HELM_RELEASE_NAME} -f ci/db_backend/sqlite_${BINRARY_VERSION}_values.yaml -f ci/filebeat/values.yaml --namespace milvus ."
     }
 }
 

ci/jenkins/step/publishImages.groovy

@@ -1,5 +1,5 @@
 timeout(time: 15, unit: 'MINUTES') {
-    dir ("docker/deploy/${env.BINRARY_VERSION}/${env.OS_NAME}") {
+    dir ("docker/deploy/${BINRARY_VERSION}/${OS_NAME}") {
         def binaryPackage = "${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz"
 
         withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'JFROG_USERNAME', passwordVariable: 'JFROG_PASSWORD')]) {

ci/jenkins/step/singleDevNightlyTest.groovy

@@ -13,7 +13,7 @@ timeout(time: 90, unit: 'MINUTES') {
     }
     dir ("milvus-helm") {
         dir ("milvus") {
-            sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.HELM_RELEASE_NAME} -f ci/db_backend/mysql_${env.BINRARY_VERSION}_values.yaml -f ci/filebeat/values.yaml --namespace milvus ."
+            sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.HELM_RELEASE_NAME} -f ci/db_backend/mysql_${BINRARY_VERSION}_values.yaml -f ci/filebeat/values.yaml --namespace milvus ."
         }
     }
     dir ("tests/milvus_python_test") {

ci/jenkins/step/singleDevTest.groovy

@@ -14,7 +14,7 @@ timeout(time: 60, unit: 'MINUTES') {
     // }
     // dir ("milvus-helm") {
     //     dir ("milvus") {
-    //         sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.HELM_RELEASE_NAME} -f ci/db_backend/mysql_${env.BINRARY_VERSION}_values.yaml -f ci/filebeat/values.yaml --namespace milvus ."
+    //         sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.HELM_RELEASE_NAME} -f ci/db_backend/mysql_${BINRARY_VERSION}_values.yaml -f ci/filebeat/values.yaml --namespace milvus ."
     //     }
     // }
     // dir ("tests/milvus_python_test") {

ci/scripts/check_ccache.sh

@@ -1,7 +1,6 @@
 #!/bin/bash
 
-OS_NAME="linux"
+OS_NAME="${OS_NAME}"
-CODE_NAME=$(lsb_release -sc)
 BUILD_ENV_DOCKER_IMAGE_ID="${BUILD_ENV_IMAGE_ID}"
 BRANCH_NAMES=$(git log --decorate | head -n 1 | sed 's/.*(\(.*\))/\1/' | sed 's=[a-zA-Z]*\/==g' | awk -F", " '{$1=""; print $0}')
 ARTIFACTORY_URL=""
@@ -43,13 +42,14 @@ fi
 
 check_ccache() {
     BRANCH=$1
-    echo "fetching ${BRANCH}/ccache-${OS_NAME}-${CODE_NAME}-${BUILD_ENV_DOCKER_IMAGE_ID}.tar.gz"
+    PACKAGE_FILE="ccache-${OS_NAME}-${BUILD_ENV_DOCKER_IMAGE_ID}.tar.gz"
-    wget -q --method HEAD "${ARTIFACTORY_URL}/${BRANCH}/ccache-${OS_NAME}-${CODE_NAME}-${BUILD_ENV_DOCKER_IMAGE_ID}.tar.gz"
+    echo "fetching ${BRANCH}/${PACKAGE_FILE}"
+    wget -q --method HEAD "${ARTIFACTORY_URL}/${BRANCH}/${PACKAGE_FILE}"
     if [[ $? == 0 ]];then
-        wget -q "${ARTIFACTORY_URL}/${BRANCH}/ccache-${OS_NAME}-${CODE_NAME}-${BUILD_ENV_DOCKER_IMAGE_ID}.tar.gz" && \
+        wget -q "${ARTIFACTORY_URL}/${BRANCH}/${PACKAGE_FILE}" && \
         mkdir -p ${CCACHE_DIRECTORY} && \
-        tar zxf ccache-${OS_NAME}-${CODE_NAME}-${BUILD_ENV_DOCKER_IMAGE_ID}.tar.gz -C ${CCACHE_DIRECTORY} && \
+        tar zxf ${PACKAGE_FILE} -C ${CCACHE_DIRECTORY} && \
-        rm ccache-${OS_NAME}-${CODE_NAME}-${BUILD_ENV_DOCKER_IMAGE_ID}.tar.gz
+        rm ${PACKAGE_FILE}
         if [[ $? == 0 ]];then
             echo "found cache"
             exit 0

ci/scripts/coverage.sh

@@ -13,10 +13,11 @@ MILVUS_CORE_DIR="${SCRIPTS_DIR}/../../core"
 CORE_BUILD_DIR="${MILVUS_CORE_DIR}/cmake_build"
 MYSQL_USER_NAME=root
 MYSQL_PASSWORD=123456
-MYSQL_HOST='127.0.0.1'
+MYSQL_HOST="127.0.0.1"
-MYSQL_PORT='3306'
+MYSQL_PORT="3306"
+CODECOV_TOKEN=""
 
-while getopts "o:b:u:p:t:h" arg
+while getopts "o:b:u:p:t:c:h" arg
 do
         case $arg in
              o)
@@ -34,6 +35,9 @@ do
              t)
                 MYSQL_HOST=$OPTARG
                 ;;
+             c)
+                CODECOV_TOKEN=$OPTARG
+                ;;
              h) # help
                 echo "
 
@@ -43,10 +47,11 @@ parameter:
 -u: mysql account
 -p: mysql password
 -t: mysql host
+-c: codecov token
 -h: help
 
 usage:
-./coverage.sh -o \${INSTALL_PREFIX} -b \${CORE_BUILD_DIR} -u \${MYSQL_USER} -p \${MYSQL_PASSWORD} -t \${MYSQL_HOST} [-h]
+./coverage.sh -o \${INSTALL_PREFIX} -b \${CORE_BUILD_DIR} -u \${MYSQL_USER} -p \${MYSQL_PASSWORD} -t \${MYSQL_HOST} -c \${CODECOV_TOKEN} [-h]
                 "
                 exit 0
                 ;;
@@ -146,5 +151,7 @@ if [ $? -ne 0 ]; then
     exit 2
 fi
 
-# gen html report
+if [[ ! -z ${CODECOV_TOKEN} ]];then
-# ${LCOV_GEN_CMD} "${FILE_INFO_OUTPUT_NEW}" --output-directory ${DIR_LCOV_OUTPUT}/
+    export CODECOV_TOKEN="${CODECOV_TOKEN}"
+    curl -s https://codecov.io/bash | bash -s - -f output_new.info || echo "Codecov did not collect coverage reports"
+fi

ci/scripts/update_ccache.sh

@@ -1,7 +1,6 @@
 #!/bin/bash
 
-OS_NAME="linux"
+OS_NAME="${OS_NAME}"
-CODE_NAME=$(lsb_release -sc)
 BUILD_ENV_DOCKER_IMAGE_ID="${BUILD_ENV_IMAGE_ID}"
 BRANCH_NAME=$(git log --decorate | head -n 1 | sed 's/.*(\(.*\))/\1/' | sed 's/.*, //' | sed 's=[a-zA-Z]*\/==g')
 ARTIFACTORY_URL=""
@@ -51,7 +50,7 @@ if [[ -z "${ARTIFACTORY_URL}" || "${ARTIFACTORY_URL}" == "" ]];then
     exit 1
 fi
 
-PACKAGE_FILE="ccache-${OS_NAME}-${CODE_NAME}-${BUILD_ENV_DOCKER_IMAGE_ID}.tar.gz"
+PACKAGE_FILE="ccache-${OS_NAME}-${BUILD_ENV_DOCKER_IMAGE_ID}.tar.gz"
 REMOTE_PACKAGE_PATH="${ARTIFACTORY_URL}/${BRANCH_NAME}"
 
 ccache --show-stats

core/cmake/ThirdPartyPackages.cmake

@@ -331,7 +331,7 @@ if (DEFINED ENV{MILVUS_GRPC_URL})
     set(GRPC_SOURCE_URL "$ENV{MILVUS_GRPC_URL}")
 else ()
     set(GRPC_SOURCE_URL
-            "https://github.com/youny626/grpc-milvus/archive/${GRPC_VERSION}.zip")
+            "https://github.com/ZhifengZhang-CN/grpc-milvus/archive/${GRPC_VERSION}.zip")
 endif ()
 set(GRPC_MD5 "0362ba219f59432c530070b5f5c3df73")
 

docker-compose.yml

@@ -59,9 +59,7 @@ services:
     networks:
       - milvus
     command: &centos-command >
-      /bin/bash -c "
+      /bin/bash --login -c "
-        source scl_source enable devtoolset-7
-        source scl_source enable llvm-toolset-7.0
         /milvus/ci/scripts/build.sh -t Release -o ${MILVUS_INSTALL_PREFIX} -l -u -c
         /milvus/ci/scripts/coverage.sh -o ${MILVUS_INSTALL_PREFIX} -u root -p 123456 -t mysql"