JenkinsFile.Promote

#!/usr/bin/groovy

node {
  def root = pwd()
  def mvn = tool 'M3'
  def appvers
  def appBaseName = "bf-ia-broker"
  def tidesUrl
  def appName

  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}/${env.ENVIRONMENT}-config.json ${configFile}"
      deleteDir()
    }
    // read the current configuration
    def configJson = readJSON file: "${configFile}"
    for (param in configJson.credparams + configJson.jobparams) {
      def paramValueString = (param.defaultvalue != null) ? param.defaultvalue.toString() : ""
      env."${param.name}" = (param.type == "booleanParam") ? paramValueString.toBoolean() : paramValueString
    }
    appvers = "${env.PROMOTE_VERSION}"
    tidesUrl = "http://bf-tideprediction-${env.PROMOTE_SPACE}.apps.internal:8080/tides"
  }

  if(!fileExists('.cf')) {
    sh "mkdir -p .cf"
  }
  withEnv(["CF_HOME=.cf"]) {

    def authenticatePcf = { ->
      withCredentials([[$class: 'UsernamePasswordMultiBinding', credentialsId: "${env.PCF_CREDS}", usernameVariable: "CFUSER", passwordVariable: "CFPASS"]]) {
        sh """
          cf api ${env.PCF_API_ENDPOINT}
          cf auth ${CFUSER} ${CFPASS}
        """
      }
    }

  stage('Pull Artifact') {
    authenticatePcf()
    if (appvers == "latest") {
      // Get the latest version from Phase 2
      echo "No version specified. Fetching the latest version from ${env.PHASE_TWO_PCF_SPACE}"
      sh "cf target -o ${env.PCF_ORG} -s ${env.PHASE_TWO_PCF_SPACE}"
      appName = sh(script: "cf apps | grep '${appBaseName}' | cut -f1 -d ' ' ", returnStdout: true)
      appvers = appName.trim().replace("${appBaseName}-", "")
      echo "Pulled version ${appvers} from ${env.PHASE_TWO_PCF_SPACE}"
    } else {
      appName = "${appBaseName}-${appvers}"
    }
    appName = appName.trim()

    // Get the Artifact from Nexus
    def getDependencyStatus = sh(script: """mvn --quiet --settings ~/.m2/settings.xml dependency:get \
      -Dmaven.repo.local="${root}/.m2/repository" \
      -DrepositoryId=nexus \
      -DartifactId=${appBaseName} \
      -Dversion=${appvers} \
      -DgroupId="org.venice.beachfront" \
      -Dpackaging=tar.gz \
      -Ddest=${root}/${appBaseName}.tar.gz \
      -DremoteRepositories="nexus::default::${env.ARTIFACT_STORAGE_DEPLOY_URL}" \
      >> /dev/null 2>&1 \
      """, returnStatus: true)
    echo "dependency status = ${getDependencyStatus}"
    if (getDependencyStatus == 0) {
      //Unzip
      sh "tar -xvzf ${root}/${appBaseName}.tar.gz"
    } else {
      error("The artifact version ${appvers} could not be found in Nexus.")
    }
  }

  stage ('Deploy') {
    authenticatePcf()
    sh "cf target -o ${env.PCF_ORG} -s ${env.PROMOTE_SPACE}"

    // Push the app
    sh "cf push ${appName} -f manifest.jenkins.yml --hostname ${appName} -d ${env.PROMOTE_DOMAIN} -c 'sleep 5m' --no-route --health-check-type none"
    try {
        sh "cf set-env ${appName} SPACE ${env.PROMOTE_SPACE}"
        sh "cf set-env ${appName} DOMAIN ${env.PROMOTE_DOMAIN}"
        sh "cf set-env ${appName} LANDSAT_HOST ${env.LANDSAT_HOST}"
        sh "cf set-env ${appName} PL_API_URL ${env.PL_API_URL}"
        sh "cf set-env ${appName} SENTINEL_HOST ${env.SENTINEL_HOST}"
        sh "cf set-env ${appName} BF_TIDE_PREDICTION_URL ${tidesUrl}"
        sh "cf set-env ${appName} LANDSAT_INDEX_SCENES_URL ${env.LANDSAT_INDEX_SCENES_URL}"
        sh "cf set-env ${appName} LANDSAT_INGEST_FREQUENCY ${env.LANDSAT_INGEST_FREQUENCY}"

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

        echo "Migration successful, starting app"
        sh "cf push ${appName} -f manifest.jenkins.yml --hostname ${appName} -d ${env.PROMOTE_DOMAIN} --health-check-type http --no-route"
      } catch (Exception e) {
        try {
          sh "cf logs --recent ${appName}"
        } catch (Exception ex) {
          echo "Printing logs failed: ${ex}"
        }
        sh "cf delete ${appName} -f -r"
        error("Error during application start. Deleting ${appName} and failing the build.")
      }

      // Assign Routes
      def legacyAppNames = sh(script: "cf routes | grep \"${appBaseName}\" | awk '{print \$4}'", returnStdout: true)
      sh "cf map-route ${appName} apps.internal --hostname ${appBaseName}-${env.PROMOTE_SPACE}"

      // Assign 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 ${appName} --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 ${appName} --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."
      }

      // Delete old Routes
      for (Object legacyApp : legacyAppNames.trim().tokenize(',')) {
        def legacyAppName = legacyApp.toString().trim()
        if (legacyAppName != appName) {
          sh "cf unmap-route ${legacyAppName} apps.internal --hostname ${appBaseName}-${env.PROMOTE_SPACE}"
          sh "cf delete -f ${legacyAppName} -r"
        }
      }
    }
  }
}