build.gradle

import java.nio.charset.Charset
import java.nio.file.Files
import java.nio.file.Paths
import java.nio.file.StandardWatchEventKinds
import java.io.BufferedReader;
import java.nio.file.StandardOpenOption;
import java.net.HttpURLConnection;
import org.apache.commons.text.StringEscapeUtils;
import org.apache.commons.lang3.SystemUtils;



buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath group: 'org.apache.commons', name: 'commons-text', version: '1.1'
        classpath group: 'org.apache.commons', name: 'commons-lang3', version: '3.6'

    }
}

plugins {
    id "de.undercouch.download" version "3.1.2"
}

def isWin=System.getProperty('os.name').toLowerCase().contains('windows')
def isOSX=System.getProperty('os.name').toLowerCase().contains('mac')
def isNix=(System.getProperty('os.name').toLowerCase().contains('nix') || System.getProperty('os.name').toLowerCase().contains('aix') || System.getProperty('os.name').toLowerCase().contains('nux'))

def commandLinePrefix = []
def startUpFile = "./startup.sh"
def shutDownFile ="./shutdown.sh"
if (isWin) {
    startUpFile = "startup.bat"
    shutDownFile = "shutdown.bat"
    commandLinePrefix =["cmd","/c"]
}

def getModule() {
    if (project.hasProperty("moduleName")) {
        def moduleName=project.property("moduleName")
        moduleName=moduleName.trim().toLowerCase()
        return moduleName.trim().isEmpty()? "all" : moduleName
    } else {
        return "all"
    }
}

def getEnv(){
    if (project.hasProperty("env")) {
        def enviromentName=project.property("env")
        enviromentName=enviromentName.trim().toLowerCase()
        return enviromentName.trim().isEmpty()? "all" : enviromentName
    } else {
        return "all"
    }
}

def isAllEnvs() {
    return getEnv().equalsIgnoreCase("all")
}

