JenkinsFile

#!/usr/bin/groovy

node {
  def appName = "bf-ia-broker"
  def root = pwd()
  def mvn = tool 'M3'
  def golangTool = tool 'golang_1.9'
  def zapHome = tool 'ZAProxy_v2_5_0'
  def nodejs = tool 'NodeJS_6'
  def fullAppName = '' // Fill during Setup stage
  def appVersion = '' // Fill during Setup stage

  stage("Config") {
    // clone the configuration repository and copy the current configuration
    def configDir = "${root}/configuration"
    def configFile = "${root}/config.json"
    dir(configDir) {
      git url: "${env.CONFIGURATION_URL}", credentialsId: "${env.CONFIGURATION_CREDS}"
      sh "mv ${configDir}/${ENVIRONMENT}-config.json ${configFile}"
      deleteDir()
    }
    // read the current configuration
    def configJson = readJSON file: "${configFile}"
    for (param in configJson.credparams + configJson.jobparams) {
      env."${param.name}" = (param.type == "booleanParam") ? "${param.defaultvalue}".toBoolean() : "${param.defaultvalue}"
    }
  }

  def printLogsFailsafe = {String logAppName ->
    try {
      echo "Printing recent logs for ${logAppName}"
      sh "cf logs --recent ${logAppName}"
    } catch (Exception e) {
      echo "Printing logs failed: ${e}"
    }
  }

  // Deploy and integration test function abstractions

  def deployPhase = { String pcfSpace, String pcfDomain, String deployAppName ->
    if(!fileExists('.cf')) {
      sh "mkdir -p .cf"
    }
    withEnv(["CF_HOME=.cf"]) {
      withCredentials([[$class: 'UsernamePasswordMultiBinding', credentialsId: "${env.PCF_CREDS}", usernameVariable: "CFUSER", passwordVariable: "CFPASS"]]) {
        def tidesUrl = "http://bf-tideprediction-${pcfSpace}.apps.internal:8080/tides"
        sh """
          cf api ${env.PCF_API_ENDPOINT}
          cf auth ${CFUSER} ${CFPASS}
          cf target -o ${env.PCF_ORG} -s ${pcfSpace}
          cf push ${deployAppName} -f manifest.jenkins.yml --hostname ${deployAppName} -d ${pcfDomain} -c 'sleep 5m' --health-check-type none --no-route
        """
        try {
          sh """
            cf set-env ${deployAppName} SPACE ${pcfSpace}
            cf set-env ${deployAppName} DOMAIN ${pcfDomain}
            cf set-env ${deployAppName} LANDSAT_HOST ${env.LANDSAT_HOST}
            cf set-env ${deployAppName} PL_API_URL ${env.PL_API_URL}
            cf set-env ${deployAppName} SENTINEL_HOST ${env.SENTINEL_HOST}
            cf set-env ${deployAppName} BF_TIDE_PREDICTION_URL ${tidesUrl}
            cf set-env ${deployAppName} LANDSAT_INDEX_SCENES_URL ${env.LANDSAT_INDEX_SCENES_URL}
            cf set-env ${deployAppName} LANDSAT_INGEST_FREQUENCY ${env.LANDSAT_INGEST_FREQUENCY}
          """

          echo "Running database migration"
          sh "cf restage ${deployAppName}"
          sh "cf run-task ${deployAppName} './bf-ia-broker.bin migrate'"

          echo "Migration successful, starting app"
          sh "cf push ${deployAppName} -f manifest.jenkins.yml --hostname ${deployAppName} -d ${pcfDomain} --health-check-type http --no-route"
        } catch (Exception e) {
          printLogsFailsafe deployAppName
          sh "cf delete ${deployAppName} -f"
          error("Error during application start. Deleting ${deployAppName} and failing the build.")
        }
      }
    }

    if(!env.SKIP_SCANS.toBoolean()) {
      withCredentials([[$class: 'StringBinding', credentialsId: "${env.THREADFIX_API_KEY}", variable: "THREADFIX_KEY"]]) {
        sh """
          mkdir -p ${root}/zap-out
          ${zapHome}/zap.sh -cmd -quickout ${root}/zap-out/zap.xml -quickurl https://${deployAppName}.${pcfDomain}
          cat ${root}/zap-out/zap.xml
          /bin/curl -v --insecure -H 'Accept: application/json' -X POST --form file=@${root}/zap-out/zap.xml ${env.THREADFIX_URL}/rest/latest/applications/${THREADFIX_ID}/upload?apiKey=${THREADFIX_KEY}
        """
      }
    }

    withEnv(["CF_HOME=.cf"]) {
      withCredentials([[$class: 'UsernamePasswordMultiBinding', credentialsId: "${env.PCF_CREDS}", usernameVariable: "CFUSER", passwordVariable: "CFPASS"]]) {
        sh """
          cf api ${env.PCF_API_ENDPOINT}
          cf auth ${CFUSER} ${CFPASS}
          cf target -o ${env.PCF_ORG} -s ${pcfSpace}
        """
        
        // Define routes
        def legacyAppNames = sh(script: """cf routes | grep \"${appName}\" | awk '{print \$4}'""", returnStdout: true)
        sh "cf map-route ${deployAppName} apps.internal --hostname bf-ia-broker-${pcfSpace}"
        
        // Define policies
        try {
          def bfApi = sh(script: "cf routes | grep \"bf-api\" | awk '{print \$4}' | head -n1", returnStdout: true).trim()
          sh "cf add-network-policy ${bfApi} --destination-app ${deployAppName} --protocol tcp --port 8080"
          def tidePrediction = sh(script: "cf routes | grep \"bf-tideprediction\" | awk '{print \$4}' | head -n1", returnStdout: true).trim()
          sh "cf add-network-policy ${deployAppName} --destination-app ${tidePrediction} --protocol tcp --port 8080"
        } catch (Exception ex) {
          echo "Could not establish network policies. The network policy tool should be run post-build to ensure functionality."
        }
        
        // Remove legacy applications
        for (Object legacyApp : legacyAppNames.trim().tokenize(',')) {
          def legacyAppName = legacyApp.toString().trim()
          if(legacyAppName != appName && legacyAppName != deployAppName) {
            sh "cf unmap-route ${legacyAppName} apps.internal --hostname bf-ia-broker-${pcfSpace}"
            sh "cf delete -f ${legacyAppName} -r"
          }
        }
      }
    }
  }

  def integrationTestPhase = { String pcfSpace, String pcfDomain ->
    if(!fileExists("integration-tests")) {
      sh "mkdir -p integration-tests"
    }
    // Clone Test Repository
    withCredentials([file(credentialsId: "${POSTMAN_SECRET_FILE}", variable: 'POSTMAN_FILE')]) {
      withEnv([
      "PATH+=${root}/integration-tests/node_modules/newman/bin:${nodejs}/bin",
      "PCF_SPACE=${pcfSpace}", "HOME=${WORKSPACE}"
      ]) {
        dir ("integration-tests") {
          if(env.INTEGRATION_GITLAB_CREDS) {
            git url: "${env.INTEGRATION_GIT_URL}", branch: "${env.INTEGRATION_GIT_BRANCH}", credentialsId: "${env.INTEGRATION_GITLAB_CREDS}"
          } else {
            git url: "${env.INTEGRATION_GIT_URL}", branch: "${env.INTEGRATION_GIT_BRANCH}"
          }
          sh "npm install newman@3"
          sh "/bin/bash ci/beachfront.sh"
        }
      }
    }
  }

  // Actual pipeline stages

  stage("Setup") {
    deleteDir()
    if(env.USE_GIT_CREDS.toBoolean()) {
      git url: "${env.GIT_URL}", branch: "${env.GIT_BRANCH}", credentialsId: "${env.GITLAB_CREDS}"
    } else {
      git url: "${env.GIT_URL}", branch: "${env.GIT_BRANCH}"
    }
    withEnv([
    "PATH+=${golangTool}/bin:${root}/gopath/bin",
    "GOROOT=${golangTool}",
    "GOPATH=${root}/gopath"
    ]) {
      sh """
        mkdir -p ${root}/gopath/bin ${root}/gopath/pkg ${root}/gopath/src
        go version
      """
    }

    appVersion = sh(script: """git describe --long --tags --always | sed 's/\\./-/'g""", returnStdout: true)
    appVersion = appVersion.trim()
    fullAppName = "${appName}-${appVersion}"
  }

  stage("Security Scan Pass/Fail") {
    echo "No-op"
  }


  stage("Archive") {
    def archiveName = "${appName}.tar.gz"
    withEnv([
    "PATH+=${golangTool}/bin:${root}/gopath/bin",
    "GOROOT=${golangTool}",
    "GOPATH=${root}/gopath"
    ]) {
      sh """
        mkdir -p ${GOPATH}/src/github.com/venicegeo/bf-ia-broker
        find . -maxdepth 1 -mindepth 1 -not -name gopath -exec cp -R '{}' gopath/src/github.com/venicegeo/bf-ia-broker/ \\;
        cd "\$GOPATH/src/github.com/venicegeo/bf-ia-broker"
        go install github.com/venicegeo/bf-ia-broker/cmd/bf-ia-broker
        cd landsat_planet
        go test -v -coverprofile=${root}/landsat_planet.cov
        cd ..
        cd planet
        go test -v -coverprofile=${root}/planet.cov
        cd ..
        cd tides
        go test -v -coverprofile=${root}/tides.cov
        cd ..
        cd util
        go test -v -coverprofile=${root}/util.cov
        cd ..
        cd ${root}
        go tool cover -func=landsat_planet.cov -o landsat_planet.cov.txt
        go tool cover -func=planet.cov -o planet.cov.txt
        go tool cover -func=tides.cov -o tides.cov.txt
        go tool cover -func=util.cov -o util.cov.txt
        cp \$GOPATH/bin/bf-ia-broker ${root}/bf-ia-broker.bin
        tar -cvzf ${archiveName} bf-ia-broker.bin *.cov *.cov.txt glide.lock glide.yaml manifest.jenkins.yml
      """
      def getDependencyStatus = sh(script: """mvn --quiet --settings ~/.m2/settings.xml dependency:get -Dmaven.repo.local="${root}/.m2/repository" -DrepositoryId=nexus -DartifactId=bf-ia-broker -Dversion=${appVersion} -DgroupId="org.venice.beachfront" -Dpackaging=tar.gz -DremoteRepositories="nexus::default::${env.ARTIFACT_STORAGE_DEPLOY_URL}" >> /dev/null 2>&1""", returnStatus: true)
      if(getDependencyStatus == 0) {
        echo "Artifact version ${appVersion} exists in Nexus, nothing to do"
      } else {
        sh """
          mvn -X --settings ~/.m2/settings.xml deploy:deploy-file -Dfile=${archiveName} -DrepositoryId=nexus	-Durl="${env.ARTIFACT_STORAGE_DEPLOY_URL}" -DgroupId="org.venice.beachfront" -DgeneratePom=false -Dpackaging=tar.gz -Dmaven.repo.local="${root}/.m2/repository" -DartifactId=bf-ia-broker -Dversion=${appVersion}
        """
      }
    }
  }

  stage("Phase One Deploy") {
    deployPhase(env.PHASE_ONE_PCF_SPACE, env.PHASE_ONE_PCF_DOMAIN, fullAppName)
  }

  if(!env.SKIP_INTEGRATION_TESTS.toBoolean()) {
    stage("Phase One Integration Tests") {
      integrationTestPhase(env.PHASE_ONE_PCF_SPACE, env.PHASE_ONE_PCF_DOMAIN)
    }
  }

  if(env.DEPLOY_PHASE_TWO.toBoolean()) {
    stage("Phase Two Deploy") {
      deployPhase(env.PHASE_TWO_PCF_SPACE, env.PHASE_TWO_PCF_DOMAIN, fullAppName)
    }
  }
}