workflow-job

import java.io.StringReader
import java.util.ArrayList
import java.util.UUID
import java.util.Properties
import org.kohsuke.github.GitHub
import org.kohsuke.github.GHCommitState
import org.kohsuke.github.GHRepository

// This script must be called with
// $repoURL parameter: specifies the commiter GitHub repo URL
// $branch parameter: branch to build specified (used by git workflow-plugin command)
// or $tagName parameter: specifies the tag to build
// or $sha1 parameter: specifies the actual commit
// $originalBranch: the branch used for merge (optional)
// $isLatest: is it the latest stable release

hostname = 'james.linagora.com'
maxRetries = 120
IMAP_PORT = 143
SMTP_PORT = 587
S3_PORT = 8000
author = extractUsername()
authorParentURL = "https://github.com/${author}/james-project.git"
repoName = extractRepoName()
workingBranch = retrieveWorkingBranch()
def retrieveWorkingBranch() {
    if (tagName != null) {
        return tagName
    } else {
        return branch
    }
}

// Not given optional parameters are set to null
def propertyMissing(String name) { null }

public String extractUsername() {
    return "${repoURL}".split('/')[3]
}

public String extractRepoName() {
    return "${repoURL}".split('/')[4].split('\\.')[0]
}

public class CommitStatuses implements Serializable {
    def commitStatuses

    public CommitStatuses() {
        commitStatuses = new ArrayList<CommitStatus>()
    }

    public void addPendingStatus(CommitStatus status) {
        commitStatuses.add(status)
        status.pending()
    }

    public void failPendingStatuses() {
        for (CommitStatus status : commitStatuses) {
            if (status.state.equals("PENDING")) {
                status.failure()
            }
        }
    }
}

public class CommitStatusFactory implements Serializable {

    private final String repoName
    private final String sha1
    private int stepNumber = 0

    public CommitStatusFactory(String repoName, String sha1) {
        this.repoName = repoName
        this.sha1 = sha1
    }

    public CommitStatus from(String description) {
        stepNumber++
        return new CommitStatus(repoName, sha1, description, stepNumber)
    }
}

public class CommitStatus implements Serializable {
    def repoName
    def sha1
    def description
    def context
    def state

    public CommitStatus(String repoName, String sha1, String description, int stepNumber) {
        this.repoName = repoName
        this.sha1 = sha1
        this.description = description
        this.context = "workflow-job step " + stepNumber
    }

    def pending() { createPendingCommitStatus() }

    def success() { createSuccessCommitStatus() }

    def failure() { createFailureCommitStatus() }

    private void createPendingCommitStatus() {
        createCommitStatus("PENDING")
    }

    private void createSuccessCommitStatus() {
        createCommitStatus("SUCCESS")
    }

    private void createFailureCommitStatus() {
        createCommitStatus("FAILURE")
    }

    @NonCPS
    private GHRepository getRepository(String repoName) {
        return GitHub.connectUsingOAuth(System.getenv("GITHUB_TOKEN")).getRepository("linagora/" + repoName)
    }

    @NonCPS
    private void createCommitStatus(String state) {
        this.state = state
        if (sha1 != null) {
            getRepository(repoName).createCommitStatus(sha1, GHCommitState.valueOf(state), null, description, context)
        }
    }
}

class Images implements Serializable {
    def cassandra
    def elasticSearch
    def rabbitmq
    def s3
    def swift
    def jamesCompile
    def jamesCassandra
    def jamesCassandraRabbitMQ
    def jamesCassandraRabbitMQLdap
    def jamesCassandraLdap
    def jamesJPA
    def jamesDemo
    def jamesDemoForTesting
    def jamesSpring
    def jamesMemory
    def gitPublish

    def images

    Images(String buildId) {
        jamesCompile = 'james-parent-compile-' + buildId
        jamesCassandra = 'james-server-cassandra-' + buildId
        jamesCassandraRabbitMQ = 'james-server-cassandra-rabbitmq-' + buildId
        jamesCassandraRabbitMQLdap = 'james-server-cassandra-rabbitmq-ldap-' + buildId
        jamesCassandraLdap = 'james-server-cassandra-ldap-' + buildId
        jamesJPA = 'james-server-jpa-' + buildId
        jamesDemo = 'james-server-demo-' + buildId
        jamesDemoForTesting = 'james-server-demo-testing' + buildId
        jamesSpring = 'james-server-spring-' + buildId
        jamesMemory = 'james-server-memory-' + buildId
        gitPublish = 'git/publish-' + buildId

        images = [ jamesCompile, jamesCassandra, jamesCassandraRabbitMQ, jamesCassandraRabbitMQLdap, jamesCassandraLdap,
                    jamesJPA, jamesDemo, jamesDemoForTesting, jamesSpring, jamesMemory, gitPublish ]
    }

    def customDependenciesOrDefault(def node) {
        Properties properties = fromFile(node, 'dockerfiles/run/dependencies.properties')

        cassandra = properties."cassandra" ?: 'cassandra:3.11.3'
        elasticSearch = properties."elasticSearch" ?: 'docker.elastic.co/elasticsearch/elasticsearch:6.3.2'
        rabbitmq = properties."rabbitmq" ?: 'rabbitmq:3.8.1-management'
        swift = properties."swift" ?: 'linagora/openstack-keystone-swift:pike'
        s3 = properties."s3" ?: 'zenko/cloudserver:8.2.6'
    }