ext {

    /** Unzip Properties **/
    tomcatVersion=project.hasProperty("tomcat.version")? project.property("tomcat.version") : "8.5.6"
    solrVersion=project.hasProperty("solr.version")? project.property("solr.version") : "6.4.1"
    downloadDir=project.hasProperty("downloadDir")? project.property("downloadDir") : "./downloads/"
    /** Environment Building properties **/
    authEnv=project.hasProperty("authoring.root")? project.property("authoring.root") : "./crafter-authoring/"
    deliveryEnv=project.hasProperty("delivery.root")? project.property("delivery.root") : "./crafter-delivery/"
    includeProfile=project.hasProperty("crafter.profile")? project.property("crafter.profile") : false
    includeSocial=project.hasProperty("crafter.social")? project.property("crafter.social") : false

    /** Social Need Profile **/
    if (includeSocial) {
        includeProfile=true
    }

    //Authoring
    authTomcatPort=project.hasProperty("authoring.tomcat.http.port")? project.property("authoring.tomcat.http.port") : 8080
    authTomcatShutdownPort=project.hasProperty("authoring.tomcat.shutdown.port")? project.property("authoring.tomcat.shutdown.port") : 8005
    authTomcatAJPPort=project.hasProperty("authoring.tomcat.ajp.port")? project.property("authoring.tomcat.ajp.port") : 8009
    authTomcatSSLPort=project.hasProperty("authoring.tomcat.https.port")? project.property("authoring.tomcat.https.port") : 8443
    authTomcatDebug=project.hasProperty("authoring.tomcat.debug.port")? project.property("authoring.tomcat.debug.port") : 8000
    authMongoDBPort=project.hasProperty("authoring.mongo.port")? project.property("authoring.mongo.port") : 27020
    authSolrPort=project.hasProperty("authoring.solr.port")? project.property("authoring.solr.port") : 8694
    authSolrDebugPort=project.hasProperty("authoring.solr.debug.port")? project.property("authoring.solr.debug.port") : 5005

    authMariaDbPort=project.hasProperty("authoring.mariadb.port")? project.property("authoring.mariadb.port") : 33306

    authDeployerPort=project.hasProperty("authoring.deployer.port")? project.property("authoring.deployer.port") : 9191
    authDeployerDebugPort=project.hasProperty("authoring.deployer.debug.port")? project.property("authoring.deployer.debug.port") : 5000
    authDeploymentDir=project.hasProperty("authoring.deployment.dir")? project.property("authoring.deployment.dir") : "data/repos/sites"


    // Delivery
    deliverySolrPort=project.hasProperty("delivery.solr.port")? project.property("delivery.solr.port") : 8695
    deliverySolrDebugPort=project.hasProperty("delivery.solr.debug.port")? project.property("delivery.solr.debug.port") : 5006

    deliveryDeployerPort=project.hasProperty("delivery.deployer.port")? project.property("delivery.deployer.port") : 9192
    deliveryDeployerDebugPort=project.hasProperty("delivery.deployer.debug.port")? project.property("delivery.deployer.debug.port") : 5001
    deliveryDeploymentDir=project.hasProperty("delivery.deployment.dir")? project.property("delivery.deployment.dir") : "data/repos/sites"

    deliveryTomcatPort=project.hasProperty("delivery.tomcat.http.port")? project.property("delivery.tomcat.http.port") : 9080
    deliveryTomcatShutdownPort=project.hasProperty("delivery.tomcat.shutdown.port")? project.property("delivery.tomcat.shutdown.port") : 9005
    deliveryTomcatAJPPort=project.hasProperty("delivery.tomcat.ajp.port")? project.property("delivery.tomcat.ajp.port") : 9009
    deliveryTomcatSSLPort=project.hasProperty("delivery.tomcat.https.port")? project.property("delivery.tomcat.https.port") : 9443
    deliveryTomcatDebugPort=project.hasProperty("delivery.tomcat.debug.port")? project.property("delivery.tomcat.debug.port") : 9000
    deliveryMongoDBPort=project.hasProperty("delivery.mongodb.port")? project.property("delivery.mongodb.port") : 28020


    /** Git properties **/
    gitURLTemplate=project.hasProperty("crafter.git.url")? project.property("crafter.git.url") : "https://github.com/craftercms/"
    gitSourceBranch=project.hasProperty("crafter.git.branch")? project.property("crafter.git.branch") : "master"
    gitRepo=project.hasProperty("crafter.git.remote")? project.property("crafter.git.remote") : "origin"
    shallowClone=project.hasProperty("crafter.git.shallowClone")? project.property("crafter.git.shallowClone") : false
    studioUIFromRepo=project.hasProperty("crafter.ui.repo")? project.property("crafter.ui.repo") : false
    forceDeploy=project.hasProperty("forceDeploy")? project.property("forceDeploy") : false
    keepBin=project.hasProperty("keepBin")? project.property("keepBin") : false

    testingPlatform=project.hasProperty("crafter.testing.platform")? project.property("crafter.testing.platform") : System.properties['os.name'].toString().toLowerCase().replaceAll(" ","-")
    chromeDriverVersion=project.hasProperty("crafter.testing.chrome")? project.property("crafter.testing.chrome") : 2.31
    browserToTest=project.hasProperty("crafter.testing.browser")? project.property("crafter.testing.browser") : "chrome"
    testArtifacts=project.hasProperty("crafter.unittest") ? project.property("crafter.unittest") : false

    /** Clonable Artifacts **/
    VALID_MODULES=["commons", "core", "search", "profile", "engine", "deployer", "studio", "social", "studio-ui", "test-suite"]
    /** Deployable Artifacts **/
    VALID_DEPLOYABLE_MODULES=[
            "search":"./src/search/crafter-search-server/target/crafter-search.war",
            "profile":"./src/profile/server/target/crafter-profile.war",
            "engine":"./src/engine/target/ROOT.war",
            "deployer":"./src/deployer/target/crafter-deployer.jar",
            "studio":"./src/studio/target/studio.war",
            "social":"./src/social/server/target/crafter-social.war"]
    WINDOWS_EDGE_DRIVER_URL = [
        "15063" : "https://download.microsoft.com/download/3/4/2/342316D7-EBE0-4F10-ABA2-AE8E0CDF36DD/MicrosoftWebDriver.exe",
        "14393" : "https://download.microsoft.com/download/3/2/D/32D3E464-F2EF-490F-841B-05D53C848D15/MicrosoftWebDriver.exe",
        "10586" :  "https://download.microsoft.com/download/C/0/7/C07EBF21-5305-4EC8-83B1-A6FCC8F93F45/MicrosoftWebDriver.msi",
        "10240" : "https://download.microsoft.com/download/8/D/0/8D0D08CF-790D-4586-B726-C6469A9ED49C/MicrosoftWebDriver.msi"
    ]

}

