@Library('nf-jenkins-shared-libraries')_  

def slavepool = "slave01 slave02 master"
def SLEEP = 5
def repo = "authorization"
MVN_HOME='mvn_local_repository'
def dependants = ["network", "identity", "billing", "netflow" ] //Services that dependant on auth.
jfrog_url = "https://netfoundry.jfrog.io/netfoundry/"
SERVER_ID = "netfoundry"

pipeline {
    agent any
    environment {
        DOCKER_HUB = credentials('dockerhub')
        SONAR_CLOUD = credentials('sonar')
        X_RAY = credentials("x_ray_user")
        BITBUCKET_AUTH = credentials('bitbucket_auth')
        ARTIFACTORY = credentials('jfrog-mop-reader')
        SRCCLR_API_TOKEN  = credentials('SRCCLR_API_TOKEN')
    }
    tools {
        maven 'apache-maven-3.6.0'
    }
    stages {
//         stage('Check if Release Exists') {
//             steps {
//                 script {
//                     def pom_version = sh (script: "mvn org.apache.maven.plugins:maven-help-plugin:3.1.0:evaluate -Dexpression=project.version -q -DforceStdout", returnStdout: true).trim()
//                     artifactory_login = "/usr/sbin/jfrog rt c --interactive=false --url=${jfrog_url} --user=${ARTIFACTORY_USR} --apikey=${ARTIFACTORY_PSW} ${SERVER_ID}"
//                     sh "${artifactory_login}"
//                     def artifacts_raw =sh (script: "jfrog rt search --sort-by=created --sort-order=asc mop-local-releases/io/netfoundry/${repo}/ | grep -v Info",returnStdout: true).trim()
//                     echo "${artifacts_raw}"
//                     artifacts = new groovy.json.JsonSlurperClassic().parseText(artifacts_raw)
//                     for(int i=0; i < artifacts.size(); i++){
//                         def path = artifacts[i]["path"].split("/")[4]
//                         release_artifact = "${path}-SNAPSHOT"
//                         echo "Path: ${path}, Pom: ${pom_version}"
//                         if( release_artifact == pom_version) {
//                             error("${pom_version} cannot be built or published as a snapshot, as there is already an existing release version ${path}")
//                         }
//                     }
//                 }
//             }
//         }

        stage('Build') {
            steps {
                script {
                    echo "Running on ${NODE_NAME}"
                    bitbucketStatus repo: "${repo}", BRANCH_NAME: "${BRANCH_NAME}", GIT_COMMIT: "${GIT_COMMIT}", status: "INPROGRESS"
                    sh "mkdir -p ${MVN_HOME}/${BUILD_NUMBER}"
                    dir("${MVN_HOME}/${BUILD_NUMBER}") {
                        sh "for dir in \$(ls \$HOME/.m2/repository/ | grep -v 'io'); do ln -s \$HOME/.m2/repository/\$dir \$dir; done"
                    }
                    sh "export JAVA_HOME=/usr/lib/jvm/java-11-amazon-corretto.x86_64/; mvn -U -Dmaven.repo.local=${MVN_HOME}/${BUILD_NUMBER} -T 1 clean install dependency-check:check"
                }
            }
        }

        
        stage('Sonar') {
            steps {
                script {
                    sh "export JAVA_HOME=/usr/lib/jvm/java-11-amazon-corretto.x86_64/; mvn -T 4 sonar:sonar -Dmaven.repo.local=../${MVN_HOME}/${BUILD_NUMBER} -Dsonar.host.url=https://sonarcloud.io "+
                        "-Dsonar.organization=netfoundry -Dsonar.projectName=${repo} "+
                        "-Dsonar.branch.name=${BRANCH_NAME} -Dsonar.login=${SONAR_CLOUD_PSW}"
                }
            }
        }
        // this build needs the artifactory stage because it builds a shared auth library
        stage('Artifactory') {
            when { expression { BRANCH_NAME == "develop" || BRANCH_NAME ==~ /(release.*)/ }}
            steps {
                script {
                if( BRANCH_NAME == "develop") {
                    artifactory REPO: "${repo}",  BUILDPATH: "${MVN_HOME}/${BUILD_NUMBER}"
                    artifactoryVeracode REPO: "${repo}",  BUILDPATH: "${MVN_HOME}/${BUILD_NUMBER}", ACTION: "upload"
                }
                }
            }
        }

        stage('Docker') {
            when { expression { BRANCH_NAME == "develop" || BRANCH_NAME ==~ /(release.*)/ || BRANCH_NAME ==~ /(hotfix.*)/ }}
            steps {
                script {
                    buildDocker REPO: "${repo}", GIT_COMMIT: "${GIT_COMMIT}", BUILD_NUMBER: "${BUILD_NUMBER}", BRANCH_NAME: "${BRANCH_NAME}"

                    try {
                        sh "docker rmi netfoundry/auth:${GIT_COMMIT}"
                        sh "docker rmi netfoundry/auth:sandbox"
                        sh "docker rmi netfoundry/auth:latest"
                    } catch(err) {
                        echo "Docker images cleanup not done: ${err}"
                    }
                }
            }
        }


        stage('Terraform'){
            when { expression { BRANCH_NAME == "develop"  }}
            steps {
                script { 
                    terraform directory: "terraform", environment: "sandbox"
                }
            }
        }

        stage('Deployment') {
            when { expression { BRANCH_NAME == "develop" }}
            steps {
                script {
                    withCredentials([[$class: 'AmazonWebServicesCredentialsBinding', credentialsId: "aws_sandbox", variable: 'AWS_ACCESS_KEY_ID']]) {
                        sh "ecs deploy --region us-east-1 --timeout 600 ecs-cluster-nfn-internal-env-private ecs-auth-service"
                    }
                }
            }
        }

        stage('Promote to Staging') {
            when { expression { BRANCH_NAME == "develop" }}
            steps {
                script {

                    build_job = build job: 'Continuous Deployment - Promotions', parameters: [
                        [$class: 'StringParameterValue', name: 'commit_hash', value: "${GIT_COMMIT}"],
                        [$class: 'StringParameterValue', name: 'REPO', value: "${repo}"],
                        [$class: 'StringParameterValue', name: 'environment', value: "staging"],
                        [$class: 'StringParameterValue', name: 'action', value: 'promote'],
                        [$class: 'BooleanParameterValue', name: 'run_tests', value: false],
                        [$class: 'BooleanParameterValue', name: 'database_backup', value: false],
                        [$class: 'BooleanParameterValue', name: 'slack_notify', value: true],
                        [$class: 'BooleanParameterValue', name: 'run_ecs_deploy', value: true],
                        [$class: 'BooleanParameterValue', name: 'run_post_deploy_tests', value: true],
                    ], propagate: false, wait: false
                }
            }
        }
        
    }
    post {
        always {
            sh "rm -rf ${MVN_HOME}/${BUILD_NUMBER}"
        }
        aborted {
            bitbucketStatus repo: "${repo}", BRANCH_NAME: BRANCH_NAME, GIT_COMMIT: GIT_COMMIT, status: "STOPPED"
        }
        failure {
            bitbucketStatus repo: "${repo}", BRANCH_NAME: BRANCH_NAME, GIT_COMMIT: GIT_COMMIT, status: "FAILED"
            script {
                if( "${BRANCH_NAME}" == "develop" ){
                    mattermostFailureNotification repo: "${repo}", commit: GIT_COMMIT, build_url: RUN_DISPLAY_URL, channel: "cd-mop-staging"
                }
            }
        }
        success {
            bitbucketStatus repo: "${repo}", BRANCH_NAME: BRANCH_NAME, GIT_COMMIT: GIT_COMMIT, status: "SUCCESSFUL"
        }
    }
}