    def fromFile(def node, def file) {
        if (!node.fileExists('dockerfiles/run/dependencies.properties')) {
            node.echo "Using default dependencies"
            return new Properties()
        }

        try {
            Properties properties = new Properties()
            properties.load(new StringReader(node.readFile(file)))
            return properties
        } catch (Exception e) {
            node.echo "Exception occured while getting dependencies, using default values"
            node.echo "${e}"
            return new Properties()
        }
    }

    def deleteAll = { node ->
        new Command("docker rmi --force=true ${images.join(' ')} || true").execute(node)
    }
}

class Containers implements Serializable {
    def keystore = 'keystore'
    def keys = 'keys'
    def cassandra
    def elasticSearch
    def rabbitmq
    def s3
    def swift
    def integrationCassandraRabbitMQ
    def integrationCassandra
    def integrationJPA
    def integrationSpring
    def integrationMemory
    def jamesCompile
    def jamesTest
    def jamesCassandra
    def jamesCassandraRabbitMQ
    def jamesCassandraLdap
    def jamesJPA
    def jamesDemoForTesting
    def jamesSpring
    def jamesMemory
    def gitPublish

    def containers

    Containers(String buildId) {
        cassandra = 'cassandra-' + buildId
        elasticSearch = 'elasticSearch-' + buildId
        rabbitmq = 'rabbitmq-' + buildId
        s3 = 's3-' + buildId
        swift = 'swift-' + buildId
        integrationCassandraRabbitMQ = 'integration-cassandra-rabbitmq-' + buildId
        integrationCassandra = 'integration-cassandra-' + buildId
        integrationJPA = 'integration-jpa-' + buildId
        integrationSpring = 'integration-spring-' + buildId
        jamesCompile = 'james-parent-compile-' + buildId
        integrationMemory = 'integration-memory-' + buildId
        jamesTest = 'james-parent-test-' + buildId
        jamesCassandra = 'james-server-cassandra-' + buildId
        jamesCassandraRabbitMQ = 'james-server-cassandra-rabbitmq-' + buildId
        jamesCassandraLdap = 'james-server-cassandra-ldap-' + buildId
        jamesJPA = 'james-server-jpa-' + buildId
        jamesDemoForTesting = 'james-server-demo-testing' + buildId
        jamesSpring = 'james-server-spring-' + buildId
        jamesMemory = 'james-server-memory-' + buildId
        gitPublish = 'git-publish-' + buildId

        containers = [ cassandra, elasticSearch, rabbitmq, s3, swift,
                       integrationCassandraRabbitMQ, integrationCassandra, integrationJPA, integrationSpring, integrationMemory,
                       jamesCompile, jamesTest, jamesCassandra, jamesCassandraRabbitMQ, jamesCassandraLdap, jamesJPA, jamesDemoForTesting, jamesSpring, jamesMemory,
                       gitPublish ]
    }

    def deleteAll = { node ->
        new Command("docker rm --force=true --volumes=true ${containers.join(' ')} || true").execute(node)
    }
}

class Command {

    private final String command

    Command(String command) {
        this.command = command
    }

    def execute = { node ->
        try {
            node.sh "${command}"
        } catch (Exception e) {
            e.printStackTrace()
        }
    }
}

productCassandra = 'cassandra'
productCassandraLdap = '"cassandra-ldap"'
productCassandraRabbitMQ = 'cassandra-rabbitmq'
productCassandraRabbitMQLdap = 'cassandra-rabbitmq-ldap'
productJPA = 'jpa'
productMemory = 'memory'

jarPathCassandra = pathInDestination(productCassandra, 'james-server-cassandra-guice.jar')
libPathCassandra = pathInDestination(productCassandra, 'james-server-cassandra-guice.lib')

jarPathCassandraLdap = pathInDestination(productCassandra, 'james-server-cassandra-guice.jar')
libPathCassandraLdap = pathInDestination(productCassandra, 'james-server-cassandra-guice.lib')

jarPathCassandraRabbitMQ = pathInDestination(productCassandraRabbitMQ, 'james-server-cassandra-rabbitmq-guice.jar')
libPathCassandraRabbitMQ = pathInDestination(productCassandraRabbitMQ, 'james-server-cassandra-rabbitmq-guice.lib')

jarPathCassandraRabbitMQLdap = pathInDestination(productCassandraRabbitMQLdap, 'james-server-cassandra-rabbitmq-guice.jar')
libPathCassandraRabbitMQLdap = pathInDestination(productCassandraRabbitMQLdap, 'james-server-cassandra-rabbitmq-guice.lib')

jarPathJPA = pathInDestination(productJPA, 'james-server-jpa-guice.jar')
libPathJPA = pathInDestination(productJPA, 'james-server-jpa-guice.lib')

