JenkinsFile.Promote

#!/usr/bin/groovy

node {
  def root = pwd()
  def mvn = tool 'M3'
  def appBaseName = "bf-api"
  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) {
      env."${param.name}" = (param.type == "booleanParam") ? "${param.defaultvalue}".toBoolean() : "${param.defaultvalue}"
    }
  }

  def appVersion = "${env.PROMOTE_VERSION}"

  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 (appVersion == "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)
        appVersion = appName.trim().replace("${appBaseName}-", "")
        echo "Pulled version ${appVersion} from ${env.PHASE_TWO_PCF_SPACE}"
      } else {
        appName = "${appBaseName}-${appVersion}"
      }
      appName = appName.trim()

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

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

      // Generate Piazza API Key
      def piazza_api_key = ""
      def piazza_url = "https://piazza.${env.PROMOTE_DOMAIN}"
      withCredentials([[$class: 'StringBinding', credentialsId: "${env.BEACHFRONT_PIAZZA_AUTH_TEXT}", variable: 'TOKEN']]) {
        def keyCurl = sh(script: """curl -s ${piazza_url}/v2/key -u \"${TOKEN}:\"""", returnStdout: true)
        if (keyCurl.contains('Please request a new API')) {
          keyCurl = sh(script: """curl -X POST -s ${piazza_url}/v2/key -u \"${TOKEN}:\"""", returnStdout: true)
        }
        piazza_api_key = sh(script: """echo \"${keyCurl}\"|grep -oE '\\w{8}-\\w{4}-\\w{4}-\\w{4}-\\w{12}'""", returnStdout: true).trim()
        sh """
          if [ -z $piazza_api_key ]; then
          echo "No Piazza API key found"
          exit 1
          fi
        """
      }

      withCredentials([
        [$class: 'StringBinding', credentialsId: "${env.GEOAXIS_CLIENT_ID}", variable: "GEOAXIS_CLIENT_ID"],
        [$class: 'StringBinding', credentialsId: "${env.GEOAXIS_SECRET}", variable: "GEOAXIS_SECRET"],
        [$class: 'StringBinding', credentialsId: "${env.JKS_PASSPHRASE}", variable: "JKS_PASSPHRASE"],
        [$class: 'StringBinding', credentialsId: "${env.PZ_PASSPHRASE}", variable: "PZ_PASSPHRASE"]
      ]) {
        // Push the app
        sh "cf push ${appName} -f manifest.jenkins.yml --hostname ${appName} -b ${env.JAVA_BUILDPACK_NAME} -d ${env.PROMOTE_DOMAIN} --no-start --no-route"
        try {
          sh """
            cf set-env ${appName} SPACE ${env.PROMOTE_SPACE}
            cf set-env ${appName} DOMAIN ${env.PROMOTE_DOMAIN}
            cf set-env ${appName} PIAZZA_API_KEY ${piazza_api_key}
            cf set-env ${appName} OAUTH_AUTH_DOMAIN ${env.GEOAXIS_AUTH_DOMAIN}
            cf set-env ${appName} OAUTH_API_DOMAIN ${env.GEOAXIS_DOMAIN}
            cf set-env ${appName} OAUTH_LOGOUT_DOMAIN ${env.GEOAXIS_LOGOUT_DOMAIN}
            cf set-env ${appName} OAUTH_CLIENT_ID ${GEOAXIS_CLIENT_ID}
            cf set-env ${appName} OAUTH_SECRET ${GEOAXIS_SECRET}
            cf set-env ${appName} JKS_FILE piazza.jks
            cf set-env ${appName} GEOAXIS_JWT_CERT GEOAXIS_JWT_CERT.pem
            cf set-env ${appName} JKS_PASSPHRASE ${JKS_PASSPHRASE}
            cf set-env ${appName} PZ_PASSPHRASE ${PZ_PASSPHRASE}
            cf set-env ${appName} exit.on.geoserver.provision.failure ${env.EXIT_ON_GEOSERVER_PROVISION_FAILURE}
            cf set-env ${appName} geoserver.workspace.name ${env.GEOSERVER_WORKSPACE_NAME}
            cf set-env ${appName} geoserver.datastore.name ${env.GEOSERVER_DATASTORE_NAME}
            cf set-env ${appName} geoserver.layer.name ${env.GEOSERVER_LAYER_NAME}
            cf set-env ${appName} geoserver.layergroup.name ${env.GEOSERVER_LAYERGROUP_NAME}
            cf set-env ${appName} geoserver.style.name ${env.GEOSERVER_STYLE_NAME}
          """
          if (env.USE_GEOSERVER_PKI_AUTH.toBoolean()) {
            sh "cf set-env ${appName} SPRING_PROFILES_ACTIVE cloud,pki-geoserver-auth"
          } else {
            sh "cf set-env ${appName} SPRING_PROFILES_ACTIVE cloud,basic-geoserver-auth"
          }
          sh "cf start ${appName}"
        } 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}.")
        }
      }

      // Assign Routes
      def legacyAppNames = sh(script: "cf routes | grep \"${appBaseName}\" | awk '{print \$4}'", returnStdout: true)
      sh "cf map-route ${appName} ${env.PROMOTE_DOMAIN} --hostname ${appBaseName}"
      
      // Assign Policies
      try {
        def iaBroker = sh(script: "cf routes | grep \"bf-ia-broker\" | awk '{print \$4}' | head -n1", returnStdout: true).trim()
        sh "cf add-network-policy ${appName} --destination-app ${iaBroker} --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} ${env.PROMOTE_DOMAIN} --hostname ${appBaseName}"
          sh "cf delete -f ${legacyAppName} -r"
        }
      }
    }
  }
}