build.groovy

#!/usr/bin/env groovy
import static java.lang.System.*
import static java.lang.System.getenv

VERSION = new File("${getRoot()}/babun.version").text.trim()
BUILD=new Date().format('yyyy-MM-dd')

execute()

def execute() {
    log "EXEC"
    checkArguments()
    String mode = this.args[0]
    if (mode == "clean") {
        doClean()
    } else if (mode == "partclean") {
        doPartClean()
    } else if (mode == "cygwin") {
        executeBabunCygwin()
    } else if (mode == "package") {
        doPackage()
    } else if (mode == "release") {
        doRelease()
    } else if (mode == "dist") {
        executeBabunDist()
    } else if (mode == "core") {
        executeBabunCore()
    } else if (mode == "packages") {
        executeBabunPackages()
    } else if (mode == "cygwin") {
        executeBabunCygwin()
    } else if (mode == "cleandist"){
        doPartClean()
		doPackage()
	}
    
    log "FINISHED"
}

def checkArguments() {
    if (this.args.length != 1 || !this.args[0].matches("clean|partclean|packages|cygwin|core|dist|package|release|cleandist")) {
        err.println "Usage: build.groovy <clean|partclean|packages|cygwin|core|dist|package|release|cleandist>"
        exit(-1)
    }
}

def initEnvironment() {
    File target = getTarget()
    if (!target.exists()) {
        target.mkdir()
    }
}

def doPartClean() {
    log "EXEC partclean"
    File target = getTarget()
    if (target.exists()) {
        if (!(new File(target,"babun-cygwin")).deleteDir()) {
            throw new RuntimeException("Cannot delete target/babun-core folder")
        }
		if (!(new File(target,"babun-core")).deleteDir()) {
            throw new RuntimeException("Cannot delete target/babun-core folder")
        }
        if (!(new File(target,"babun-dist")).deleteDir()) {
            throw new RuntimeException("Cannot delete target/babun-dist folder")
        }
    }
}

def doClean() {
    log "EXEC clean"
    File target = getTarget()
    if (target.exists()) {
        if (!target.deleteDir()) {
            throw new RuntimeException("Cannot delete target folder")
        }
    }
}

def doPackage() {
    log "EXEC package"  
    executeBabunPackages()  
    executeBabunCygwin()
    executeBabunCore()
    executeBabunDist()
}

def doRelease() {
    log "EXEC release"
    doPackage()
    executeRelease()
}

def executeBabunPackages(){
	File confFolder = new File(getRoot(), "babun-packages/conf/")
	File outputFolder = new File(getTarget(), "babun-packages")
	outputFolder.mkdirs()
    String setupVersion
    try {
        downloadPackages(confFolder, outputFolder, "x86_64")
        copyPackagesListToTarget(confFolder, outputFolder, "x86_64")
    } catch (Exception ex) {
        log("Unexpected error occurred: " + ex + " . Quitting!")
        ex.printStackTrace()
        exit(-1)
    }
}

def downloadPackages(File confFolder, File outputFolder, String bitVersion) {
    File packagesFile = new File(confFolder, "cygwin.${bitVersion}.packages")
    def rootPackages = packagesFile.readLines().findAll() { it }
    def repositories = new File(confFolder, "cygwin.repositories").readLines().findAll() { it }
    def processed = [] as Set
    for (repo in repositories) {
        String setupIni = downloadSetupIni(repo, bitVersion, outputFolder)
        new File(outputFolder,"cygwin.version").withWriter('utf-8') {
            writer -> writer.writeLine(getCygwinVersion(setupIni))
        }
        for (String rootPkg : rootPackages) {
            if (processed.contains(rootPkg.trim())) continue
            def processedInStep = downloadRootPackage(repo, setupIni, rootPkg.trim(), processed, outputFolder)
            processed.addAll(processedInStep)
        }
        rootPackages.removeAll(processed)
        if (rootPackages.isEmpty()) {
            return
        }
    }
    if (!rootPackages.isEmpty()) {
        error("Could not download the following ${rootPackages}! Quitting!")
        exit(-1)
    }
}

