Jenkinsfile-Integration

/**
 * Helper function for looping over Map object
 *
 */
@NonCPS
def mapToList(depmap) {
    def dlist = []
    for (def entry in depmap) {
        dlist.add(new java.util.AbstractMap.SimpleImmutableEntry(entry.key, entry.value))
    }
    dlist
}

/**
 * Functions to validate image
 *
 */
def helmLint(Map args) {
    // lint helm chart
    sh "/usr/local/bin/helm lint ${args.chart_dir} --set build=${args.commit_id},image.tag=${args.tag},image.app.repository=${args.appRepo},image.proxy.repository=${args.proxyRepo},image.app.tag=${args.tag},image.proxy.tag=${args.tag},version=${args.version},config.directory=config/${args.namespace},logging.env.cloud_id=${ELASTIC_ID},logging.env.username=${ELASTIC_USER},logging.env.password=${ELASTIC_PASSWORD},ingress.type=${INGRESS_VERSION},context=${args.context},ingress.entry=${args.entry},ingress.external=${args.external}"
}

/**
 * Functions to deploy image
 *
 */
def helmDeploy(Map args) {
    try {

        // Configure helm client and confirm tiller process is installed

        if (args.dry_run) {
            println "Running dry-run deployment"

            sh "/usr/local/bin/helm install --dry-run --debug ${args.name} ${args.chart_dir} --set build=${args.commit_id},image.tag=${args.tag},image.app.repository=${args.appRepo},image.proxy.repository=${args.proxyRepo},image.app.tag=${args.tag},image.proxy.tag=${args.tag},version=${args.version},config.directory=config/${args.namespace},logging.env.cloud_id=${ELASTIC_ID},logging.env.username=${ELASTIC_USER},logging.env.password=${ELASTIC_PASSWORD},ingress.type=${INGRESS_VERSION},context=${args.context},ingress.entry=${args.entry},ingress.external=${args.external} --namespace=${args.namespace}"
        } else {
            println "Running deployment"

            sh "/usr/local/bin/helm upgrade --install ${args.name} ${args.chart_dir} --set build=${args.commit_id},image.tag=${args.tag},image.app.repository=${args.appRepo},image.proxy.repository=${args.proxyRepo},image.app.tag=${args.tag},image.proxy.tag=${args.tag},version=${args.version},config.directory=config/${args.namespace},logging.env.cloud_id=${ELASTIC_ID},logging.env.username=${ELASTIC_USER},logging.env.password=${ELASTIC_PASSWORD},ingress.type=${INGRESS_VERSION},context=${args.context},ingress.entry=${args.entry},ingress.external=${args.external} --namespace=${args.namespace}"

            echo "Application ${args.name} successfully deployed. Use helm status ${args.name} to check."
        }

        notifyBuild('SUCCESS', null, null, "Image deployed to `${args.namespace}` Kubernetes successfully.")
    }

    catch(exception) {

        echo "${exception}"

        // Slack notification failure.
        notifyBuild('FAILURE', null, null, "Error in pushing image to `${args.namespace}` Kubernetes - Retrying.", args.notify, args.slack_channel)

        println "Error on Upgrade / Install"
    }
}

/**
 * Track Git logs
 *
 */
def showChangeLogs() {

    def authors       = []
    def changeLogSets = currentBuild.rawBuild.changeSets

    for (int i = 0; i < changeLogSets.size(); i++) {

        def entries = changeLogSets[i].items
        for (int j = 0; j < entries.length; j++) {

            def author = "${entries[j].author}"
            def email  = entries[j].author.getProperty(hudson.tasks.Mailer.UserProperty.class).getAddress()

            authors.push("${author}:${email}")
        }
    }

    return authors.unique();
}

/**
 * TODO: Track Container Deployment Status
 *
 */
