sharedLibsPath = "${env.WORKSPACE}/sharedLibs"

// 获取镜像URL
generateFullImageUri = {Map DOCKER, String base_branch, String BUILD_NUMBER ->
    return "${DOCKER.registry}/${DOCKER.image}:${base_branch}-${BUILD_NUMBER}"
}

// 获取镜像名
generateImageName = {Map DOCKER, String base_branch, String BUILD_NUMBER ->
    return "${DOCKER.image}:${base_branch}-${BUILD_NUMBER}"
}

// 生成Dockerfile
def generateDockerfile(Object SERVICE, String pathOfDockerfile='projdir') {
    
    def module = SERVICE.module == null ? '' : (SERVICE.module[-1] == '/' ? SERVICE.module : SERVICE.module + '/')
    echo "-----> Generating Dockerfile: ${pathOfDockerfile}/Dockerfile ..."
    sh """cat > ${pathOfDockerfile}/Dockerfile<<EOF
FROM openjdk:8-alpine as final
ADD ${module}target/${SERVICE.jar} /app/target/${SERVICE.jar}
EOF
"""
    return pathOfDockerfile
}

// Maven工程生成.jar
def buildJar(String path='projdir') {
    
    echo "-----> Building java package ..."
    dir(path){
        sh '$MAVEN_HOME/bin/mvn clean package -Dmaven.test.skip=true'
    }
    return path
}

def cleanJar(String path='projdir') {
    echo "-----> Clean java package ..."
    dir(path){
        sh '$MAVEN_HOME/bin/mvn clean'
    }
    return path
}

// 构建Docker镜像
def buildDockerImage(Object SERVICE, Object DOCKER, String base_branch, projDir='projdir', String filter2Remove=null) {

    def imageUri = generateFullImageUri(DOCKER, base_branch, BUILD_NUMBER)
    echo "-----> Building docker image: ${imageUri} ..."
    dir(projDir) {
        docker.withRegistry("http://${DOCKER.registry}", "${DOCKER.push_credentialId}") {
            def imageName = generateImageName(DOCKER, base_branch, BUILD_NUMBER)
            def image = docker.build(imageName)
            image.push()
            sh "docker rmi ${imageName}"
            sh "docker rmi ${imageUri}"
            if(filter2Remove != null)
                sh "docker image prune --filter label=${filter2Remove} -f"
        }
    }
    return imageUri
}

def dockerRun(Object CONFIG, String docker_image_uri) {

    def DOCKER_OPTS = "-H tcp://10.172.9.200:2375"
    sh "if [ \$(docker ${DOCKER_OPTS} ps -aq --filter name=${CONFIG.service.name}) ]; then docker ${DOCKER_OPTS} rm -f -v ${CONFIG.service.name};fi"
    sh "docker ${DOCKER_OPTS} login -u ryo.hune@gmail.com -p QAZwsx117 registry.cn-shanghai.aliyuncs.com"
    def EXEC = "docker ${DOCKER_OPTS} run -d --restart=always -p 80:80 -e TZ=Asia/Shanghai --name ${CONFIG.service.name} ${docker_image_uri} " + 
        "java -Djava.awt.headless=true -Dserver.port=80 -jar /app/target/${CONFIG.service.jar}"
    echo "$EXEC"
    sh "$EXEC"
}

// Jenkins pipeline stages
// closures = [
//    GITCLONE: { -> },
//    GENERATEDOCKERFILE: { -> },
//    BUILDIMAGE: { -> },
//    DOCKERRUN: { -> } 
//]
def execute(CONFIG, base_branch, closures=[:]) {

    stage('source code check out') {
        
        println "loading ${sharedLibsPath}/gitUtil.groovy..."
        def gitUtils = load "${sharedLibsPath}/gitUtil.groovy"

        println closures.GITCLONE == null
        COMMIT_SHA = closures.GITCLONE == null ? gitUtils.clone(CONFIG.git, base_branch) : closures.GITCLONE()
    }

    stage("docker image build") {

        def projDir = 'projdir'
        if (closures.BUILDJAR != null)
            projDir = closures.BUILDJAR()
        else
            projDir = buildJar(projDir)

        if (closures.GENERATEDOCKERFILE != null)
            projDir = closures.GENERATEDOCKERFILE()
        else
            projDir = generateDockerfile(CONFIG.service)

        if (closures.BUILDIMAGE != null)
            imageUri = closures.BUILDIMAGE()
        else
            imageUri = buildDockerImage(CONFIG.service, CONFIG.docker, base_branch, projDir)
        
        if (closures.CLEANJAR != null)
            closures.CLEANJAR()
        else
            cleanJar(projDir)
    }

    stage("run docker container") {

        if(closures.DOCKERRUN != null){
            closures.DOCKERRUN()
            return
        }

        dockerRun(CONFIG, imageUri)        
    }
}

return this