jarPathMemory = pathInDestination(productMemory, 'james-server-memory-guice.jar')
libPathMemory = pathInDestination(productMemory, 'james-server-memory-guice.lib')

private getCliJarPath(productMemory) {
    pathInDestination(productMemory, 'james-server-cli.jar')
}

private getCliLibPath(product) {
    pathInDestination(product, 'james-server-cli.lib')
}

def runJamesScriptPath(product) {
    pathInDestination(product, 'run_james.sh')
}

def glowrootPluginsPath(product) {
    pathForGlowrootFile(product, 'plugins')
}

def glowrootJarPath(product) {
    pathForGlowrootFile(product, 'glowroot.jar')
}

def glowrootCollectorJarPath(product) {
    pathForGlowrootFile(product, 'lib/glowroot-embedded-collector.jar')
}

def glowrootLogginJarPath(product) {
    pathForGlowrootFile(product, 'lib/glowroot-logging-logstash.jar')
}

def glowrootAdminJsonPath(product) {
    pathForGlowrootFile(product, 'admin.json')
}

def pathForGlowrootFile(product, file) {
    pathInDestination(product, "glowroot/$file")
}

def pathInDestination(product, file) {
    return "$product/destination/$file"
}

keystorePath = '/keys/keystore'
jamesCliWithOptions = 'java -jar /root/james-cli.jar -h 127.0.0.1'

def version() {
    def matcher = readFile('pom.xml') =~ '<version>(.+?)</version>'
    matcher ? matcher[1][1] : null
}

def waitForCommandSuccess(command, maxRetries) {
    def tries = 0
    while (tries++ < maxRetries) {
        try {
            sh command
            return true
        } catch (Exception e) {
            if (tries >= maxRetries) {
                throw new Exception("${} tries exceeded. ${command} failed.", e)
            }
            sh "sleep 1"
        }
    }
}

def setDockerHost(dockerHost) {
    env.DOCKER_HOST = "tcp://${dockerHost}:2376"
    env.DOCKER_CERT_PATH = '/keys/'
    env.DOCKER_TLS_VERIFY = 'TRUE'
}

def unsetDockerHost() {
    env.DOCKER_HOST = ""
    env.DOCKER_CERT_PATH = ""
    env.DOCKER_TLS_VERIFY = 'FALSE'
}

def flows = [:]

def sha1OrBranch = {
    if (sha1 == null) {
        return "${workingBranch}"
    }
    return sha1
}

def isMaster = {
    return sha1OrBranch() == 'master'
}

def isBranch = {
    return sha1 == null
}

def isTag = {
    return tagName != null
}

def tag = {
    if (isTag()) {
        return "${tagName}"
    }
    if (isMaster()) {
        return "branch-master"
    }
    return null
}

dockerTag = tag()
dockerUser = System.getenv("DOCKER_USER")
dockerPassword = System.getenv("DOCKER_PASSWORD")

gitlabToken = System.getenv("GITLAB_TOKEN")

def publishToDocker = {
    return (isBranch() || isTag()) && dockerUser != null
}

def partialBuild = {
    return !isBranch() && !isMaster()
}

def partialBuildEnvFunction = {
    if (partialBuild()) {
        if (originalBranch == null) {
            return "--env 'JAMES_PARTIAL_BUILD_BASE_BRANCH=origin/master' --env 'MVN_ADDITIONAL_ARG_LINE=-Ppartial-build"
        }
    }
    return ""
}

partialBuildEnv = partialBuildEnvFunction()

def packageOnGitlab = {
    return isMaster() && gitlabToken != null
}

def isAlive(dockerContainer) {
    try {
        sh "docker inspect -f '{{.State.Status}}' ${dockerContainer} | grep running"
        return true
    } catch (Exception e) {
        return false
    }
}

def provisionDataForIntegrationTest(dockerContainer, jamesCliCmd) {
    sh "docker exec ${dockerContainer} ${jamesCliCmd} adddomain domain"
    sh "docker exec ${dockerContainer} ${jamesCliCmd} adduser imapuser@domain password"
}

def containerIp(dockerContainer) {
    return "`docker inspect -f '{{(index .NetworkSettings.IPAddress)}}' ${dockerContainer}`"
}

// Define main variables
buildId = "${workingBranch.toLowerCase()}-${UUID.randomUUID()}"
mergeBranch = "MERGE-${buildId}"
containers = new Containers(buildId)
jamesLinks = "--link ${containers.cassandra}:cassandra --link ${containers.elasticSearch}:elasticsearch"
rabbitmqS3Links = "--link ${containers.rabbitmq}:rabbitmq --link ${containers.s3}:s3.docker.test"
rabbitmqSwiftLinks = "--link ${containers.rabbitmq}:rabbitmq --link ${containers.swift}:swift"
m2volume = "m2-${buildId}"
m2mount = "--volume ${m2volume}:/root/.m2"
batchModeEnv =  "--env 'MVN_ADDITIONAL_ARG_LINE=--batch-mode'"

sha1ToBuild = sha1OrBranch()
verbose = "-a stdout -a stderr"