apply from:"downloads.gradle"
apply from:"environments.gradle"

task("utils"){
    description "builds the utils project and copies the utils jar file to the environment"

    doLast {
        buildModule(commandLinePrefix, "utils", "./")
        copy {
            from "./utils/target/craftercms-utils.jar"
            into "${authEnv}/bin"
        }
        copy {
            from "./utils/target/craftercms-utils.jar"
            into "${deliveryEnv}/bin"
        }
    }
}

task("upgrade"){
    description "Upgrades the installed tomcat version, solr scripts, etc. without deleting your data then builds and deploys"

    doLast {
        def authEnvFolder = new File("${authEnv}")
        if (authEnvFolder.exists()) {
            authEnvFolder.eachFile { dir ->
                if (!dir.getName().equalsIgnoreCase("data")) {
                    if (!dir.isFile()) {
                        dir.deleteDir()
                    } else {
                        dir.delete()
                    }
                }
            }
        }
        update.execute();
        forceDeploy=true
        build.execute()
        deploy.execute()
    }
}

task("init"){
    description "Clones Crafter CMS stack"

    doFirst{
        def module = getModule();
    }
    doLast {
        if (module.equals("all")) {
            VALID_MODULES.each {
                cloneModule(commandLinePrefix, it).execute()
            }
        } else if (VALID_MODULES.contains(module)) {
            cloneModule(commandLinePrefix, module).execute()
        } else {
            throw new InvalidUserDataException("${module} is not a valid module, please one of ${VALID_MODULES}")
        }
    }

}

task("update") {
    description "Update the various modules of Crafter CMS"
    doFirst{
        def module = getModule();
    }

    doLast {

        if (module.equals("all")) {
            VALID_MODULES.each {
                updateModule(commandLinePrefix, it).execute()
            }
        } else if (VALID_MODULES.contains(module)) {
            updateModule(commandLinePrefix, module).execute()
        } else {
            throw new InvalidUserDataException("${module} is not a valid module, please use one of ${VALID_MODULES}")
        }
    }
}

task("selfupdate") {
    description "Updates the Crafter CMS project"
    doLast {
        def arry = commandLinePrefix + ["git", "pull", gitRepo, gitSourceBranch]
        executeProcess(arry,".")
    }
}

task("start") {
    description "Start Crafter CMS"

    doLast {
        def env = getEnv()
        println "Running for the first time might take longer while fetching OS dependent requirements."
        switch (env) {
            case "all":
                if(!file(authEnv).exists() || !file(deliveryEnv).exists()){
                    throw new InvalidUserDataException("Neither enviroment ('authoring'/'delivery') are deployed. Please run deploy before 'start'.")
                }
                startAuth(commandLinePrefix, startUpFile).execute()
                startDelivery(commandLinePrefix, startUpFile).execute()
                break
            case "authoring":
                if (!file(authEnv).exists()) {
                    throw new InvalidUserDataException("The 'authoring' enviroment is not deployed. Please run 'deploy -Penv=authoring' before 'start'.")
                }
                startAuth(commandLinePrefix, startUpFile).execute()
                break
            case "delivery":
                if (!file(deliveryEnv).exists()) {
                    throw new InvalidUserDataException("The 'delivery' enviroment is not deployed. Please run 'deploy -Penv=delivery' before 'start'.")
                }
                startDelivery(commandLinePrefix, startUpFile).execute()
                break
            default:
                throw new InvalidUserDataException("'${env}' is not a valid environment, please use 'authoring' or 'delivery'.")
        }
    }
}

