commons.gradle

/*
 * Copyright (C) 2007-2022 Crafter Software Corporation. All Rights Reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

// Deps
buildscript {
	repositories {
		mavenCentral()
	}
	dependencies {
		classpath "org.ajoberstar.grgit:org.ajoberstar.grgit.gradle.plugin:${project.property('grgit.version')}"
		classpath "org.apache.commons:commons-text:${project.property('commons-text.version')}"
		classpath "org.apache.commons:commons-lang3:${project.property('commons-lang3.version')}"
	}
}

import java.security.MessageDigest

// Helper methods
ext.splash = { ->
	System.out.println("\033[38;5;196m")
	System.out.println(" ██████╗ ██████╗   █████╗  ███████╗ ████████╗ ███████╗ ██████╗   ██████╗ ███╗   ███╗ ███████╗")
	System.out.println("██╔════╝ ██╔══██╗ ██╔══██╗ ██╔════╝ ╚══██╔══╝ ██╔════╝ ██╔══██╗ ██╔════╝ ████╗ ████║ ██╔════╝")
	System.out.println("██║      ██████╔╝ ███████║ █████╗      ██║    █████╗   ██████╔╝ ██║      ██╔████╔██║ ███████╗")
	System.out.println("██║      ██╔══██╗ ██╔══██║ ██╔══╝      ██║    ██╔══╝   ██╔══██╗ ██║      ██║╚██╔╝██║ ╚════██║")
	System.out.println("╚██████╗ ██║  ██║ ██║  ██║ ██║         ██║    ███████╗ ██║  ██║ ╚██████╗ ██║ ╚═╝ ██║ ███████║")
	System.out.println(" ╚═════╝ ╚═╝  ╚═╝ ╚═╝  ╚═╝ ╚═╝         ╚═╝    ╚══════╝ ╚═╝  ╚═╝  ╚═════╝ ╚═╝     ╚═╝ ╚══════╝")
	System.out.println("\033[0m")
}

// Settings
ext {
	cmsDir = "${projectDir}/craftercms"
	commandTimeout = getPropertySafelyWithDefaults("commandTimeout", 1000000).toInteger()
}

ext.execCommand = { command, dir ->
	def cmd = "";

	command.each { fragment ->
		cmd += fragment
		if (fragment != command.last()) {
			cmd += " "
		}
	}

	// System.out.println("Executing command \"" + dir + ":" + cmd + "\"")

	def proc = cmd.execute(null, file(dir))

	proc.consumeProcessOutput(System.out, System.err)
	proc.waitForOrKill(commandTimeout)

	if (proc.exitValue() != 0) {
		throw new GradleException("$cmd failed.")
	}
}

ext.copyFile = { workingDir, source, destination ->
	def command = ["cp", source, destination]
	try {
		execCommand(command, workingDir)
	} catch (e) {
		logger.error("Failed to copy file workingDir: {}, source: {}, destination: {}")
		throw new GradleException("Failed to copy file.", e)
	}
}

ext.syncFolder = { workingDir, source, destination, exclude, overwriteChangedFiles, deleteNonExisting ->
	def command = ["rsync", "-ar"]

	if (!overwriteChangedFiles) {
		command += ["--update"]
	}

	if (deleteNonExisting) {
		command += ["--delete"]
	}

	if (!exclude.isEmpty()) {
		command += ["--exclude", exclude]
	}

	// Make sure the destination exists
	file(destination).mkdirs()

	// Rsync the source to the destination
	command += [source, destination]

	try {
		execCommand(command, workingDir)
	} catch (e) {
		logger.error("Failed to sync folders workingDir: {}, source: {}, destination: {}," +
			"exclude: {}, overwriteChangedFiles: {}, exception: {}", workingDir, source,
			destination, exclude, overwriteChangedFiles, e)
		throw new GradleException("Failed to sync folders.", e)
	}
}

// Build methods
ext.gradleModules = [
	'groovy-sandbox': ':groovy-sandbox',
	'script-security-plugin': ':script-security-plugin',
	'commons': [
		':commons:utilities',
		':commons:security',
		':commons:audit',
		':commons:git',
		':commons:entitlements',
		':commons:validation',
		':commons:plugin',
		':commons:upgrade-manager'
	],
	'core': ':core',
	'search': [
		':search:commons',
		':search:batch-indexer',
		':search:opensearch'
	],
	'engine': ':engine',
	'studio-ui': ':studio-ui',
	'studio': ':studio',
	'deployer': ':deployer',
	'cli': ':cli'
]

// This is used to run external tasks: bomGenerate, publishMavenPublicationToGitHubPackagesRepository
ext.runGradleModuleTask = { module, task, extraArgs = [] ->
	def projects = gradleModules[module]
	if (projects == null) {
		return false
	}
	def gradleArgs = ["./gradlew"]
	if (extraArgs) {
		gradleArgs.addAll(extraArgs as List)
	}
	if (projects instanceof List) {
		projects.each { gradleArgs += "${it}:${task}" }
	} else {
		gradleArgs += "${projects}:${task}"
	}
	execCommand(gradleArgs, projectDir)
	return true
}

ext.buildBom = { module ->
	if (runGradleModuleTask(module, 'bomGenerate')) {
		return
	}

	println "Skipping BOM generation for $module (no Gradle bomGenerate task configured)"
}

ext.aggregateBoms = { dir ->
	try {
		execCommand(["./aggregate-boms.sh"], dir)
	} catch (e) {
		logger.error("Failed to aggregate BOMs, exception: {}", e)
		throw new GradleException("Failed to aggregate BOMs.", e)
	}
}

ext.checksumFile = { filePath, algorithm ->
	// Set your algorithm
	// "MD2","MD5","SHA","SHA-1","SHA-256","SHA-384","SHA-512"
	MessageDigest md = MessageDigest.getInstance(algorithm);
	FileInputStream fis = new FileInputStream(new File(filePath));
	byte[] dataBytes = new byte[1024];

	int nread = 0;
	while ((nread = fis.read(dataBytes)) != -1) {
		md.update(dataBytes, 0, nread);
	}

	byte[] mdbytes = md.digest();

	StringBuilder sb = new StringBuilder();
	for (int i = 0; i < mdbytes.length; i++) {
		sb.append(Integer.toString((mdbytes[i] & 0xff) + 0x100, 16).substring(1));
	}
	return sb.toString();
}

ext.bundleEnvironment = { env, bundlesDir /*, fresh*/ ->
/*
	// TODO: add support for a fresh env before bundling
	if (fresh) {
		// Create a temporary folder and do a fresh build
		// Set the source to the fresh build
	}
*/
	// Tar and package
	def bundleFilename = "crafter-cms-${env}-${project.version}-${currentPlatform}-${currentArch}.tar.gz"
	def bundlePath = "${bundlesDir}/" + bundleFilename
	def source = "./crafter"

	if (!file(bundlePath).exists()) {
		if (env == "authoring") {
			file("${authoringEnvDir}").renameTo(source)
		} else if (env == "delivery") {
			file("${deliveryEnvDir}").renameTo(source)
		} else {
			throw new GradleException("Unknown environment " + env)
		}

		file(bundlesDir).mkdir()

		try {
			execCommand(["tar", "czf", bundlePath, source], "${projectDir}")

			def md5sum = checksumFile(bundlePath, "MD5")
			def sha512sum = checksumFile(bundlePath, "SHA-512")

			new File(bundlePath + ".md5").withWriter('utf-8') {
				writer -> writer.writeLine md5sum + "  " + bundleFilename
			}

			new File(bundlePath + ".sha512").withWriter('utf-8') {
				writer -> writer.writeLine sha512sum + "  " + bundleFilename
			}
		} catch (e) {
			logger.error("Failed to create bundle for env: {}, bundlesDir: {}", env, bundlesDir, e)
			throw new GradleException("Failed to create bundle.", e)
		} finally {
			if (env == "authoring") {
				file(source).renameTo("${authoringEnvDir}")
			} else if (env == "delivery") {
				file(source).renameTo("${deliveryEnvDir}")
			} else {
				throw new GradleException("Unknown environment " + env)
			}
		}
	}
}