statuses = new CommitStatuses()
commitStatusFactory = new CommitStatusFactory(repoName, sha1)
merging = commitStatusFactory.from("Merging")
statuses.addPendingStatus(merging)

buildingJava = commitStatusFactory.from("Building")
statuses.addPendingStatus(buildingJava)

testingJava = commitStatusFactory.from("Testing")
statuses.addPendingStatus(testingJava)

dockeringGuiceCassandraRabbitMQLdap = commitStatusFactory.from("Dockering Guice Cassandra + RabbitMQ + object store + Ldap")
statuses.addPendingStatus(dockeringGuiceCassandraRabbitMQLdap)
dockeringGuiceCassandraRabbitMQ = commitStatusFactory.from("Dockering Guice Cassandra + RabbitMQ + object store")
statuses.addPendingStatus(dockeringGuiceCassandraRabbitMQ)
dockeringGuiceCassandra = commitStatusFactory.from("Dockering Guice Cassandra")
statuses.addPendingStatus(dockeringGuiceCassandra)
dockeringGuiceJPA = commitStatusFactory.from("Dockering Guice JPA")
statuses.addPendingStatus(dockeringGuiceJPA)
dockeringSpringJPA = commitStatusFactory.from("Dockering Spring JPA")
statuses.addPendingStatus(dockeringSpringJPA)
dockeringMemory = commitStatusFactory.from("Dockering Memory")
statuses.addPendingStatus(dockeringMemory)
deployingMemory = commitStatusFactory.from("Deploying Memory")
statuses.addPendingStatus(deployingMemory)
dockeringGuiceCassandraLdap = commitStatusFactory.from("Building Guice Cassandra/Ldap")
statuses.addPendingStatus(dockeringGuiceCassandraLdap)
dockeringGuiceDemoTesting = commitStatusFactory.from("Dockering Guice JPA with data provision")
statuses.addPendingStatus(dockeringGuiceDemoTesting)

deployingGuiceCassandraRabbitMQ = commitStatusFactory.from("Deploying Guice Cassandra + RabbitMQ + object store")
statuses.addPendingStatus(deployingGuiceCassandraRabbitMQ)
deployingGuiceCassandra = commitStatusFactory.from("Deploying Guice Cassandra")
statuses.addPendingStatus(deployingGuiceCassandra)
deployingGuiceJPA = commitStatusFactory.from("Deploying Guice JPA")
statuses.addPendingStatus(deployingGuiceJPA)
deployingSpringJPA = commitStatusFactory.from("Deploying Spring JPA")
statuses.addPendingStatus(deployingSpringJPA)
deployingGuiceDemoTesting = commitStatusFactory.from("Deploying Guice JPA with data provision")
statuses.addPendingStatus(deployingGuiceDemoTesting)

testingGuiceCassandraRabbitMQ = commitStatusFactory.from("Integrating Guice Cassandra  + RabbitMQ + object store")
statuses.addPendingStatus(testingGuiceCassandraRabbitMQ)
testingGuiceCassandra = commitStatusFactory.from("Integrating Guice Cassandra")
statuses.addPendingStatus(testingGuiceCassandra)
testingGuiceJPA = commitStatusFactory.from("Integrating Guice JPA")
statuses.addPendingStatus(testingGuiceJPA)
testingSpringJPA = commitStatusFactory.from("Integrating Spring JPA")
statuses.addPendingStatus(testingSpringJPA)
testingMemory = commitStatusFactory.from("Integrating Memory")
statuses.addPendingStatus(testingMemory)

publishing

deployAndValidatingBuilder = [:]
if (publishToDocker()) {
    publishing = commitStatusFactory.from("Publishing")
    statuses.addPendingStatus(publishing)
}
packagingTrigger
if (packageOnGitlab()) {
    packagingTrigger = commitStatusFactory.from("Triggering packaging")
    statuses.addPendingStatus(packagingTrigger)
}
rabbitMQProductExists = false
memoryProductExists = false
images = null
flows["${sha1}"] = {

    stage "Build"
    node('remote') {
        ws("/home/jenkins/build/workspace/${env.BUILD_NUMBER}") {
            try {
                if (isTag()) {
                    buildVolumeFromTag(this)
                } else {
                    merge(this)
                }
                merging.success()
                rabbitMQProductExists = fileExists 'dockerfiles/run/guice/cassandra-rabbitmq-ldap'
                memoryProductExists = fileExists 'dockerfiles/run/guice/memory'

                sh "docker volume create ${m2volume}"

                compile(this)

                deployGuiceCassandra()
                testGuiceCassandra()

                deployGuiceJPA()
                testGuiceJPA()

                deploySpringJPA()
                testSpringJPA()

                if (memoryProductExists) {
                    deployMemory()
                    testMemory()
                }

                buildGuiceCassandraLdap()

                deployGuiceDemo()

                if (publishToDocker()) {
                    publish()
                }

                if (packageOnGitlab()) {
                    wrap([$class: 'MaskPasswordsBuildWrapper', varPasswordPairs: [[password: "${gitlabToken}", var: 'gitlabToken']]]) {
                        sh "curl -X POST -Ftoken=${gitlabToken} -F'ref=master' -F'variables[REPO_NAME]=oncommit' -F'variables[SOURCE_REPO]=https://github.com/linagora/james-project' https://ci.linagora.com/api/v4/projects/803/trigger/pipeline"
                    }
                    packagingTrigger.success()
                }
            } finally {
                containers.deleteAll(this)
                images?.deleteAll(this)
                sh "docker volume rm ${m2volume} || true"
            }
        }
    }
    statuses.failPendingStatuses()
}