task("stop") {
    description "Stop Crafter CMS"

    doLast {
        def env = getEnv()
        switch (env) {
            case "all":
                if (!file(authEnv).exists() || !file(deliveryEnv).exists()) {
                    throw new InvalidUserDataException("Neither enviroment ('authoring'/'delivery') are deployed. Please run deploy before 'stop'.")
                }
                stopAuth(commandLinePrefix,shutDownFile).execute()
                stopDelivery(commandLinePrefix, shutDownFile).execute()
            case "authoring":
                if (!file(authEnv).exists()) {
                    throw new InvalidUserDataException("The 'authoring' enviroment is not deployed. Please run 'deploy -Penv=authoring' before 'stop'.")
                }
                stopAuth(commandLinePrefix, shutDownFile).execute()
                break
            case "delivery":
                if (!file(deliveryEnv).exists()) {
                    throw new InvalidUserDataException("The 'delivery' enviroment is not deployed. Please run 'deploy -Penv=delivery' before 'stop'.")
                }
                stopDelivery(commandLinePrefix, shutDownFile).execute()
                break
            default:
                throw new InvalidUserDataException("'${env}' is not a valid environment, please use 'authoring' or 'delivery'.")
        }
    }
}

task("clean") {
    description "Clean Crafter CMS stack"

    doFirst {
        def module = getModule();
    }

    doLast {
        if (module.equals("all")) {
            VALID_MODULES.each {
                if(!(it.equalsIgnoreCase("studio-ui")||(it.equalsIgnoreCase("test-suite")))) { // Not a pom project ignore
                    cleanModule(commandLinePrefix, it).execute()
                }
            }
        } else if (VALID_MODULES.contains(module)) {
            if(!(module.equalsIgnoreCase("studio-ui")||(module.equalsIgnoreCase("test-suite")))) { // Not a pom project ignore
                cleanModule(commandLinePrefix, module).execute()
            }
        } else {
            throw new InvalidUserDataException("${module} is not a valid module, please use one of ${VALID_MODULES}")
        }
    }
}

task("build") {
    description "Builds Crafter CMS"

    doFirst {
        def module = getModule();
    }

    doLast {
        if (module.equals("all")) {
            VALID_MODULES.each {
                if (!(it.equalsIgnoreCase("studio-ui")||(it.equalsIgnoreCase("test-suite")))) {
                    buildModule(commandLinePrefix, it).execute()
                }
            }
        } else if (VALID_MODULES.contains(module)) {
            if (!(module.equalsIgnoreCase("studio-ui")||(module.equalsIgnoreCase("test-suite")))) {
                buildModule(commandLinePrefix, module).execute()
            }
        } else {
            throw new InvalidUserDataException("${module} is not a valid module, please use one of ${VALID_MODULES}")
        }
    }
}

