add ci

Former-commit-id: 6ba5e9408d396d55b15d2ff1d82407e4b7169af9

ci/jenkins/Jenkinsfile

+pipeline {
+    agent none
+
+    options {
+        timestamps()
+    }
+
+    parameters{
+        choice choices: ['Release', 'Debug'], description: '', name: 'BUILD_TYPE'
+        string defaultValue: 'cf1434e7-5a4b-4d25-82e8-88d667aef9e5', description: 'GIT CREDENTIALS ID', name: 'GIT_CREDENTIALS_ID', trim: true
+        string defaultValue: '1a527823-d2b7-44fd-834b-9844350baf14', description: 'JFROG CREDENTIALS ID', name: 'JFROG_CREDENTIALS_ID', trim: true
+        string defaultValue: 'ba070c98-c8cc-4f7c-b657-897715f359fc', description: 'DOCKER CREDENTIALS ID', name: 'DOCKER_CREDENTIALS_ID', trim: true
+        string defaultValue: 'http://192.168.1.202/artifactory/milvus', description: 'JFROG ARTFACTORY URL', name: 'JFROG_ARTFACTORY_URL', trim: true
+    }
+
+    environment {
+        PROJECT_NAME = "milvus"
+        LOWER_BUILD_TYPE = params.BUILD_TYPE.toLowerCase()
+        SEMVER = "${BRANCH_NAME}"
+        JOBNAMES = env.JOB_NAME.split('/')
+        PIPELIEN_NAME = "${JOBNAMES[0]}"
+    }
+
+    stages {
+        stage("Ubuntu 16.04") {
+            environment {
+                OS_NAME = "ubuntu16.04"
+                PACKAGE_VERSION = VersionNumber([
+                    versionNumberString : '${SEMVER}-${LOWER_BUILD_TYPE}-${OS_NAME}-x86_64-${BUILD_DATE_FORMATTED, "yyyyMMdd"}-${BUILDS_TODAY}'
+                ]);
+                DOCKER_VERSION = "${SEMVER}-${OS_NAME}-${LOWER_BUILD_TYPE}"
+            }
+
+            stages {
+                stage("Run Build") {
+                    agent {
+                        kubernetes {
+                            label 'build'
+                            defaultContainer 'jnlp'
+                            yamlFile 'ci/pod/milvus-build-env-pod.yaml'
+                        }
+                    }
+
+                    stages {
+                        stage('Build') {
+                            steps {
+                                container('milvus-build-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/build.groovy"
+                                    }
+                                }
+                            }
+                        }
+                        stage('Upload Package') {
+                            steps {
+                                container('milvus-build-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/package.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                stage("Publish docker images") {
+                    agent {
+                        kubernetes {
+                            label 'publish'
+                            defaultContainer 'jnlp'
+                            yamlFile 'ci/pod/docker-pod.yaml'
+                        }
+                    }
+
+                    stages {
+                        stage('Publish') {
+                            steps {
+                                container('publish-images'){
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/publishImages.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                stage("Deploy to Development") {
+                    agent {
+                        kubernetes {
+                            label 'dev-test'
+                            defaultContainer 'jnlp'
+                            yamlFile 'ci/pod/testEnvironment.yaml'
+                        }
+                    }
+
+                    stages {
+                        stage("Deploy to Dev") {
+                            steps {
+                                container('milvus-test-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/deploySingle2Dev.groovy"
+                                    }
+                                }
+                            }
+                        }
+
+                        stage("Dev Test") {
+                            steps {
+                                container('milvus-test-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/singleDevTest.groovy"
+                                    }
+                                }
+                            }
+                        }
+
+                        stage ("Cleanup Dev") {
+                            steps {
+                                container('milvus-test-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/cleanupSingleDev.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        unsuccessful {
+                            container('milvus-test-env') {
+                                script {
+                                    load "${env.WORKSPACE}/ci/jenkinsfile/cleanupSingleDev.groovy"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+

ci/jenkins/jenkinsfile/build.groovy

+timeout(time: 60, unit: 'MINUTES') {
+    dir ("core") {
+        sh "git config --global user.email \"test@zilliz.com\""
+        sh "git config --global user.name \"test\""
+       //  sh "./build.sh -l"
+        withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
+            sh "export JFROG_ARTFACTORY_URL='${params.JFROG_ARTFACTORY_URL}' && export JFROG_USER_NAME='${USERNAME}' && export JFROG_PASSWORD='${PASSWORD}' && ./build.sh -t ${params.BUILD_TYPE} -j -u"
+        }
+    }
+}
+

ci/jenkins/jenkinsfile/cleanupSingleDev.groovy

+try {
+    def jobNames = env.JOB_NAME.split('/')
+    sh "helm del --purge ${env.PIPELIEN_NAME}-${env.BUILD_NUMBER}-single-gpu"
+} catch (exc) {
+    def helmResult = sh script: "helm status ${env.PIPELIEN_NAME}-${env.BUILD_NUMBER}-single-gpu", returnStatus: true
+    if (!helmResult) {
+        sh "helm del --purge ${env.PIPELIEN_NAME}-${env.BUILD_NUMBER}-single-gpu"
+    }
+    throw exc
+}

ci/jenkins/jenkinsfile/deploySingle2Dev.groovy

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

ci/jenkins/jenkinsfile/package.groovy

+timeout(time: 5, unit: 'MINUTES') {
+    dir ("core") {
+        if (fileExists('milvus')) {
+            sh "tar -zcvf ./${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz ./milvus"
+            withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'JFROG_USERNAME', passwordVariable: 'JFROG_PASSWORD')]) {
+                def uploadStatus = sh(returnStatus: true, script: "curl -u${JFROG_USERNAME}:${JFROG_PASSWORD} -T ./${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz ${params.JFROG_ARTFACTORY_URL}/milvus/package/${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz")
+                if (uploadStatus != 0) {
+                    error("\" ${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz \" upload to \" ${params.JFROG_ARTFACTORY_URL}/milvus/package/${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz \" failed!")
+                }
+            }
+        } else {
+            error("Milvus binary directory don't exists!")
+        }
+    }
+}

ci/jenkins/jenkinsfile/publishImages.groovy

+container('publish-images') {
+    timeout(time: 15, unit: 'MINUTES') {
+        dir ("docker/deploy/${OS_NAME}") {
+            def binaryPackage = "${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz"
+            withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'JFROG_USERNAME', passwordVariable: 'JFROG_PASSWORD')]) {
+                def downloadStatus = sh(returnStatus: true, script: "curl -u${JFROG_USERNAME}:${JFROG_PASSWORD} -O ${params.JFROG_ARTFACTORY_URL}/milvus/package/${binaryPackage}")
+
+                if (downloadStatus != 0) {
+                    error("\" Download \" ${params.JFROG_ARTFACTORY_URL}/milvus/package/${binaryPackage} \" failed!")
+                }
+            }
+            sh "tar zxvf ${binaryPackage}"
+            def imageName = "${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+
+            try {
+                def customImage = docker.build("${imageName}")
+                docker.withRegistry('https://registry.zilliz.com', "${params.DOCKER_CREDENTIALS_ID}") {
+                    customImage.push()
+                }
+            } catch (exc) {
+                throw exc
+            } finally {
+                sh "docker rmi ${imageName}"
+            }
+        } 
+    }
+}

ci/jenkins/jenkinsfile/singleDevTest.groovy

+timeout(time: 30, unit: 'MINUTES') {
+    dir ("tests/milvus_python_test") {
+        sh 'python3 -m pip install -r requirements.txt'
+        sh "pytest . --alluredir=\"test_out/dev/single/sqlite\" --level=1 --ip ${env.PIPELIEN_NAME}-${env.BUILD_NUMBER}-single-gpu-milvus-gpu-engine.milvus.svc.cluster.local"
+    }
+    // mysql database backend test
+    load "${env.WORKSPACE}/ci/jenkinsfile/cleanupSingleDev.groovy"
+
+    if (!fileExists('milvus-helm')) {
+        dir ("milvus-helm") {
+            checkout([$class: 'GitSCM', branches: [[name: "0.5.0"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_CREDENTIALS_ID}", url: "https://github.com/zilliz-ci-robot/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.5.0:refs/remotes/origin/0.5.0"]]])
+        }
+    }
+    dir ("milvus-helm") {
+        dir ("milvus-gpu") {
+            sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.PIPELIEN_NAME}-${env.BUILD_NUMBER}-single-gpu -f ci/db_backend/mysql_values.yaml --namespace milvus ."
+        }
+    }
+    dir ("tests/milvus_python_test") {
+        sh "pytest . --alluredir=\"test_out/dev/single/mysql\" --level=1 --ip ${env.PIPELIEN_NAME}-${env.BUILD_NUMBER}-single-gpu-milvus-gpu-engine.milvus.svc.cluster.local"
+    }
+}

ci/jenkins/pod/docker-pod.yaml

+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-images
+    image: registry.zilliz.com/library/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
+

ci/jenkins/pod/milvus-build-env-pod.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.5.0
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "32Gi"
+        cpu: "8.0"
+        nvidia.com/gpu: 1
+      requests:
+        memory: "16Gi"
+        cpu: "4.0"

ci/jenkins/pod/testEnvironment.yaml

+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test-env
+spec:
+  containers:
+  - name: milvus-test-env
+    image: registry.zilliz.com/milvus/milvus-test-env:v0.1
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: test-cluster-config
+

docker/deploy/ubuntu16.04/Dockerfile

+FROM nvidia/cuda:10.1-devel-ubuntu16.04
+
+ENV NVIDIA_DRIVER_CAPABILITIES compute,utility
+
+RUN rm -rf /etc/apt/sources.list.d/nvidia-ml.list && rm -rf /etc/apt/sources.list.d/cuda.list
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gfortran libsqlite3-dev libmysqlclient-dev libcurl4-openssl-dev python3 && \
+    apt-get remove --purge -y && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN ln -s /usr/lib/x86_64-linux-gnu/libmysqlclient.so /usr/lib/x86_64-linux-gnu/libmysqlclient_r.so
+
+COPY ./docker-entrypoint.sh /opt
+COPY ./milvus /opt/milvus
+ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/opt/milvus/lib"
+
+ENTRYPOINT [ "/opt/docker-entrypoint.sh" ]
+
+CMD [ "start" ]
+
+EXPOSE 19530
+

docker/deploy/ubuntu16.04/docker-entrypoint.sh

+#!/bin/bash
+
+set -e
+
+if [ "$1" == 'start' ]; then
+    cd /opt/milvus/scripts && ./start_server.sh
+fi
+
+exec "$@"
+