parallel flows

jamesVersion = ""
def merge(def node) {
    git url: authorParentURL, branch: branch
    sh "git fetch origin"
    sh "git checkout ${branch}"
    jamesVersion = version()
    images = new Images(buildId)
    images.customDependenciesOrDefault(node)

    sh "docker build --tag ${images.gitPublish} -f dockerfiles/merge/Dockerfile ."
    sh "docker run ${verbose} -t --name ${containers.gitPublish} -v /origin ${images.gitPublish} ${sha1ToBuild} ${mergeBranch} ${originalBranch}"
}

def buildVolumeFromTag(def node) {
    git url: authorParentURL, branch: "master"
    sh "git fetch --tags origin"
    sh "git checkout ${tagName} -b ${mergeBranch}"
    jamesVersion = version()
    images = new Images(buildId)
    images.customDependenciesOrDefault(node)

    def dockerfile = """\
                        FROM debian:8.11
                        
                        ADD . /origin
                        WORKDIR /origin
                        CMD echo \"Volume built\"""".stripIndent()
    sh "echo \"${dockerfile}\" > Dockerfile"
    sh "docker build --tag ${images.gitPublish} ."
    sh "docker run ${verbose} -t --name ${containers.gitPublish} -v /origin ${images.gitPublish}"
}

def compile(def node) {
    if (node.fileExists('dockerfiles/compilation/java-8')) {
        javaVersion = "java-8"
    } else {
        javaVersion = "java-11"
    }

    sh "docker build --tag=${images.jamesCompile} dockerfiles/compilation/${javaVersion}"

    def tmpfsOptions = '--tmpfs=/tmp:rw,exec,size=1g --tmpfs=/james-project:rw,size=4g'
    def dockerVolume = '-v /var/run/docker.sock:/var/run/docker.sock'
    def destinationVolumes = '--volume=/jpa/destination --volume=/cassandra/destination --volume=/spring/destination --volume=/cassandra-rabbitmq/destination --volume=/cassandra-rabbitmq-ldap/destination --volume=/memory/destination'
    def allVolumes = "${dockerVolume} ${m2mount} --volumes-from=${containers.keys} --volumes-from=${containers.gitPublish} ${destinationVolumes}"
    def compileNameDefinitions = "--name=${containers.jamesCompile}"
    def testNameDefinitions = "--name=${containers.jamesTest}"

    sh "cd dockerfiles/; docker run ${verbose} ${tmpfsOptions} ${m2mount} --volumes-from=${containers.gitPublish} ${compileNameDefinitions} --env 'MVN_ADDITIONAL_ARG_LINE=-T 1C --batch-mode' ${images.jamesCompile} -s ${mergeBranch}"
    buildingJava.success()

    sh "cd dockerfiles/; docker run ${verbose} ${tmpfsOptions} ${allVolumes} ${batchModeEnv} ${testNameDefinitions} ${partialBuildEnv} ${images.jamesCompile} ${mergeBranch}"
    testingJava.success()
}

def copyFilesFromCompilationContainer(product, jarPath, libPath) {
    copyFilesFromCompilationContainer(product, product, jarPath, libPath)
}

def copyFilesFromCompilationContainer(destinationProduct, sourceProduct, jarPath, libPath) {
    sh "cd dockerfiles/run/guice/$destinationProduct; docker cp ${containers.keystore}:${keystorePath} destination/conf"
    sh "cd dockerfiles/run/guice/$destinationProduct; docker cp ${containers.jamesTest}:$jarPath destination"
    sh "cd dockerfiles/run/guice/$destinationProduct; docker cp ${containers.jamesTest}:$libPath destination"
    sh "cd dockerfiles/run/guice/$destinationProduct; docker cp ${containers.jamesTest}:${getCliJarPath(sourceProduct)} destination"
    sh "cd dockerfiles/run/guice/$destinationProduct; docker cp ${containers.jamesTest}:${getCliLibPath(sourceProduct)} destination"

    sh "cd dockerfiles/run/guice; mkdir ${pathForGlowrootFile(destinationProduct, "lib")} || true"

    sh "cd dockerfiles/run/guice/$destinationProduct; docker cp ${containers.jamesTest}:${glowrootJarPath(sourceProduct)} destination/glowroot || true"
    sh "cd dockerfiles/run/guice/$destinationProduct; docker cp ${containers.jamesTest}:${glowrootCollectorJarPath(sourceProduct)} destination/glowroot/lib || true"
    sh "cd dockerfiles/run/guice/$destinationProduct; docker cp ${containers.jamesTest}:${glowrootLogginJarPath(sourceProduct)} destination/glowroot/lib || true"

}

