Jenkinsfile

#!/usr/bin/env groovy

node {
    
    // Cleanup workspace
    deleteDir()
    
    //Clone example project from GitHub repository
    git url: 'https://github.com/jfrogtraining/kubernetes_example.git', branch: 'master'
    def rtServer = Artifactory.server SERVER_ID
    def rtDocker = Artifactory.docker server: rtServer
    def buildInfo = Artifactory.newBuildInfo()
    def tagDockerApp

    buildInfo.env.capture = true

    //Fetch all depedencies from Artifactory
    stage ('Dependencies') {
        dir ('docker-app') {
            try {
                println "Gather Released Docker Framework and Gradle War file"
                def gradleWarDownload = """{
                    "files": [
                      {
                        "pattern": "gradle-release-local/org/jfrog/example/gradle/webservice/1.1.2/*.war",
                        "target": "war/webservice.war",
                        "props": "unit-test=pass",
                        "flat": "true"
                      }
                    ]
                 }"""
                rtServer.download(gradleWarDownload, buildInfo )
            } catch (Exception e) {
                println "Caught Exception during resolution. Message ${e.message}"
                throw e
            }
        }
    }
    //Build docker image named docker-app
    stage ('Build & Deploy') {
        dir ('docker-app') {
            sh "sed -i 's/docker.artifactory/${ARTDOCKER_REGISTRY}/' Dockerfile"
            tagDockerApp = "${ARTDOCKER_REGISTRY}/docker-app:${env.BUILD_NUMBER}"
            println "Docker App Build"
            docker.build(tagDockerApp)
            println "Docker push" + tagDockerApp + " : " + REPO
            buildInfo = rtDocker.push(tagDockerApp, REPO, buildInfo)
            println "Docker Buildinfo"
            rtServer.publishBuildInfo buildInfo
        }
     }
    
    stage ("Retag latest image") {
        dir('docker-app') {
            reTagLatest (SOURCE_REPO)   
        }
    }
    
    //Test docker image
     stage ('Test') {
        dir('docker-app/app-test') {
            tagDockerApp = "${ARTDOCKER_REGISTRY}/docker-app:${env.BUILD_NUMBER}"
            if (testApp(tagDockerApp)) {
                  println "Setting property and promotion"
                  sh 'docker rmi '+tagDockerApp+' || true'
             } else {
                  currentBuild.result = 'UNSTABLE'
                  return
             }
        }
     }

    //Scan Build Artifacts in Xray
    stage('Xray Scan') {
         if (XRAY_SCAN == "YES") {
             def xrayConfig = [
                'buildName'     : env.JOB_NAME,
                'buildNumber'   : env.BUILD_NUMBER,
                'failBuild'     : false
              ]
              def xrayResults = rtServer.xrayScan xrayConfig
              echo xrayResults as String
         } else {
              println "No Xray scan performed. To enable set XRAY_SCAN = YES"
         }
         sleep 60
     }

    //Promote docker image from staging local repo to production repo in Artifactory
    /* stage ('Promote') {
        dir('docker-app/app-test') {
            def promotionConfig = [
              'buildName'          : env.JOB_NAME,
              'buildNumber'        : env.BUILD_NUMBER,
              'targetRepo'         : PROMOTE_REPO,
              'comment'            : 'App works with latest released version of gradle swampup app, tomcat and jdk',
              'sourceRepo'         : SOURCE_REPO,
              'status'             : 'Released',
              'includeDependencies': false,
              'copy'               : true
            ]
            rtServer.promote promotionConfig
            reTagLatest (SOURCE_REPO)
            reTagLatest (PROMOTE_REPO)
        }

        // promote war file from gradle-dev-local to gradle-release-local

     }*/
    
    
        
}

def testApp (tag) {
    docker.image(tag).withRun('-p 9191:8181') {c ->
        sleep 10
        //def stdout = sh(script: 'curl "http://localhost:9191/swampup/"', returnStdout: true)
        //if (stdout.contains("Welcome Docker Lifecycle Training")) {
          //  println "*** Passed Test: " + stdout
            println "*** Passed Test"
            return true
       // } else {
        //    println "*** Failed Test: " + stdout
         //   return false
       // }
    }
}

//Tag docker image
def reTagLatest (targetRepo) {
    def BUILD_NUMBER = env.BUILD_NUMBER
    sh 'sed -E "s/@/$BUILD_NUMBER/" retag.json > retag_out.json'
    switch (targetRepo) {
          case PROMOTE_REPO :
              sh 'sed -E "s/TARGETREPO/${PROMOTE_REPO}/" retag_out.json > retaga_out.json'
              break
          case SOURCE_REPO :
              sh 'sed -E "s/TARGETREPO/${SOURCE_REPO}/" retag_out.json > retaga_out.json'
              break
    }
    sh 'cat retaga_out.json'
    withCredentials([[$class: 'UsernamePasswordMultiBinding', credentialsId: CREDENTIALS, usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD']]) {
        def curlString = "curl -u " + env.USERNAME + ":" + env.PASSWORD + " " + SERVER_URL
        def regTagStr = curlString +  "/api/docker/$targetRepo/v2/promote -X POST -H 'Content-Type: application/json' -T retaga_out.json"
        println "Curl String is " + regTagStr
        sh regTagStr
    }
}

def updateProperty (property) {
    withCredentials([[$class: 'UsernamePasswordMultiBinding', credentialsId: CREDENTIALS, usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD']]) {
            def curlString = "curl -u " + env.USERNAME + ":" + env.PASSWORD + " " + "-X PUT " + SERVER_URL
            def updatePropStr = curlString +  "/api/storage/${SOURCE_REPO}/docker-app/${env.BUILD_NUMBER}?properties=${property}"
            println "Curl String is " + updatePropStr
            sh updatePropStr
     }
}