def downloadSetupIni(String repository, String bitVersion, File outputFolder) {
    log "Downloading [setup.ini] from repository [${repository}]"
    String setupIniUrl = "${repository}/${bitVersion}/setup.ini"
    
	
	File outputFile = new File(new File(outputFolder, "${repository.split("/")[2]}/${bitVersion}"), "setup.ini")
	outputFile.getParentFile().mkdirs()
	outputFile.createNewFile()
	use(FileBinaryCategory) {
		outputFile << setupIniUrl.toURL()
	}
    
    return outputFile.text
}

def downloadRootPackage(String repo, String setupIni, String rootPkg, Set<String> processed, File outputFolder) {
    def processedInStep = [] as Set
    log "Processing top-level package [$rootPkg]"
    def packagesToProcess = [] as Set
    try {
        buildPackageDependencyTree(setupIni, rootPkg, packagesToProcess)
        for (String pkg : packagesToProcess) {
            if (processed.contains(pkg) || processedInStep.contains(pkg)) continue
            String pkgInfo = parsePackageInfo(setupIni, pkg)
            String pkgPath = parsePackagePath(pkgInfo)
            if (pkgPath) {
                log "  Downloading package [$pkg]"
                if (downloadPackage(repo, pkgPath, outputFolder)) {
                    processedInStep.add(pkg)
                }
            } else if (pkgInfo) {
                // packages doesn't have binary file
                processedInStep.add(pkg)
            } else {
                log "  Cannot find package [$pkg] in the repository"
                processedInStep = [] as Set // reset as the tree could not be fetched
                break;
            }
        }
    } catch (Exception ex) {
        error("Could not download dependency tree for [$rootPkg]")
        ex.printStackTrace()
        processedInStep = [] as Set
    }
    processedInStep
}

def buildPackageDependencyTree(String setupIni, String pkgName, Set<String> result) {
    String pkgInfo = parsePackageInfo(setupIni, pkgName)

    if (!pkgInfo) {
                pkgName=pkgName.replace("perl5_026","perl5_032")
        pkgInfo = setupIni?.split("(?=@ )")?.find() { it.contains("provides: ${pkgName}") }
        if(!pkgInfo){
            throw new RuntimeException("Cannot find dependencies of [${pkgName}]")
        }
        log "  Parsing virtual package [${pkgName}]"
        String newPkgName=parsePackageName(pkgInfo);
        log "    parsed as [${newPkgName}]"
        result.add(newPkgName)

    }else{
        result.add(pkgName)
    }
    String[] deps = parsePackageRequires(pkgInfo)
    for (String dep : deps) {
        if (!result.contains(dep.trim())) {
            buildPackageDependencyTree(setupIni, dep.trim(), result)
        }
    }
}

def parsePackageRequires(String pkgInfo) {
    String requires = pkgInfo?.split("\n")?.find() { it.startsWith("depends2:") }
    return requires?.replace("depends2:", "")?.replace(",","")?.replace(" _windows ( >= 6.1 )","")?.replace(" _windows ( >= 6.3 )","")?.trim()?.split("\\s")
}

def getCygwinVersion(String setupIni){
    String version = setupIni?.split("(?=@)")?.find(){it.startsWith("@ cygwin")}.split("\n").find(){it.startsWith("version: ")}.replace("version:","").trim();
    return version
}

def parsePackageName(String pkgInfo) {
    String name = pkgInfo?.split("\n")?.find() { it.startsWith("@ ") }
    return name?.replace("@ ", "")?.trim()
}

def parsePackageInfo(String setupIni, String packageName) {
    return setupIni?.split("(?=@ )")?.find() { it.contains("@ ${packageName}") }
}

def parsePackagePath(String pkgInfo) {
    String version = pkgInfo?.split("\n")?.find() { it.startsWith("install:") }
    String[] tokens = version?.replace("install:", "")?.trim()?.split("\\s")
    return tokens?.length > 0 ? tokens[0] : null
}