def getDeploymentStatus(commitId, environment) {
    sh "sleep 10s"

    def status
    def sleep   = ['ContainerCreating', 'Pending', 'Succeeded']
    def success = ['Running']
    def failure = ['CrashLoopBackOff', 'Terminating', 'Error']

    sh "kubectl get pods -l build=${commitId} --namespace=${environment} --sort-by=.status.startTime"

    def deploymentVerify = sh (script: "kubectl get pods -l build=${commitId} --namespace=${environment} --sort-by=.status.startTime | awk 'NR==2{print \$3}'", returnStdout: true).trim()
    def containerCount   = sh (script: "kubectl get pods -l build=${commitId} --namespace=${environment} --sort-by=.status.startTime | awk 'NR==2{print \$4}'", returnStdout: true).trim().toInteger()

    echo "Deployment Status: ${deploymentVerify}"
    echo "Container Restart Count: ${containerCount}"

    if (sleep.contains(deploymentVerify)) {
        return getDeploymentStatus(commitId, environment)
    }

    if (success.contains(deploymentVerify)) {
        if (containerCount == 0) {
            return true
        } else {
            return false
        }
    }

    if (failure.contains(deploymentVerify)) {
        return false
    }
}

def assertUniqueTag(Map args) {

    withAWS(credentials: args.credentials) {

        try {
            sh "if echo \$(aws ecr describe-images --region ${env.AWS_REGION} --repository-name ${args.repo} --filter tagStatus=TAGGED --query 'imageDetails[*].imageTags[*]' --output text) | grep --line-regexp '.*[[:space:]]${args.tag}[[:space:]].*'; then exit 1; fi"
        }
        catch (exception) {
            sh "echo ${exception}"
            error "Tag ${args.tag} already found in repo ${args.repo}. Will not overwrite..."
        }
    }
}

/**
 * Jenkins pipeline stages.
 *
 * A list of stages available in this pipeline Jenkins file will be executed
 * sequentially. The name of this file should be matching with Pipeline block of
 * Jenkins configuration.
 *
 */