task("test") {
    description "Builds and run tests"
    doFirst {
        def driverPath=""
        switch (browserToTest.toString().toLowerCase()){
            case "chrome":
                downloadChromeDriver.execute()
                if(SystemUtils.IS_OS_WINDOWS){
                    driverPath=file("./src/test-suite/bin/${browserToTest}-${testingPlatform}/chromedriver.exe")
                }else{
                    driverPath=file("./src/test-suite/bin/${browserToTest}-${testingPlatform}/chromedriver")
                }
                break;
            case "edge":
                downloadEdgeDriver.execute();
                driverPath=file("./src/test-suite/bin/${browserToTest}/MicrosoftWebDriver.exe")
                break
            default:
                driverPath=askForPath();
        }
        if(!file("./src/test-suite/test-properties.properties").exists()){
            def properties = []
            properties.add("webBrowser=${browserToTest}")
            properties.add("baseUrl=http://localhost:8080/studio/#/login")
            properties.add("${browserToTest}.driver.path=${StringEscapeUtils.escapeJava(file(driverPath).absolutePath)}")
            Files.write(Paths.get("./src/test-suite/test-properties.properties"), properties, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)
        }
    }
    
    doLast{
       startAuth(commandLinePrefix, startUpFile)
       try {
              //  waitUntilAuthIsUp(10)//10*30sec
                buildModule(commandLinePrefix,
                        "test-suite", "./src/",
                        ["-Dfile=src/test/resources/testng.xml,src/test/resources/testngcomplexscenarios.xml,src/test/resources/testngAPI.xml"],
                        true)

        }catch (GradleException ex){ // no nothing
        } finally {
            stopAuth(commandLinePrefix, shutDownFile)
        }        
    }
}
task("deploy") {
    description "Setup the Crafter CMS environment/s"

    doLast {
        def module = getModule()
        def env = getEnv()
        switch (env){
            case "all":
                checkEnvWD(authEnv, "authoring")
                checkEnvWD(deliveryEnv, "delivery")
                break
            case "authoring":
                checkEnvWD(authEnv, env)
                break
            case "delivery":
                checkEnvWD(deliveryEnv, env)
                break
            default:
                throw new InvalidUserDataException("'${env}' is not a valid environment, please use 'authoring' or 'delivery'.")
        }



        if (module.equals("all")) {
            VALID_DEPLOYABLE_MODULES.keySet().each {
                if (isAllEnvs()) {
                    deployModule(commandLinePrefix, it, "authoring").execute()
                    deployModule(commandLinePrefix, it, "delivery").execute()
                } else {
                    deployModule(commandLinePrefix, it, env).execute()
                }
                if(!keepBin) {
                    file(VALID_DEPLOYABLE_MODULES[it]).delete()
                }
            }
        } else if (VALID_DEPLOYABLE_MODULES.containsKey(module)) {
            if (isAllEnvs()) {
                deployModule(commandLinePrefix, module, "authoring").execute()
                deployModule(commandLinePrefix, module, "delivery").execute()
            } else {
                deployModule(commandLinePrefix, module, env).execute()
            }
            if (!keepBin) {
                file(VALID_DEPLOYABLE_MODULES[module]).delete()
            }
        } else {
            throw new InvalidUserDataException("${module} is not a valid module, please use one of ${VALID_DEPLOYABLE_MODULES.keySet()}")
        }
        utils.execute()
    }
}

task("bundle") {
    description "Builds a deployable and distributable bundle of Crafter CMS"

    doLast {
        def env = getEnv()
        switch (env) {
            case "all":
                pack(authEnv, "authoring")
                pack(deliveryEnv, "delivery")
                break
            case "authoring":
                pack(authEnv, "authoring")
                break
            case "delivery":
                pack(deliveryEnv, "delivery")
                break
            default:
                throw new InvalidUserDataException("'${env}' is not a valid environment, please use 'authoring' or 'delivery'.")
        }
    }
}


def cleanModule(commandLinePrefix, module) {
    def ctask=tasks.findByPath("clean${module}")
    if (ctask!= null) {
        return ctask
    } else {
        return tasks.create("clean${module}") {
            executeProcess(commandLinePrefix +  commandLinePrefix + ["mvn", "clean"], "./src/${module}".toString())
        }
    }
}

def updateModule(commandLinePrefix, module) {
    def btask=tasks.findByPath("update${module}")
    if (btask!= null) {
        return btask
    } else {
        return tasks.create("update${module}") {
            if (!file("./src/${module}").exists()) {
                throw new InvalidUserDataException("Module ${module} is not initialized. Please use 'update' to initialize it.")
            } else {
                def arry = commandLinePrefix + ["git", "pull", gitRepo, gitSourceBranch]
                executeProcess(arry,"./src/${module}".toString())
            }
        }
    }
}

def cloneModule(commandLinePrefix, module){
    def btask=tasks.findByPath("clone${module}")
    if (btask!= null) {
        return btask
    } else {
        return tasks.create("clone${module}") {
            def finalUrl = "${gitURLTemplate}${module}.git".toString()
            def path = "src/${module}".toString()
            def gitCloneCmd = ["git","clone"]
            if(shallowClone){
                gitCloneCmd.add("--depth")
                gitCloneCmd.add("1")
            }
            def arry = commandLinePrefix + gitCloneCmd+["-b",gitSourceBranch,finalUrl,path]
            if (file(path).exists()) {
                println ("Module ${module} has already been initialized, please use " +
                        "'update' to update it.")
            } else {
                println "Cloning: ${module}, branch: ${gitSourceBranch}, url: ${finalUrl}"
                executeProcess(arry,".")
            }
        }
    }
}