def deployGuiceCassandra() {
    // Start common dependencies
    sh "docker run --detach=true --name=${containers.cassandra} ${images.cassandra}"
    sh "docker run --detach=true --name=${containers.elasticSearch} --env 'discovery.type=single-node' ${images.elasticSearch}"
    try {
        waitForCommandSuccess("docker exec ${containers.cassandra} cqlsh -e 'describe columnfamily system.local;'", maxRetries)
    } catch (Exception e) {
        sh "docker logs ${containers.cassandra}"
    }

    if (rabbitMQProductExists) {
        deployGuiceRabbitMQ()
        testGuiceRabbitMQ()
    }
    dockeringGuiceCassandraRabbitMQLdap.success()
    dockeringGuiceCassandraRabbitMQ.success()
    deployingGuiceCassandraRabbitMQ.success()
    testingGuiceCassandraRabbitMQ.success()

    copyFilesFromCompilationContainer(productCassandra, jarPathCassandra, libPathCassandra)
    sh "cd dockerfiles/run/guice/cassandra; docker build --tag=${images.jamesCassandra} ."
    dockeringGuiceCassandra.success()


    sh "docker rm --force --volumes ${containers.cassandra} || true"
    sh "docker rm --force --volumes ${containers.elasticSearch} || true"
    sh "docker run --detach=true --name=${containers.cassandra} ${images.cassandra}"
    sh "docker run --detach=true --name=${containers.elasticSearch} --env 'discovery.type=single-node' ${images.elasticSearch}"
    try {
        waitForCommandSuccess("docker exec ${containers.cassandra} cqlsh -e 'describe columnfamily system.local;'", maxRetries)
    } catch (Exception e) {
        sh "docker logs ${containers.cassandra}"
    }
    sh "docker run --detach=true --name=${containers.jamesCassandra} --hostname ${hostname} --expose=${IMAP_PORT} --expose=${SMTP_PORT} --publish-all=true ${jamesLinks} ${images.jamesCassandra}"

    echo 'Waiting for James server to be deployed'
    try {
        waitForCommandSuccess("docker exec ${containers.jamesCassandra} ${jamesCliWithOptions} listusers", maxRetries)
    } catch (Exception e) {
        sh "docker logs ${containers.jamesCassandra}"
    }

    deployingGuiceCassandra.success()
}

def readBlobStoreImplementation() {
    blobStoreFileName = 'dockerfiles/run/guice/cassandra-rabbitmq-ldap/destination/conf/blob.properties'
    if (!fileExists(blobStoreFileName)) {
        return "swift"
    }
    properties = readProperties file: blobStoreFileName
    return properties["implementation"]
}

def startObjectStore() {
    switch (readBlobStoreImplementation()) {
        case "s3":
            s3_envs = "--env SCALITY_ACCESS_KEY_ID=accessKey1 --env SCALITY_SECRET_ACCESS_KEY=secretKey1 --env S3BACKEND=mem --env REMOTE_MANAGEMENT_DISABLE=1"
            sh "docker run --detach=true --name=${containers.s3} ${s3_envs} ${images.s3}"
            return rabbitmqS3Links
        default:
            sh "docker run --detach=true --name=${containers.swift} ${images.swift}"
            return rabbitmqSwiftLinks
    }
}

def deployGuiceRabbitMQ() {
    //Dockering Guice Server with Cassandra + RabbitMQ + object store + Ldap
    copyFilesFromCompilationContainer(productCassandraRabbitMQLdap, jarPathCassandraRabbitMQLdap, libPathCassandraRabbitMQLdap)

    sh "cd dockerfiles/run/guice/cassandra-rabbitmq-ldap; docker build --tag=${images.jamesCassandraRabbitMQLdap} ."

    // Deploying Guice Server with Cassandra + RabbitMQ + object store
    copyFilesFromCompilationContainer(productCassandraRabbitMQ, jarPathCassandraRabbitMQ, libPathCassandraRabbitMQ)
    sh "docker run --detach=true --name=${containers.rabbitmq} ${images.rabbitmq}"

    rabbitmqBlobLinks = startObjectStore()

    sh "cd dockerfiles/run/guice/cassandra-rabbitmq; docker build --tag=${images.jamesCassandraRabbitMQ} ."

    sh "docker run --detach=true --name=${containers.jamesCassandraRabbitMQ} --hostname ${hostname} --expose=${IMAP_PORT} --expose=${SMTP_PORT} --publish-all=true ${jamesLinks} ${rabbitmqBlobLinks} ${images.jamesCassandraRabbitMQ}"

    echo 'Waiting for James server to be deployed'
    try {
        waitForCommandSuccess("docker exec ${containers.jamesCassandraRabbitMQ} ${jamesCliWithOptions} listusers", maxRetries)
    } catch (Exception e) {
        sh "docker logs ${containers.jamesCassandraRabbitMQ}"
    }
}