node {

    /**
     * Version details for tagging the image, refer build-scripts/versioning-image
     *
     * @final string tag
     *   Push image to Integration.
     * @final string pullRepoTag
     *   Pull image from Integration.
     *
     */
    def tag
    def pullRepoTag

    /**
     * Define script variables.
     *
     */
    def notify
    def slackChannel = "#general"
    // Docker image
    def app
    def proxy
    // Config.json file
    def config
    // Component specific variables builds
    def component = "insights-ui"
    def cluster = "delivery"
    def environment = "integration"
    def chartDirectory
    // Config File from S3
    def configFile
    // Git Credentials
    def gitCredentials = "impinger-cicd-github"
    // Helm Repository
    def helmRepo = "git@github.com:InterMx/intermx-cicd-helm.git"
    // Helm Branch
    def helmBranch = "delivery"
    // S3 Config Bucket
    def configBucket = "${AWS_BUCKET_NAME}"
    // AWS Credentials
    def awsCredentials = "intermx-impinger-credentials"
    // ECR Repository for application
    def appEcrRepoName = "intermx-insights-ui"
    // ECR Repository for proxy
    def proxyEcrRepoName = "intermx-insights-proxy"
    // ECR Repository
    def ecrRepo     = "${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com"
    // ECR FQDN
    def ecrAppRepo = "${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/${appEcrRepoName}"
    def ecrProxyRepo = "${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/${proxyEcrRepoName}"
    // ECR Repository Endpoint
    def ecrEndpoint = "https://${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com"
    // ECR Credentials
    def ecrCredentials = "ecr:us-east-1:${awsCredentials}"
    // Host to listen to for routing
    def endpointHost = "gisdev.geopath.io"
    // Context name to avoid collisions
    def context = "ui"
    // Helm deployment name to avoid collisions
    def deploymentName = "intermx-insights-ui"
    // Entry point for Traefik
    def entryPoint = "https"
    // Default externality for Traefik
    def external = "true"
    // Git commit message
    def commitMessage
    def commitId
    def deployment

    try {

        /**
         * Cloning the repository to workspace to build image.
         *
         */
        stage ('Clone Repository') {

            checkout scm

            def (origin, branch) = scm.branches[0].name.tokenize('/')

            commitMessage = sh (script: 'git log --oneline -1 ${GIT_COMMIT}', returnStdout: true).trim().substring(8)
            commitId      = sh (script: 'git log -1 --format=%H', returnStdout: true).trim() // %h, for short hash
            notify        = showChangeLogs()

            // Slack notification in progress.
            notifyBuild('STARTED', branch, commitMessage)
        }

        /**
         * Get dependencies for Kubernetes Deploy (Integration).
         *
         */
        stage('Get Dependencies for Integration') {

            // Get helm charts from git repo
            dir('helm') {
                git url: helmRepo, credentialsId: gitCredentials, branch: helmBranch
            }

            // Download config.json from S3 into the insights-ui/config helm repo
            final s3ConfigPath = "${cluster}/${environment}/${component}"

            chartDirectory = "helm/${component}"
            configFile     = "${chartDirectory}/config/${environment}/config.json"

            dir("${chartDirectory}/config/${environment}") {
                withAWS(credentials:awsCredentials) {
                    s3Download(file: 'config.json', bucket: configBucket, path: "${s3ConfigPath}/config.json", force: true)
                    s3Download(file: 'filebeat.yaml', bucket: configBucket, path: "${s3ConfigPath}/filebeat.yaml", force: true)
                    s3Download(file: 'ilm_policy.json', bucket: configBucket, path: "${s3ConfigPath}/ilm_policy.json", force: true)
                }
            }
        }

        /**
         * Environment variables for Kubernetes.
         *
         */
        stage('Build Kubernetes Env Variables for Integration From Config') {

            config = readJSON file: "${configFile}"

            for (entry in mapToList(config)) {
                dir("${chartDirectory}/config/${environment}"){
                    writeFile file: "${entry.key}", text: "${entry.value}"
                }
            }
        }

        /**
         * Version Automation.
         *
         */
        stage('Update Version') {

            def json          = readJSON file: "package.json"
            def image_version = json.devops['image-version']

            tag         = "v${image_version}_integration"
            pullRepoTag = "v${image_version}_development"
        }

        /**
         * Add Required Tools to Run NodeJS.
         *
         */
        stage('Add NodeJS Tool') {
            env.NODEJS_HOME = "${tool 'node'}"
            env.PATH        = "${env.NODEJS_HOME}/bin:${env.PATH}"

            sh "mv common.package.json package.json && mv common.package-lock.json package-lock.json"
            sh "npm install"
        }

        /**
         * Running BrowserStack Test.
         *
         */
        stage('BrowserStack Test') {
            // Disabled browserStack as a temp fix, the keys are expired.
            // sh "./BrowserStackLocal --key ${BROWSERSTACK_KEY} --daemon start"
            // sh "./node_modules/.bin/protractor browser.test.js"
        }

        /**
         * Set Unique Tag.
         *
         */
        stage ('Assert Unique Tag') {

            assertUniqueTag(
                credentials : awsCredentials,
                repo        : appEcrRepoName,
                tag         : tag
            )
            assertUniqueTag(
                credentials : awsCredentials,
                repo        : proxyEcrRepoName,
                tag         : tag
            )
        }

        /**
         * Pull the image from Integration, chnage tag and push the same to AWS ECR Integration repo.
         *
         */
        stage('Pull and Push the Image to ECR Repo') {

            docker.withRegistry("${ecrEndpoint}", "${ecrCredentials}") {

                docker.image("${appEcrRepoName}:${pullRepoTag}").pull()
                docker.image("${proxyEcrRepoName}:${pullRepoTag}").pull()

                docker.image("${ecrRepo}/${appEcrRepoName}:${pullRepoTag}").push("${tag}")
                docker.image("${ecrRepo}/${proxyEcrRepoName}:${pullRepoTag}").push("${tag}")
            }
        }

        /**
         * Deploy Image to Kubernetes using Helm.
         *
         */
        stage('Deploy image to Integration Environment') {
            entryPoint = "https"
            external = "true"

            // Run helm chart linter
            helmLint(
                chart_dir     : chartDirectory,
                chart_version : environment,
                appRepo       : ecrAppRepo,
                proxyRepo     : ecrProxyRepo,
                tag           : tag,
                name          : deploymentName,
                version       : environment,
                namespace     : environment,
                context       : context,
                entry         : entryPoint,
                external      : external,
                commit_id     : commitId
            )

            // Deploy using Helm chart
            helmDeploy(
                dry_run       : false,
                name          : deploymentName,
                appRepo       : ecrAppRepo,
                proxyRepo     : ecrProxyRepo,
                chart_dir     : chartDirectory,
                tag           : tag,
                version       : environment,
                namespace     : environment,
                notify        : notify,
                slack_channel : slackChannel,
                context       : context,
                entry         : entryPoint,
                external      : external,
                git_cred      : gitCredentials,
                commit_id     : commitId
            )
        }

        /**
         * Track Container Status for Integration
         *
         */
        stage('Track Container Status for Integration') {
            // deployment = getDeploymentStatus(commitId, environment);

            // Slack notification success.
            /* if (deployment) {
                notifyBuild('SUCCESS', null, null, "Image deployed to `${environment}` Kubernetes successfully.")
            } else {
                notifyBuild('FAILURE', null, null, "Error in creating container, please check the code for ${environment}", notify, slackChannel)

                error ("Error in creating container, please check the code for ${environment}")
            } */

            // notifyBuild('SUCCESS', null, null, "Image deployed to `${environment}` Kubernetes successfully.")
        }
    }

    catch(exception) {

        echo "${exception}"

        // Slack notification failure.
        notifyBuild('FAILURE', null, null, 'Exception found in Jenkins.', notify, slackChannel)
    }

    finally {

        // Clean up the workspace after finish the job.
        deleteDir()
    }
}


