build.gradle

import com.bmuschko.gradle.docker.tasks.container.DockerCopyFileFromContainer

import com.liferay.docker.workspace.environments.Util

import groovy.json.JsonSlurper

import java.time.format.DateTimeFormatter

plugins {
	id "com.avast.gradle.docker-compose" version "0.17.10"
	id "docker-common"
	id "docker-database-saas"
	id "docker-liferay-bundle"
	id "docker-webserver"
}

if (Boolean.getBoolean("env.mode.ci")) {
	formatSource {
		failOnAutoFix = true
	}
}

gradle.liferayWorkspace {
	dockerImageId = config.liferayDockerImageId
}

Instant now = Instant.now()

DateTimeFormatter formatter = DateTimeFormatter.
ofPattern("yyyyMMdd.HHmmss").
withZone(ZoneId.systemDefault())

String timestamp = formatter.format(now)

tasks.register("exportContainerData", DockerCopyFileFromContainer) {
	containerId = "${config.namespace}-data-helper"

	doFirst {
		mkdir hostPath.get()

		waitForCommand("docker compose create data-helper")
	}

	doLast {
		updateGradleLocalProperties(["lr.docker.environment.data.directory" : hostPath.get()])

		logger.lifecycle("\nUpdated gradle-local.properties with the new value:\nlr.docker.environment.data.directory=${hostPath.get()}")
	}

	hostPath = provider {
		"exported_data/data_${config.namespace}_${timestamp}"
	}

	remotePath = "/container-data"
}

tasks.register("importDocumentLibraryStructure") {
	doLast {
		project.fileTree(project.getProperty("sourceDir")).visit {
			if (it.isDirectory()) {
				return
			}

			File newFile = project.file("configs/common/data/document_library/${it.relativePath}")

			if (!newFile.parentFile.exists()) {
				newFile.parentFile.mkdirs()
			}

			if (!newFile.exists()) {
				newFile.createNewFile()
			}
		}
	}
}

tasks.register("shareWorkspace", Zip) {
	archiveFileName = provider {
		"workspace_${config.namespace}_${timestamp}.zip"
	}

	destinationDirectory = file 'shared_workspaces'

	doLast {
		logger.lifecycle "\nWorkspace zip: ${archiveFile.get()}\n"
	}

	exclude ".gitkeep"
	exclude ".gitignore"
	exclude ".git"
	exclude ".gradle"
	exclude "binds"
	exclude "dumps/*"
	exclude "shared_workspaces"
	exclude {
		FileTreeElement fileTreeElement ->

		fileTreeElement.relativePath.pathString.startsWith("exported_data/") &&
		!fileTreeElement.relativePath.pathString.startsWith(config.dataDirectory)
	}

	from '.'

	include "${config.dataDirectory}/**"
	include "**/*"

	outputs.upToDateWhen {
		false
	}
}

tasks.register("restart") {
	dependsOn ":start"
	dependsOn ":stop"
}

tasks.register("start") {
	dependsOn ":composeUp"
	mustRunAfter ":stop"
}

tasks.register("stop") {
	dependsOn ":composeDown"
}

buildDockerImage {
	onlyIf("using the Liferay service") {
		config.useLiferay
	}

	dependsOn ":checkForLiferayLicense"
	dependsOn ":prepareJDBCDriver"

	mustRunAfter ":importDatabaseDumps"
}

clean {
	dependsOn ":cleanPrepareJDBCDriver"
	dependsOn ":cleanPrepareHotfixes"
	dependsOn ":cleanPrepareSelfSignedCert"
	dependsOn ":cleanPrepareWebserverConfig"
	dependsOn ":cleanDownloadYourKitAgentZip"
	dependsOn ":cleanPrepareYourKitAgent"
}

dockerDeploy {
	dependsOn ":prepareJDBCDriver"
	dependsOn ":prepareHotfixes"
	dependsOn ":prepareYourKitAgent"
}

composeBuild {
	dependsOn ":prepareSelfSignedCert"
	dependsOn ":prepareWebserverConfig"
}

composeUp {
	onlyIf("there are Compose files") {
		!config.composeFiles.isEmpty()
	}

	dependsOn ":buildDockerImage"
	dependsOn ":importDatabaseDumps"

	doFirst {
		println "Using config:\n\n${config}\n\n"
	}

	finalizedBy ":listAdminUsers"
	finalizedBy ":printBundleInfo"
}

Map<String, String> environmentMap = [:]

environmentMap.put "DATA_DIRECTORY", config.dataDirectory
environmentMap.put "DATABASE_NAME", config.databaseName
environmentMap.put "GLOWROOT_ENABLED", config.glowrootEnabled
environmentMap.put "NAMESPACE", config.namespace

if (config.useClustering) {
	environmentMap.put "LIFERAY_CLUSTER_NODES", config.clusterNodes
}

if (config.useLiferay) {
	environmentMap.put "LIFERAY_IMAGE_NAME", config.liferayDockerImageId
}

environmentMap.put("COMPOSE_FILE", config.composeFiles.join(File.pathSeparator))
environmentMap.put("COMPOSE_PROJECT_NAME", config.namespace)

file("ports.env").withInputStream {
	portsFile ->

	Properties ports = new Properties()

	ports.load(portsFile)

	environmentMap.putAll ports
}

file('.env').withOutputStream {
	BufferedOutputStream envFileOutputStream ->

	environmentMap.forEach {
		key, value ->

		envFileOutputStream << key << "=" << value << "\n"
	}
}

dockerCompose {
	captureContainersOutput = true
	environment.putAll environmentMap
	projectName = config.namespace
	removeVolumes = config.clearVolumeData
	useComposeFiles = config.composeFiles
	waitForTcpPorts = false

	// DEBUG: Set to true if container startup is failing
	retainContainersOnStartupFailure = false
}