Jenkinsfile

def COLOR_MAP = ['SUCCESS': 'good', 'FAILURE': 'danger', 'UNSTABLE': 'danger', 'ABORTED': 'danger']

pipeline {
  options {
    parallelsAlwaysFailFast()
  }
  agent {
    kubernetes {
      slaveConnectTimeout 240000
      activeDeadlineSeconds 43200
      yamlFile 'jenkins/build-pod.yaml'
    }
  }
  stages {
    stage('Source and Environment Setup') {
      steps {
        script {
          // SGX Compile mode
          env.SGX_MODE = "HW"

          // Intel Attestation Service compile/runtime mode
          env.IAS_MODE = "DEV"

          // Network name, results in node names like nodeX.$NETWORK.mobilecoin.com
          env.NETWORK = "cd"

          // Owner of the Docker repos for pushing container images
          env.DOCKER_OWNER = "mobilecoin"

          // Container repository for the consensus service
          env.CONSENSUS_NODE_DOCKER_REPO = "node_hw"

          // Container repository for the mobilecoind service
          env.MOBILECOIND_DOCKER_REPO = "mobilecoind"

          // Container repository for the mobilecoind service
          env.BOOTSTRAP_TOOLS_DOCKER_REPO = "bootstrap-tools"

          // Set a dateformat string to be used as a docker tag
          env.TAG_VERSION = sh(returnStdout: true, script: 'date +"v%Y%m%d%H%m%S"').trim()
        }

        // Stash sources for later use on multiple Jenkins nodes
        stash name: 'sources', useDefaultExcludes: false, includes: '**', excludes: '**/.git, **/.git/**'
      }
    }
    stage('Cargo Build') {
      // Reusing the default agent/pod config
      steps {
        container('rust-builder-default') {
          // Show the environment for posterity
          sh 'printenv | sort'

          // Can be swapped out for specific build commands
          sh 'cargo build --release'

          // Build mobilecoind without default features
          sh 'cargo build --release -p mc-mobilecoind --no-default-features'

          // Staging area for binary packaging
          sh 'mkdir -p $WORKSPACE/ops/bin'

          // Copy relevant binaries to staging area
          sh '''
            for file in $(find $WORKSPACE/target/release -maxdepth 1 -type f "(" -name '*.so' -o -executable ")" -not -name '*_test' ); do
              cp -v ${file} $WORKSPACE/ops/bin/
            done
            ls -la $WORKSPACE/ops/bin
          '''

          // Copy the one-shot test-certificates into the staging area
          sh 'mkdir -p $WORKSPACE/ops/attest && cp -a $WORKSPACE/attest/test_certs $WORKSPACE/ops/attest/test_certs'

          // Make directories and populate sample_data
          dir('ops') {
            sh 'mkdir -p sample_data/ledger'
            sh 'mkdir -p sample_data/keys'
          }

          // Generate sample data
          dir('ops/sample_data') {
            // Generate lots of account keys to keep balances smaller
            sh '../bin/sample-keys --num 1000'
            sh '../bin/generate-sample-ledger -t 100'
            // Remove extra keys otherwise test_client will try all combinations
            sh 'for i in $(seq 6 999); do rm -rf keys/*_${i}.*; done'
            sh 'rm -f ./ledger/lock.mdb'
          }

          // Stash the ops data/binaries for usage in later steps
          stash name: 'ops_data', includes: 'ops/**'
        }
      }
    }
    stage('Build Images') {
      parallel {
        stage('Build Consensus Service container') {
          options {
            skipDefaultCheckout true
          }
          agent {
            kubernetes {
              slaveConnectTimeout 240000
              activeDeadlineSeconds 43200
              yamlFile 'jenkins/packaging-pod.yaml'
            }
          }
          steps {
            container('jnlp'){
              unstash name: 'sources'
              unstash name: 'ops_data'
            }
            container('kaniko'){
              sh '''
                  for i in 1 2 3; do
                    /kaniko/executor -f $WORKSPACE/ops/Dockerfile-consensus -c $WORKSPACE/ops \
                      --build-arg ORIGIN_DATA_DIR=sample_data \
                      --build-arg GIT_COMMIT=${GIT_COMMIT} \
                      --build-arg BRANCH=${NETWORK} \
                      --destination=$DOCKER_OWNER/$CONSENSUS_NODE_DOCKER_REPO:${NETWORK}-${TAG_VERSION} \
                      --destination=$DOCKER_OWNER/$CONSENSUS_NODE_DOCKER_REPO:${NETWORK}-latest \
                      --cleanup \
                      && break || sleep 5;
                  done
              '''
            }
          }
        }
        stage('Build mobilecoind container') {
          options {
            skipDefaultCheckout true
          }
          agent {
            kubernetes {
              slaveConnectTimeout 240000
              activeDeadlineSeconds 43200
              yamlFile 'jenkins/packaging-pod.yaml'
            }
          }
          steps {
            container('jnlp'){
              unstash name: 'sources'
              unstash name: 'ops_data'
            }
            container('kaniko'){
              sh '''
                  for i in 1 2 3; do
                    /kaniko/executor -f $WORKSPACE/ops/Dockerfile-mobilecoind -c $WORKSPACE/ops \
                      --build-arg ORIGIN_DATA_DIR=sample_data \
                      --build-arg GIT_COMMIT=${GIT_COMMIT} \
                      --build-arg BRANCH=${NETWORK} \
                      --destination=$DOCKER_OWNER/$MOBILECOIND_DOCKER_REPO:${NETWORK}-${TAG_VERSION} \
                      --destination=$DOCKER_OWNER/$MOBILECOIND_DOCKER_REPO:${NETWORK}-latest \
                      --cleanup \
                      && break || sleep 5;
                  done
              '''
            }
          }
        }
      }
    }
    stage('Deploy and Test') {
      options {
        lock resource: env.NETWORK
      }
      stages {
        stage('Deploy to k8s') {
          options {
            skipDefaultCheckout true
          }
          agent {
            kubernetes {
              slaveConnectTimeout 240000
              activeDeadlineSeconds 43200
              yamlFile 'jenkins/kubectl-pod.yaml'
            }
          }
          steps {
            container('jnlp') {
              unstash name: 'sources'
              dir('deploy') {
                sh './generate-manifests -n ${NETWORK} -t ${NETWORK}-${TAG_VERSION}'
              }
            }
            container('kubectl') {
              dir('deploy/build') {
                script {
                  sh(script: 'kubectl get po -n ${NETWORK}')

                  // Delete the consensus nodes, and {discovery, mobilecoind, ledger} nodes if any
                  sh(script: 'for i in 03* 04*; do kubectl delete --ignore-not-found -n ${NETWORK} -f ${i}; done')

                  // Update the 01* configs
                  sh(script: 'for i in 01*yaml; do kubectl apply -n ${NETWORK} -f ${i}; done')

                  // Launch the consensus node deployments
                  sh(script: 'for i in 03*yaml; do kubectl apply -n ${NETWORK} -f ${i}; done')

                  // Wait until the deployments have achieved an Available state.
                  sh(script: 'for i in 1 2 3 4 5; do kubectl wait --for=condition=Available deploy/node${i} -n ${NETWORK} --timeout=2500s; done')

                  // Deploy an internal mobilecoind to test with
                  sh(script: 'kubectl apply -n ${NETWORK} -f 04-mobilecoind.yaml')

                  // Wait for mobilecoind to achieve and Available state
                  sh(script: 'kubectl wait --for=condition=Available deploy/mobilecoind -n ${NETWORK} --timeout=480s')

                  sh(script: 'kubectl get po -n ${NETWORK}')
                }
              }
            }
          }
        }
        stage('Wallet Integration Test') {
          steps {
            container('rust-builder-default') {
              dir('mobilecoind/strategies') {
                sh 'pip3 install -r requirements.txt'
                sh '''
                  python3 -m grpc_tools.protoc -I$WORKSPACE/api/proto \
                    --python_out=. $WORKSPACE/api/proto/external.proto
                '''
                sh '''
                  python3 -m grpc_tools.protoc -I$WORKSPACE/api/proto \
                    --python_out=. $WORKSPACE/api/proto/blockchain.proto
                '''
                sh '''
                  python3 -m grpc_tools.protoc \
                    -I$WORKSPACE/mobilecoind/api/proto -I$WORKSPACE/api/proto -I$WORKSPACE/consensus/api/proto \
                    --python_out=. --grpc_python_out=. $WORKSPACE/mobilecoind/api/proto/mobilecoind_api.proto
                '''
                sh '''
                  python3 test_client.py \
                    --key-dir $WORKSPACE/ops/sample_data/keys \
                    --mobilecoind-host mobilecoind.${NETWORK}.svc.cluster.local\
                    --mobilecoind-port 3229
                '''
              }
            }
          }
        }
      }
    }
  }
  post {
    always {
      slackSend color: COLOR_MAP[currentBuild.currentResult],
        message: "*${currentBuild.currentResult}:*\nJob: ${env.JOB_NAME}\nCommit: ${env.GIT_COMMIT}\nDocker Tag: ${env.NETWORK}-${env.TAG_VERSION}\nBuild: ${env.BUILD_NUMBER}\nDuration: ${currentBuild.durationString}\nMore info at: ${env.BUILD_URL}"
    }
  }
}