def testGuiceRabbitMQ() {
    provisionDataForIntegrationTest("${containers.jamesCassandraRabbitMQ}", "${jamesCliWithOptions}")

    echo "Running integration tests on Cassandra + RabbitMQ + object store on ${buildId}"
    def jamesCassandraRabbitMQIp = containerIp("${containers.jamesCassandraRabbitMQ}")
    sh "docker run ${verbose} ${m2mount} --name=${containers.integrationCassandraRabbitMQ} ${batchModeEnv} --entrypoint=\"/root/integration_tests.sh\" --volumes-from=${containers.gitPublish} ${images.jamesCompile} ${jamesCassandraRabbitMQIp} ${IMAP_PORT} ${SMTP_PORT} ${sha1ToBuild}"
}

def testGuiceCassandra() {
    provisionDataForIntegrationTest("${containers.jamesCassandra}", "${jamesCliWithOptions}")

    echo "Running integration tests on Cassandra on ${buildId}"
    def jamesCassandraIp = containerIp("${containers.jamesCassandra}")
    sh "docker run ${verbose} ${m2mount} --name=${containers.integrationCassandra} ${batchModeEnv} --entrypoint=\"/root/integration_tests.sh\" --volumes-from=${containers.gitPublish} ${images.jamesCompile} ${jamesCassandraIp} ${IMAP_PORT} ${SMTP_PORT} ${sha1ToBuild}"

    testingGuiceCassandra.success()
}

def deployGuiceJPA() {
    copyFilesFromCompilationContainer(productJPA, jarPathJPA, libPathJPA)
    sh "cd dockerfiles/run/guice/jpa; docker build --tag=${images.jamesJPA} ."

    dockeringGuiceJPA.success()

    sh "docker run --detach=true --name=${containers.jamesJPA} --hostname ${hostname} --expose=${IMAP_PORT} --expose=${SMTP_PORT} --publish-all=true ${images.jamesJPA}"

    echo 'Waiting for James server to be deployed'
    try {
        waitForCommandSuccess("docker exec ${containers.jamesJPA} ${jamesCliWithOptions} listusers", maxRetries)
    } catch (Exception e) {
        sh "docker logs ${containers.jamesJPA}"
    }

    deployingGuiceJPA.success()
}

def testGuiceJPA() {
    provisionDataForIntegrationTest("${containers.jamesJPA}", "${jamesCliWithOptions}")

    echo "Running integration tests on JPA on ${buildId}"
    def jamesJPAIp = containerIp("${containers.jamesJPA}")
    sh "docker run ${verbose} ${m2mount} --name=${containers.integrationJPA} ${batchModeEnv} --entrypoint=\"/root/integration_tests.sh\" --volumes-from=${containers.gitPublish} ${images.jamesCompile} ${jamesJPAIp} ${IMAP_PORT} ${SMTP_PORT} ${sha1ToBuild}"

    testingGuiceJPA.success()
}

jamesCliWithOptionsSpring = ""
def deploySpringJPA() {
    sh "cd dockerfiles/run/spring; docker cp ${containers.keystore}:${keystorePath} destination/conf"

    sh "cd dockerfiles/run/spring; mkdir destination/glowroot/lib || true"

    sh "cd dockerfiles/run/spring; docker cp ${containers.jamesTest}:spring/destination/glowroot/glowroot.jar destination/glowroot || true"
    sh "cd dockerfiles/run/spring; docker cp ${containers.jamesTest}:spring/destination/glowroot/lib/glowroot-embedded-collector.jar destination/glowroot/lib || true"
    sh "cd dockerfiles/run/spring; docker cp ${containers.jamesTest}:spring/destination/glowroot/lib/glowroot-logging-logstash.jar destination/glowroot/lib || true"


    def zipPath = "/spring/destination/james-server-app-${jamesVersion}-app.zip"
    jamesCliWithOptionsSpring = "/root/james-server-app-${jamesVersion}/bin/james-cli.sh -h 127.0.0.1 -p 9999"

    sh "cd dockerfiles/run/spring; docker cp ${containers.jamesTest}:${zipPath} destination"

    sh "cd dockerfiles/run/spring; docker build --tag=${images.jamesSpring} ."

    dockeringSpringJPA.success()

    sh "docker run --detach=true --name=${containers.jamesSpring} --hostname ${hostname} --expose=${IMAP_PORT} --expose=${SMTP_PORT} --publish-all=true ${images.jamesSpring}"

    echo 'Waiting for James server to be deployed'
    try {
        waitForCommandSuccess("docker exec ${containers.jamesSpring} ${jamesCliWithOptionsSpring} listusers", maxRetries)
    } catch (Exception e) {
        sh "docker logs ${containers.jamesSpring}"
    }
    deployingSpringJPA.success()
}

def testSpringJPA() {
    provisionDataForIntegrationTest("${containers.jamesSpring}", "${jamesCliWithOptionsSpring}")

    echo "Running integration tests on ${buildId}"
    def jamesSpringIp = containerIp("${containers.jamesSpring}")
    sh "docker run ${verbose} ${m2mount} --name=${containers.integrationSpring} ${batchModeEnv} --entrypoint=\"/root/integration_tests.sh\" --volumes-from=${containers.gitPublish} ${images.jamesCompile} ${jamesSpringIp} ${IMAP_PORT} ${SMTP_PORT} ${sha1ToBuild}"

    testingSpringJPA.success()
}

