deploy_seed_nodes.jf

#!groovy

def TERRAFORM_EXE_PATH = "terraform"
pipeline {
    environment {
        AWS_REGION = "us-east-1"
        CONFIG_BUCKET_NAME = "wizards-cassandra-config"
        COMMON_BUCKET_KEY = "${params.environment}/cassandra/${name}"
        STATE_BUCKET_NAME = "wizards-terraform-state"
    }
    agent any
    stages{
        stage("Setup Parameters"){
            steps {
                script {
                    properties([
                        parameters([
                            string(
                                name: 'name',
                                description: '[Mandatory] Name of cluster',
                                defaultValue: 'cassandra-cluster',
                                trim: true
                            ),
                            choice(
                                name: 'environment',
                                description: '[Mandatory] Environment to deploy into',
                                choices: ['development', 'staging', 'production'], 
                                defaultValue: 'production',
                                trim: true
                            ),
                            string(
                                name: 'ami',
                                description: '[Mandatory] Ubuntu AMI of underlying EC2 instance',
                                defaultValue: 'ami-07ebfd5b3428b6f4d',
                                trim: true
                            ),
                            string(
                                name: 'vpc_id',
                                description: '[Mandatory] ID of VPC to deploy into',
                                defaultValue: 'vpc-d630b2ab',
                                trim: true
                            ),
                            string(
                                name: 'subnet_ids',
                                description: '[Mandatory] Comma Separated List of Subnet IDs of VPC to deploy into',
                                defaultValue: 'subnet-cff6f782,subnet-cff6f782',
                                trim: true
                            ),
                            string(
                                name: 'instance_type',
                                description: '[Mandatory] Instance Type of underlying EC2',
                                defaultValue: 't2.small',
                                trim: true
                            )
                        ])
                    ])
                }
            }
        }

        stage('Initialize Ingredients'){
            steps{
                script{
                    checkout scm
                }
            }
        }

        stage('Execute Terraform'){
            steps{
                script {
                    check_terraform()
                    def terraform_vars = get_terraform_vars(params)
                    def terraform_init_vars = get_terraform_init_vars()
                    execute_terraform(terraform_init_vars, terraform_vars)  
                }
            }

        }

        stage('Create Config Files'){
            steps{
                script{
                    def seed_nodes_private_ips = get_seed_nodes_private_ips()
                    prepare_config_files(params.name, seed_nodes_private_ips)
                }
            }
        }

        stage('Upload Config Files to S3'){
            steps{
                script{
                    upload_config_files()
                }
            }
        }

        stage('Audit'){
            steps{
                script{
                    print_audit_information(params)
                }
            }

        }
    }

    post {
        always {
            cleanWs()
        }
    }

}

def get_terraform_vars(params){
    def terraform_vars = ""
    terraform_vars += " -var 'NAME=${params.name}'"
    terraform_vars += " -var 'ENVIRONMENT=${params.environment}'"
    terraform_vars += " -var 'VPC_ID=${params.vpc_id}'"
    def subnet_ids_list = params.subnet_ids.split(',')
    def subnet_ids_string = ""
    for (subnet_id in subnet_ids_list) {
        subnet_ids_string += "\"" + subnet_id + "\"" + ","
    }
    subnet_ids_string = subnet_ids_string.substring(0, subnet_ids_string.length()-1)
    terraform_vars += " -var 'SUBNET_IDs=[${subnet_ids_string}]'"
    terraform_vars += " -var 'AMI=${params.ami}'"
    terraform_vars += " -var 'INSTANCE_TYPE=${params.instance_type}'"
    terraform_vars += " -var 'CONFIG_BUCKET_NAME=${env.CONFIG_BUCKET_NAME}'"
    terraform_vars += " -var 'CONFIG_BUCKET_KEY=${env.COMMON_BUCKET_KEY}'"
    return terraform_vars
}

def get_terraform_init_vars(){
    def terraform_init_vars = ""
    terraform_init_vars += " -backend-config=\"bucket=${env.STATE_BUCKET_NAME}\" "
    terraform_init_vars += " -backend-config=\"key=${env.COMMON_BUCKET_KEY}\" "
    terraform_init_vars += " -backend-config=\"region=${env.AWS_REGION}\" "
    return terraform_init_vars
}

def check_terraform(){
    def returnStatus = sh(script: "terraform", returnStatus: true)
    if(returnStatus!=0){
        TERRAFORM_EXE_PATH = "/usr/local/bin/terraform"
    }else{
        TERRAFORM_EXE_PATH = "terraform"
    }

    print "TERRAFORM_EXE_PATH is set to ${TERRAFORM_EXE_PATH}"
}

def execute_terraform(terraform_init_vars, terraform_vars){
    dir("terraform"){
        def returnStatus = sh(script: "${TERRAFORM_EXE_PATH} init ${terraform_init_vars}", returnStatus: true)
        if(returnStatus!=0){
            error("Unable to execute ${TERRAFORM_EXE_PATH} init")
        }

        returnStatus = sh(script: "/usr/local/bin/terraform plan ${terraform_vars} -out=terraform_plan.tf", returnStatus: true)
        if(returnStatus!=0){
            error("Unable to execute ${TERRAFORM_EXE_PATH} plan")
        }

        returnStatus = sh(script: "/usr/local/bin/terraform apply -auto-approve terraform_plan.tf", returnStatus: true)
        if(returnStatus!=0){
            error("Unable to execute ${TERRAFORM_EXE_PATH} apply")
        }

        returnStatus = sh(script: "rm terraform_plan.tf", returnStatus: true)
        if(returnStatus!=0){
            error("Unable to remove terraform_plan.tf")
        }
    }
}

def get_seed_nodes_private_ips(){
    dir("terraform"){
        def terraform_output = sh(script: "${TERRAFORM_EXE_PATH} output -json cassandra_seed_nodes_private_ips", returnStdout: true)
        def seed_nodes_private_ips = readJSON text: "${terraform_output}"
        print "seed_nodes_private_ips : ${seed_nodes_private_ips}"
        return seed_nodes_private_ips
    }
}

def prepare_config_files(name, seed_nodes_private_ips){
    def return_status = sh(script: "sed -i 's/@@NAME_OF_CLUSTER@@/${name}/g' config/cassandra/cassandra.yaml", returnStatus: true)
    if(return_status!=0){
        error("Unable to replace NAME_OF_CLUSTER")
    }

    def join_private_ips = ""
    for (private_ip in seed_nodes_private_ips) {
    	join_private_ips = join_private_ips + private_ip + ","
    }
    join_private_ips = join_private_ips.substring(0, join_private_ips.length()-1)

    return_status = sh(script: "sed -i 's/@@LIST_OF_SEED_NODES@@/${join_private_ips}/g' config/cassandra/cassandra.yaml", returnStatus: true)
    if(return_status!=0){
        error("Unable to replace LIST_OF_SEED_NODES")
    }
}


def upload_config_files(){
    sh(script: "aws s3 cp config/cassandra/ s3://${env.CONFIG_BUCKET_NAME}/${env.COMMON_BUCKET_KEY}/ --recursive")
}

def print_audit_information(params){
    print "#############################################"
    print "NAME                       :       ${params.name}"
    print "ENVIRONMENT                :       ${params.environment}"
    print "CONFIGURATION BUCKET NAME  :       ${env.CONFIG_BUCKET_NAME}"
    print "STATE BUCKET NAME          :       ${env.STATE_BUCKET_NAME}"
    print "BUCKET KEY                 :       ${env.COMMON_BUCKET_KEY}"
    print "#############################################"
}