/**
 * Sending notifications to Slack channel.
 *
 */
def notifyBuild(buildStatus = 'FAILURE', branch = null, commitMessage = null, message = null, notify = null, channel = null) {

    // Default values
    def summary
    def alert   = false
    def org     = "${ORGANIZATION}"
    def baseURL = "${SLACK_BASE_URL}"

    org = org.toUpperCase()

    if (buildStatus == 'STARTED') {
        color = 'YELLOW'
        colorCode = '#FFFF00'
        summary = "${buildStatus}: ${org} - Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' is currently working on branch '${branch}' with a message: '${commitMessage}'"
    } else if (buildStatus == 'SUCCESS') {
        color = 'GREEN'
        colorCode = '#00FF00'
        summary = "${buildStatus}: ${org} - Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' | Message: ${message}"
    } else {
        color = 'RED'
        colorCode = '#FF0000'
        summary = "${buildStatus}: ${org} - Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' | Error: ${message}"
        alert = true
    }

    // Send notifications to Slack.
    slackSend (baseUrl: baseURL, color: colorCode, message: summary)

    if (alert) {

        for(int i = 0; i < notify.size(); i++) {
            def notice = notify[i].split(":")
            def author = notice[0]
            def email  = notice[1]
            def domain = email.split("@")[1]

            if (domain && domain == 'intermx.com') {

                emailext (
                    to: "${email}",
                    subject: "${buildStatus}: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
                    body: """
                      <html>
                        <body>
                          <p>Hi ${author},</p>
                          <br>
                          <p>The build job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' failed to complete.</p>
                          <p>The following error was reported:</p>
                          <br>
                          <p>${message}</p>
                          <br>
                          <p>Please review the error at <a href=\"${env.BUILD_URL}console\">${env.BUILD_URL}console</a> and resolve the issue causing the failure so that releases can continue.</p>
                        </body>
                      </html>
                    """
                )
            }
        }

        slackSend (baseUrl: baseURL, channel: "${channel}", color: colorCode, message: summary)
    }
}