def downloadPackage(String repositoryUrl, String packagePath, File outputFolder) {
    String packageUrl = repositoryUrl + packagePath
	String repoName = packageUrl.split("/")[2]
	String outputPath = "${outputFolder.getAbsolutePath()}/${repoName}/${packagePath}"
	downloadFile(packageUrl, new File(outputPath), false)
    return true
}

def copyPackagesListToTarget(File confFolder, File outputFolder, String bitVersion) {
    File packagesFile = new File(confFolder, "cygwin.${bitVersion}.packages")
    File outputFile = new File(outputFolder, "cygwin.${bitVersion}.packages")
    outputFile.createNewFile()
    outputFile << packagesFile.text
}

def downloadCygwinInstaller(File outputFolder) {    
    File cygwinInstaller = new File(outputFolder, "setup-x86_64.exe")
    if(!cygwinInstaller.exists()) {
        println "Downloading Cygwin installer"
        use(FileBinaryCategory) {
            cygwinInstaller << "http://cygwin.com/setup-x86_64.exe".toURL()
        }
    } else {
        println "Cygwin installer alread exists, skipping the download!";
    }

    return cygwinInstaller
}

def installCygwin(File cygwinInstaller, File repoFolder, File cygwinFolder, File pkgsFile) {    
    err.println "Installing cygwin"
    String pkgs = pkgsFile.text.trim().replaceAll("(\\s)+", ",")    
    err.println "Packages to install: ${pkgs}"
    String installCommand = "\"${cygwinInstaller.absolutePath}\" " +
            "--quiet-mode " +
            "--local-install " +
            "--local-package-dir \"${repoFolder.absolutePath}\" " +
            "--root \"${cygwinFolder.absolutePath}\" " +
            "--no-shortcuts " +
            "--no-startmenu " +
            "--no-desktop " +
            "--packages " + pkgs
    err.println installCommand
    executeCmd(installCommand)
}


def executeBabunCygwin(boolean downloadOnly = false){
	File repoFolder = new File(getTarget(), "babun-packages")
	File inputFolder = new File(getRoot(), "babun-cygwin")
	File outputFolder = new File(getTarget(), "babun-cygwin")
	outputFolder.mkdirs()
    File cygwinFolder = new File(outputFolder, "cygwin")
	cygwinFolder.mkdirs()
	
	pkgsFile = new File(getRoot(), "babun-packages/conf/cygwin.x86_64.packages")
    try {
        
        File cygwinInstaller = downloadCygwinInstaller(outputFolder)
        if(downloadOnly) {
            println "downloadOnly flag set to true - Cygwin installation skipped.";
            return
        }
        installCygwin(cygwinInstaller, repoFolder, cygwinFolder, pkgsFile)
        //cygwinInstaller.delete()

        // handle symlinks
        copySymlinksScripts(inputFolder, cygwinFolder)
        findSymlinks(cygwinFolder)
        new AntBuilder().copy( 
            file:"${repoFolder.absolutePath}/cygwin.version", 
            tofile:"${outputFolder.absolutePath}/cygwin/usr/local/etc/babun/installed/cygwin" 
        )
    } catch (Exception ex) {
        error("ERROR: Unexpected error occurred: " + ex + " . Quitting!", true)
        ex.printStackTrace()
        exit(-1)
    }
}

def copySymlinksScripts(File inputFolder, File cygwinFolder) {
	new AntBuilder().copy(todir: "${cygwinFolder.absolutePath}/etc/postinstall", quiet: true) {
        fileset(dir: "${inputFolder.absolutePath}/symlinks", defaultexcludes:"no")
    }    
}

def findSymlinks(File cygwinFolder) {
    String symlinksFindScript = "/etc/postinstall/symlinks_find.sh"
    String findSymlinksCmd = "${cygwinFolder.absolutePath}/bin/bash.exe --norc --noprofile \"${symlinksFindScript}\""
    executeCmd(findSymlinksCmd)
    new File(cygwinFolder, symlinksFindScript).renameTo(new File(cygwinFolder, symlinksFindScript + ".done"))
}