def startAuth(commandLinePrefix, startUpFile) {
    def btask = tasks.findByPath("startAuth")
    if (btask!= null){
        return btask
    } else {
        tasks.create("startAuth") {
            executeProcess(commandLinePrefix + [startUpFile], "$authEnv/bin",true)
        }
    }
}

def startDelivery(commandLinePrefix, startUpFile){
    def btask=tasks.findByPath("startDelivery")
    if (btask!= null) {
        return btask
    } else {
        tasks.create("startDelivery") {
            executeProcess(commandLinePrefix + [startUpFile], "$deliveryEnv/bin", true)
        }
    }
}

def stopAuth(commandLinePrefix, shutDownFile) {
    def btask = tasks.findByPath("stopAuth")
    if (btask!= null) {
        return btask
    } else {
        tasks.create("stopAuth") {
            executeProcess(commandLinePrefix + [shutDownFile], "$authEnv/bin", true)
        }
    }
}

def stopDelivery(commandLinePrefix, shutDownFile) {
    def btask=tasks.findByPath("stopDelivery")
    if (btask!= null) {
        return btask
    } else {
        tasks.create("stopDelivery") {
            executeProcess(commandLinePrefix + [shutDownFile], "$deliveryEnv/bin", true)
        }
    }
}

def buildModule(commandLinePrefix, module, path="./src/", commandLinePost=[], forceTest=false) {
    def btask=tasks.findByPath("build${module}")
    def actualCommandLinePost = [];
    actualCommandLinePost.addAll(commandLinePost)
    if(!testArtifacts && !forceTest){ //ForceTest is needed to make test-suite run since, well they are tests
        actualCommandLinePost.add("-Dmaven.test.skip=true")
        // Ignore integration test to avoid starting mongo and jetty for nothing
        if(module.equalsIgnoreCase("search")){
            actualCommandLinePost.add("-pl")
            actualCommandLinePost.add("!crafter-search-itest")
        }else if(module.equalsIgnoreCase("profile")){
            actualCommandLinePost.add("-pl")
            actualCommandLinePost.add("!integration-tests")
        }
    }

    if (btask!= null) {
        return btask
    } else {
        return tasks.create("build${module}") {
            if(module.equalsIgnoreCase("studio") && !studioUIFromRepo) {
                actualCommandLinePost.add("-Dstudio.ui.path=../studio-ui/".toString())
                actualCommandLinePost.add("-Dexec.skip=true")
            }
            // Always do a Clean build, never trust caches or FS.
            def array=commandLinePrefix +  commandLinePrefix + ["mvn", "clean", "install"] + actualCommandLinePost
            executeProcess(array, "${path}${module}".toString())
        }
    }
}

def deployBinary(deployable, env){
    if (deployable.exists()) {
        def path = env.equals("authoring")? authEnv : deliveryEnv
        path += deployable.absolutePath.endsWith(".jar")? "bin/crafter-deployer/" : "bin/apache-tomcat/webapps/"
        path += deployable.name
        delete {
            delete path
            delete path.take(path.lastIndexOf('.'))
        }
        copy {
            from deployable.absolutePath
            into path.take(path.lastIndexOf('/'))
        }
    } else {
        println "WARN: You haven't built ${module} module"
    }
}

def deployModule(commandLinePrefix, module, env) {
    def dtask=tasks.findByPath("deploy${module}${env}")
    if (dtask!= null) {
        return dtask
    } else {
        return tasks.create("deploy${module}${env}") {
            println "Deploy ${module} to ${env}"
            if (module.equals("studio") && env.equals("delivery")) {
                println "Ignoring module 'studio' can not be deployed in environment 'delivery'"
            } else if((module.equals("profile") && !includeProfile) || (module.equals("social") && !includeSocial)) {
                println "Ignoring module '$module' not enabled for environment '$env'"
            } else {
                def deployable = file(VALID_DEPLOYABLE_MODULES[module])
                deployBinary(deployable, env)
                if(module.equalsIgnoreCase("profile")){
                    deployBinary(file("./src/profile/admin-console/target/crafter-profile-admin.war"), env)
                } else if (module.equalsIgnoreCase("social")) {
                    deployBinary(file("./src/social/admin/target/crafter-social-admin.war"), env)
                }
            }
        }
    }
}