def deployMemory() {
    copyFilesFromCompilationContainer(productMemory, jarPathMemory, libPathMemory)
    sh "cd dockerfiles/run/guice/memory; docker build --tag=${images.jamesMemory} ."

    dockeringMemory.success()

    sh "docker run --detach=true --name=${containers.jamesMemory} --hostname ${hostname} --expose=${IMAP_PORT} --expose=${SMTP_PORT} --publish-all=true ${images.jamesMemory}"

    echo 'Waiting for James server to be deployed'
    try {
        waitForCommandSuccess("docker exec ${containers.jamesMemory} ${jamesCliWithOptions} listusers", maxRetries)
    } catch (Exception e) {
        sh "docker logs ${containers.jamesMemory}"
    }

    deployingMemory.success()
}

def testMemory() {
    provisionDataForIntegrationTest("${containers.jamesMemory}", "${jamesCliWithOptions}")

    echo "Running integration tests on Memory on ${buildId}"
    def jamesMemoryIp = containerIp("${containers.jamesMemory}")
    sh "docker run ${verbose} ${m2mount} --name=${containers.integrationMemory} ${batchModeEnv} --entrypoint=\"/root/integration_tests.sh\" --volumes-from=${containers.gitPublish} ${images.jamesCompile} ${jamesMemoryIp} ${IMAP_PORT} ${SMTP_PORT} ${sha1ToBuild}"

    testingMemory.success()
}

def buildGuiceCassandraLdap() {
   copyFilesFromCompilationContainer(productCassandraLdap, productCassandra, jarPathCassandraLdap, libPathCassandraLdap)
    sh "cd dockerfiles/run/guice/cassandra-ldap; docker build --tag=${images.jamesCassandraLdap} ."

    dockeringGuiceCassandraLdap.success()
}

def deployGuiceDemo() {
    sh "cd dockerfiles/run/guice/provisioned; cp Dockerfile NewDockerfile; sed -i -- 's,linagora/james-jpa-guice:james-project-3.4.0,${images.jamesJPA},g' NewDockerfile"

    sh "cd dockerfiles/run/guice/provisioned; docker build --tag=${images.jamesDemoForTesting} -f NewDockerfile ."

    dockeringGuiceDemoTesting.success()

    sh "docker run --detach=true --name=${containers.jamesDemoForTesting} --hostname ${hostname} --expose=${IMAP_PORT} --expose=${SMTP_PORT} --publish-all=true ${images.jamesDemoForTesting}"

    echo 'Waiting for James server to be deployed and provision data'
    try {
        waitForCommandSuccess("docker exec ${containers.jamesDemoForTesting} ${jamesCliWithOptions} listusers", maxRetries)
    } catch (Exception e) {
        sh "docker logs ${containers.jamesDemoForTesting}"
    }

    sh "cd dockerfiles/run/guice/provisioned; rm NewDockerfile"

    deployingGuiceDemoTesting.success()
}

def publish() {
    wrap([$class: 'MaskPasswordsBuildWrapper', varPasswordPairs: [[password: "${dockerUser}", var: 'dockerUser'], [password: "${dockerPassword}", var: 'dockerPassword']]]) {
        sh "docker login -u ${dockerUser} -p ${dockerPassword}"
    }

    if (dockerTag) {
        publishTag(dockerTag)
    }
    if (isLatest == "true") {
        publishTag("latest")
    }

    publishing.success()
}

def publishTag(dockerTag) {
    sh "docker tag ${images.jamesCassandra} linagora/james-project:${dockerTag}"
    sh "docker push linagora/james-project:${dockerTag}"

    sh "docker tag ${images.jamesSpring} linagora/james-jpa-spring:${dockerTag}"
    sh "docker push linagora/james-jpa-spring:${dockerTag}"

    sh "docker tag ${images.jamesJPA} linagora/james-jpa-guice:${dockerTag}"
    sh "docker push linagora/james-jpa-guice:${dockerTag}"

    sh "docker tag ${images.jamesCassandraLdap} linagora/james-ldap-project:${dockerTag}"
    sh "docker push linagora/james-ldap-project:${dockerTag}"

    if (memoryProductExists) {
        sh "docker tag ${images.jamesMemory} linagora/james-memory:${dockerTag}"
        sh "docker push linagora/james-memory:${dockerTag}"
    }

    sh "cd dockerfiles/run/guice/provisioned; docker build --tag=${images.jamesDemo} ."

    sh "docker tag ${images.jamesDemo} linagora/james-demo:${dockerTag}"
    sh "docker push linagora/james-demo:${dockerTag}"

    if (rabbitMQProductExists) {
        sh "docker tag ${images.jamesCassandraRabbitMQLdap} linagora/james-cassandra-rabbitmq-ldap-project:${dockerTag}"
        sh "docker push linagora/james-cassandra-rabbitmq-ldap-project:${dockerTag}"

        sh "docker tag ${images.jamesCassandraRabbitMQ} linagora/james-rabbitmq-project:${dockerTag}"
        sh "docker push linagora/james-rabbitmq-project:${dockerTag}"
    }
}