def copyCygwin(File cygwinFolder, File outputFolder) {
    println "Copying ${cygwinFolder.absolutePath} to ${outputFolder.absolutePath}/cygwin"
    new AntBuilder().copy( todir: "${outputFolder.absolutePath}/cygwin", quiet: true ) {
      fileset( dir: "${cygwinFolder.absolutePath}", defaultexcludes:"no" )
    }
    println "Copying ${cygwinFolder.absolutePath} to ${outputFolder.absolutePath}/cygwin done"
}

def copyCygwinForDist(File cygwinFolder, File outputFolder) {
    println "Copying ${cygwinFolder.absolutePath} to ${outputFolder.absolutePath}/.babun/cygwin"
    new AntBuilder().copy(todir: "${outputFolder.absolutePath}/.babun/cygwin", quiet: false) {
        fileset(dir: "${cygwinFolder.absolutePath}", defaultexcludes:"no") {
            exclude(name: "Cygwin.bat")
            exclude(name: "Cygwin.ico")
            exclude(name: "Cygwin-Terminal.ico")
        }
    }
}

def repairSymlinks(File outputFolder) {
    String symlinksRepairScript = "/etc/postinstall/symlinks_repair.sh"
    String fixBOM = "${outputFolder.absolutePath}/cygwin/bin/bash.exe --norc --noprofile -c \"/bin/sed -i '1s/^\\xEF\\xBB\\xBF//' ${symlinksRepairScript}\""
    String repairSymlinksCmd = "${outputFolder.absolutePath}/cygwin/bin/bash.exe --norc --noprofile \"${symlinksRepairScript}\""
    executeCmd(fixBOM, true)
    executeCmd(repairSymlinksCmd, true)
}

def executeBabunCore(){
	File outputFolder = new File(getTarget(), "babun-core")
    copyCygwin(new File(getTarget(), "babun-cygwin/cygwin"), outputFolder)
    
    String bash = "${outputFolder.absolutePath}/cygwin/bin/bash.exe -l"
    String dash = "${outputFolder.absolutePath}/cygwin/bin/dash.exe"
    
    // rebase dll's
    executeCmd("${dash} -c '/usr/bin/rebaseall'")
    repairSymlinks(outputFolder)   

	File babunSourceDest = new File(outputFolder, "cygwin/usr/local/etc/babun/source")
	babunSourceDest.mkdirs()
    new AntBuilder().copy( todir: "${babunSourceDest.absolutePath}/babun-core", quiet: true ) {
      fileset( dir: "babun-core", defaultexcludes:"no" )
    }
    new AntBuilder().copy( todir: "${babunSourceDest.absolutePath}/babun-dist", quiet: true ) {
      fileset( dir: "babun-dist", defaultexcludes:"no" )
    }
	new AntBuilder().copy( file: "babun.version" ,todir: "${babunSourceDest.absolutePath}", quiet: true )
	
	File babunBuild = new File(babunSourceDest, "babun.build")
	babunBuild.createNewFile()
	babunBuild << BUILD
	
    
    // checkout babun
    //String sslVerify = "git config --global http.sslverify"
    //String src = "/usr/local/etc/babun/source"
    //String clone = "git clone https://github.com/kamm/babun.git ${src}"
    //String babunBranch = getenv("babun_branch") ? getenv("babun_branch") : "master"
    //String checkout = "git --git-dir='${src}/.git' --work-tree='${src}' checkout ${babunBranch}"    
    //executeCmd("${bash} -c \"mkdir -p /usr/local/bin\"")
    //executeCmd("${bash} -c \"mkdir -p /usr/local/etc/babun\"")
    //executeCmd("${bash} -c \"${sslVerify} 'false'\"")
    //executeCmd("${bash} -c \"${clone}\"")
    //executeCmd("${bash} -c \"${checkout}\"")
    //executeCmd("${bash} -c \"${sslVerify} 'true'\"")
    
    // remove windows new line feeds
    String dos2unix = "find /usr/local/etc/babun/source/babun-core -type f -exec dos2unix {} \\;"
    executeCmd("${bash} -c \"${dos2unix}\"", true)

    // make installer executable
    String chmod = "find /usr/local/etc/babun/source/babun-core -type f -regex '.*sh' -exec chmod u+x {} \\;"
    executeCmd("${bash} -c \"${chmod}\"")

    // invoke init.sh
    executeCmd("${bash} -c \"/usr/local/etc/babun/source/babun-core/tools/init.sh x86_64\"")

    // run babun installer - yay!
    executeCmd("${bash} -c \"/usr/local/etc/babun/source/babun-core/plugins/install.sh\"")
}