def checkEnvWD(path, env) {
    def ddir = file(path)
    if (!ddir.exists() || forceDeploy) {
        ddir.mkdir()
        def deployerDir = file("${path}/bin/crafter-deployer")
        deployerDir.mkdir()
        downloadTomcat.execute()
        downloadSolr.execute()
        if (env.equals("authoring")) {
            authoringEnvironment.execute()
        } else if (env.equals("delivery")) {
            deliveryEnvironment.execute()
        }
    }
}

def pack(environmentPath,envName){
    def dtask=tasks.findByPath("tar${envName}")
    if (dtask!= null) {
        return dtask
    } else {
        def zipTask = tasks.findByPath("zip${envName}")
        if (zipTask != null) {
            zipTask.execute()
        } else {
            tasks.create("zip${envName}", Zip.class) {
                from(environmentPath) {
                    into("crafter")
                }
                archiveName "crafter-cms-${envName}.zip"
                fileMode null
                dirMode null
                includeEmptyDirs true
                metadataCharset "UTF-8"
                caseSensitive false
                destinationDir(file("bundles/"))
            }.execute()
        }

        def tarTask = tasks.findByPath("tar${envName}")
        if (tarTask != null) {
            tarTask.execute()
        } else {
            tasks.create("tar${envName}", Tar.class) {
                from(environmentPath) {
                    into("crafter")
                }
                archiveName "crafter-cms-${envName}.tar.gz"
                fileMode null
                dirMode null
                includeEmptyDirs true
                caseSensitive false
                compression = Compression.GZIP
                destinationDir(file("bundles/"))
            }.execute()
        }
    }
}

def executeProcess(command, workingDir, printOutputUntilFinish = false) {
    ProcessBuilder pb = new ProcessBuilder(command)
    def processOutput = File.createTempFile("process", "out")
    pb.directory(new File(workingDir))
    pb.redirectOutput(processOutput)
    Process proc = pb.start();
    watchProcessOutput(proc,processOutput)
    proc.waitFor()
    if (proc.exitValue() != 0) {
        throw new GradleException("${command} @ ${workingDir} return a  non-zero value (${proc.exitValue()})")
    }
}

// Poor's man tail (but get's the job done
def watchProcessOutput(process, processOutputFile){
    Thread.start {

        def reader=null
        if(System.getProperty('os.name').toLowerCase().contains('windows')){
            reader = Files.newBufferedReader(Paths.get(processOutputFile.path), Charset.forName("ISO-8859-1"))
        }else{
            reader = Files.newBufferedReader(Paths.get(processOutputFile.path), Charset.forName("UTF-8"))
        }
        while(process.alive) {
            // Thread.sleep(100)
            def line=null
            while((line=reader.readLine()) != null) {
                println line
            }
        }
        processOutputFile.delete()
    }
}

def askForPath(){
    def console = System.console();
    def inputPath = console.readLine("> Please enter path for selemiun driver of ${browserToTest} ")
    if(!file(inputPath).exists()){
        console.println("${inputPath} does not exist, please enter a new valid path");
        askForPath();
    }
    return inputPath
}

def waitUntilAuthIsUp(tryThinsManyTimes){
    if(tryThinsManyTimes<=0){
        return false
    }else{
        try{
            URL url = new URL("http://localhost:${authTomcatPort}/studio");
            HttpURLConnection huc = (HttpURLConnection) url.openConnection();
            HttpURLConnection.setFollowRedirects(false);
            huc.setConnectTimeout(30000);
            huc.setRequestMethod("GET");
            huc.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.1.2) Gecko/20090729 Firefox/3.5.2 (.NET CLR 3.5.30729)");
            huc.connect();
            return true
        }catch(java.net.SocketTimeoutException | java.net.ConnectException ex){
            println "Studio is not Ready yet trying again"
            waitUntilAuthIsUp(tryThinsManyTimes-1)
        }
    }
}