def executeBabunDist(){
	File cygwinFolder = new File(getTarget(), "babun-core/cygwin")
	File inputFolder  = new File(getRoot(), "babun-dist")
	File outputFolder = new File(getTarget(), "babun-dist")

	copyCygwinForDist(cygwinFolder, outputFolder)
    copyTools(inputFolder, outputFolder)
    copyStartScripts(inputFolder, outputFolder)
    copyFonts(inputFolder, outputFolder)
    // prepare Dist
    zipBabun(outputFolder)
    copyInstallScripts(inputFolder, outputFolder)
    createBabunDist(inputFolder, outputFolder, VERSION)   
}

def copyTools(File inputFolder, File outputFolder) {
    println "Copying ${inputFolder.absolutePath}/tools to ${outputFolder.absolutePath}/.babun/tools"
    new AntBuilder().copy(todir: "${outputFolder.absolutePath}/.babun/tools", quiet: true) {
        fileset(dir: "${inputFolder.absolutePath}/tools", defaultexcludes:"no")
    }
}

def copyFonts(File inputFolder, File outputFolder) {
    println "Copying ${inputFolder.absolutePath}/fonts to ${outputFolder.absolutePath}/.babun/fonts"
    new AntBuilder().copy(todir: "${outputFolder.absolutePath}/.babun/fonts", quiet: true) {
        fileset(dir: "${inputFolder.absolutePath}/fonts", defaultexcludes:"no")
    }
}

def copyStartScripts(File inputFolder, File outputFolder) {
    println "Copying ${inputFolder.absolutePath}/start to ${outputFolder.absolutePath}/.babun"
    new AntBuilder().copy(todir: "${outputFolder.absolutePath}/.babun", quiet: true) {
        fileset(dir: "${inputFolder.absolutePath}/start", defaultexcludes:"no")
    }
}

def zipBabun(File outputFolder) {
    /*new AntBuilder().zip(destFile: "${outputFolder.absolutePath}/dist/dist/babun.zip", level: 9) {
        fileset(dir: "${outputFolder.absolutePath}", defaultexcludes:"no") {
            include(name: '.babun/**')
        }
    }*/
	//7z a -t7z Files.7z -mx9 -aoa
	def command = "babun-dist\\7zip-64\\7z.exe a -t7z ${outputFolder.absolutePath}\\dist\\dist\\babun.7z -mx9 ${outputFolder.absolutePath}\\.babun"
	executeCmd(command, true)
}

def copyInstallScripts(File inputFolder, File outputFolder) {
	new AntBuilder().copy(todir: "${outputFolder.absolutePath}/dist/dist", quiet: true) {
        fileset(dir: "${inputFolder.absolutePath}/7zip", defaultexcludes:"no") { include(name: "7z.*") }        
    }
    new AntBuilder().copy(todir: "${outputFolder.absolutePath}/dist/dist", quiet: true) {
        fileset(dir: "${inputFolder.absolutePath}/tools", defaultexcludes:"no") { include(name: "freespace.vbs") }
    }    
    new AntBuilder().copy(todir: "${outputFolder.absolutePath}/dist", quiet: true) {
        fileset(dir: "${inputFolder.absolutePath}/install", defaultexcludes:"no") { include(name: "install.*") }
    }
}

def createBabunDist(File inputFolder, File outputFolder, String version) {
    // rename dist folder
    File dist = new File(outputFolder, "dist")
    File distWithVersion = new File(outputFolder, "babun-${version}")
    dist.renameTo(distWithVersion)
	
	
	def zipCommand = "babun-dist\\7zip-64\\7z.exe a -t7z ${outputFolder.absolutePath}\\babun.7z -mx0 ${outputFolder.absolutePath}\\babun-${version}"
	executeCmd(zipCommand, true)
    generateConfigTxt(inputFolder, outputFolder, version)
	def exeCommand = "cmd /c copy /y/b ${inputFolder.absolutePath}\\sfx\\7zsd.sfx+${outputFolder.absolutePath}\\sfx\\config.txt+${outputFolder.absolutePath}\\babun.7z ${outputFolder.absolutePath}\\babun-${version}-${BUILD}.exe"
	executeCmd(exeCommand, true)
}

def generateConfigTxt(File inputFolder, File outputFolder, String version){
    File inputFile = new File(inputFolder, "sfx/config.txt")
    input = inputFile.text
    println input
    output = input.replace("%VERSION%", version)
    println output
    File outputFile = new File(outputFolder, "sfx/config.txt")
    outputFile.getParentFile().mkdirs()
    outputFile.withWriter('utf-8'){
        writer -> writer.write output
    }
}

def executeRelease() {
    log "EXEC release"
    assert getenv("bintray_user") != null
    assert getenv("bintray_secret") != null
    File artifact = new File(getTarget(), "babun-dist/babun-${VERSION}-dist.zip")
    def args = ["groovy", "babun-dist/release/release.groovy", "babun", "babun-dist", VERSION,
            artifact.absolutePath, getenv("bintray_user"), getenv("bintray_secret")]
    executeCmd(args, getRoot())
}

def shouldSkipModule(String module) {
    File out = new File(getTarget(), module)
    log "Checking if skip module ${module} -> folder ${out.absolutePath}"
    if (out.exists()) {
        log "SKIP ${module}"
        return true
    }
    log "DO NOT SKIP ${module}"
    return false
}

File getTarget() {
    return new File(getRoot(), "target")
}

File getRoot() {
    return new File(getClass().protectionDomain.codeSource.location.path).parentFile
}

def executeCmd(List<String> command, File workingDir) {
    ProcessBuilder processBuilder = new ProcessBuilder(command)
    processBuilder.directory(workingDir)
    Process process = processBuilder.start()
    addShutdownHook { process.destroy() }
    process.consumeProcessOutput(err, err)
    process.waitForProcessOutput()
    assert process.exitValue() == 0
}

def executeCmd(String command, boolean disableOutput = false) {
    log command
    def process = command.execute()
    addShutdownHook { process.destroy() }
    if(!disableOutput){
        process.consumeProcessOutput(out, out)
    }
    process.waitForProcessOutput()
    return process.exitValue()
}


def getReleaseScript() {
    new File(getRoot(), "release.groovy")
}

def log(String msg) {
    println "[${new Date()}] ${msg}"
}

def error(String message, boolean noPrefix = false) {
    log((noPrefix ? "" : "ERROR: ") + message)
}


def downloadFile(String url, File output, boolean overwrite = false){
    if(!output.exists() || overwrite) {
        try{
			log "Downloading ${url}"
			output.getParentFile().mkdirs()
			use(FileBinaryCategory) {
				output << url.toURL()
			}
		}
		catch (Exception ex) {
			return false
		}
    } 
    return true
}

class FileBinaryCategory {
    def static leftShift(File file, URL url) {
        url.withInputStream { is ->
            file.withOutputStream { os ->
                def bs = new BufferedOutputStream(os)
                bs << is
            }
        }
    }
}