build-test-analytics-cloud.xml

<?xml version="1.0"?>

<project basedir="." name="portal-test-analytics-cloud" xmlns:antelope="antlib:ise.antelope.tasks">
	<import file="build-test.xml" />

	<macrodef name="build-analytics-cloud-images">
		<sequential>
			<if>
				<equals arg1="${env.OSB_ASAH_STAGING_ENABLED}" arg2="true" />
				<then>
					<echo>Skipping build-analytics-cloud-images due to staging</echo>
				</then>
				<else>
					<loadproperties srcfile="${project.dir}/.gradle/gradle.properties" />

					<echo append="true" file="${analytics.cloud.asah.dir}/gradle.properties">&#10;systemProp.repository.private.password=${systemProp.repository.private.password}</echo>
					<echo append="true" file="${analytics.cloud.asah.dir}/gradle.properties">&#10;systemProp.repository.private.username=${systemProp.repository.private.username}</echo>

					<create-analytics-cloud-docker-compose start.analytics.cloud="false" />

					<if>
						<available file="${project.dir}/dist/liferay-docker-asah.tar" />
						<then>
							<execute>
								docker load --input ${project.dir}/dist/liferay-docker-asah.tar
							</execute>
						</then>
						<else>
							<pull-docker-image-dependencies
								analytics.cloud.image.names.excludes="${analytics.cloud.asah.image.names.excludes}"
								analytics.cloud.repository.dir="${analytics.cloud.asah.dir}"
							/>

							<execute-analytics-cloud dir="${analytics.cloud.asah.dir}" timeout="600000">
								./gradlew jar -Dliferay.ci=true

								./gradlew clean assemble -Dliferay.ci=true

								docker compose --file=${analytics.cloud.docker.test.yaml} --project-name=${analytics.cloud.project.name} build

								docker images
							</execute-analytics-cloud>

							<for list="${analytics.cloud.asah.image.names}" param="analytics.cloud.asah.image.name">
								<sequential>
									<if>
										<not>
											<matches pattern=".*com-liferay-osb-.*" string="@{analytics.cloud.asah.image.name}" />
										</not>
										<then>
											<if>
												<isset property="analytics.cloud.ecr.registry" />
												<then>
													<local name="analytics.cloud.ecr.image.name" />

													<beanshell>
														String analyticsCloudAsahImageName = "@{analytics.cloud.asah.image.name}";

														StringBuilder sb = new StringBuilder();

														sb.append(project.getProperty("analytics.cloud.ecr.registry"));
														sb.append("/");

														if (!analyticsCloudAsahImageName.matches("([^/\\s]+)/([^:\\s]+)(:([^:\\s]+))?")) {
															sb.append("library/");
														}

														sb.append(analyticsCloudAsahImageName);

														project.setProperty("analytics.cloud.ecr.image.name", sb.toString());
													</beanshell>

													<execute dir="${project.dir}">
														docker pull ${analytics.cloud.ecr.image.name}

														docker tag ${analytics.cloud.ecr.image.name} @{analytics.cloud.asah.image.name}
													</execute>
												</then>
												<else>
													<execute dir="${project.dir}">
														docker pull @{analytics.cloud.asah.image.name}
													</execute>
												</else>
											</if>
										</then>
									</if>
								</sequential>
							</for>

							<antelope:stringutil property="analytics.cloud.asah.image.names.list" string="${analytics.cloud.asah.image.names}">
								<antelope:replace regex="," replacement=" " />
							</antelope:stringutil>

							<execute dir="${project.dir}">
								docker save --output ${project.dir}/dist/liferay-docker-asah.tar ${analytics.cloud.asah.image.names.list}
							</execute>
						</else>
					</if>

					<if>
						<available file="${project.dir}/dist/liferay-docker-faro.tar" />
						<then>
							<execute>
								docker load --input ${project.dir}/dist/liferay-docker-faro.tar
							</execute>
						</then>
						<else>
							<download-gradle-wrapper-binary workspace.dir="${analytics.cloud.asah.dir}" />

							<pull-docker-image-dependencies
								analytics.cloud.image.names.excludes="${analytics.cloud.faro.image.names.excludes}"
								analytics.cloud.repository.dir="${analytics.cloud.faro.dir}"
							/>

							<local name="portal.base.dir" />

							<beanshell>
								<![CDATA[
									import com.liferay.jenkins.results.parser.JenkinsResultsParserUtil;

									File analyticsCloudFaroDir = new File(project.getProperty("analytics.cloud.faro.dir"));

									File gradleWrapperDir = analyticsCloudFaroDir.getParentFile();

									File gradleWrapperFile = new File(gradleWrapperDir, "gradlew");

									while (true) {
										if (gradleWrapperFile.exists()) {
											break;
										}

										gradleWrapperDir = gradleWrapperDir.getParentFile();

										if (gradleWrapperDir == null) {
											break;
										}

										gradleWrapperFile = new File(gradleWrapperDir, "gradlew");
									}

									if (gradleWrapperFile.exists()) {
										project.setProperty("portal.base.dir", JenkinsResultsParserUtil.getCanonicalPath(gradleWrapperFile.getParentFile()));

										project.setProperty("portal.gradlew", JenkinsResultsParserUtil.getCanonicalPath(gradleWrapperFile));
									}
									else {
										project.setProperty("portal.gradlew", "gradle");
									}
								]]>
							</beanshell>

							<if>
								<and>
									<available file="${portal.base.dir}" />
									<not>
										<equals arg1="${portal.base.dir}" arg2="${project.dir}" />
									</not>
								</and>
								<then>
									<echo>Set up portal for OSB Faro (${portal.base.dir}).</echo>

									<execute dir="${portal.base.dir}">
										ant setup-profile-dxp

										ant setup-sdk

										ant setup-libs

										ant compile

										ant install-portal-snapshots
									</execute>
								</then>
							</if>

							<loadfile
								property="analytics.cloud.docker.test.yaml.content"
								srcfile="${analytics.cloud.docker.test.yaml}"
							/>

							<propertyregex
								input="${analytics.cloud.docker.test.yaml.content}"
								override="true"
								property="analytics.cloud.faro.tag.name"
								regexp="[\S\s]*image: (liferay\/com-liferay-osb-faro\:[^\s]+)[\S\s]*"
								replace="\1"
							/>

							<execute-analytics-cloud dir="${analytics.cloud.faro.dir}" timeout="600000">
								${portal.gradlew} createDocker -Pcom.liferay.osb.faro.environment.name=local -Dliferay.ci=true

								docker tag ${analytics.cloud.faro.image.name} ${analytics.cloud.faro.tag.name}

								docker rm ${analytics.cloud.faro.container.name}

								docker save --output ${project.dir}/dist/liferay-docker-faro.tar ${analytics.cloud.faro.image.name}
							</execute-analytics-cloud>
						</else>
					</if>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="create-analytics-cloud-docker-compose">
		<attribute default="false" name="start.analytics.cloud" />

		<sequential>
			<fail message="Please set the property ${env.DOCKER_ENABLED}." unless="env.DOCKER_ENABLED" />

			<var name="analytics.cloud.docker.test.yaml" unset="true" />
			<var name="analytics.cloud.service.images.available" unset="true" />

			<property location="${analytics.cloud.asah.dir}/docker-compose.test.yml" name="analytics.cloud.docker.test.yaml" />

			<mkdir dir="${project.dir}/dist" />

			<get-host-git-dir />

			<beanshell>
				<![CDATA[
					import com.liferay.jenkins.results.parser.JenkinsResultsParserUtil;

					import java.util.regex.Matcher;
					import java.util.regex.Pattern;

					import org.yaml.snakeyaml.DumperOptions;
					import org.yaml.snakeyaml.Yaml;

					public void downloadImageTarFile(File imageTarFile) {
						if (imageTarFile.exists()) {
							return;
						}

						String distPath = getDistPath();

						if (JenkinsResultsParserUtil.isNullOrEmpty(distPath)) {
							return;
						}

						File parentDir = imageTarFile.getParentFile();

						parentDir.mkdirs();

						long analyticsCloudRsyncTimeout = Long.valueOf(project.getProperty("analytics.cloud.rsync.timeout"));

						int retryCount = 0;

						while (true) {
							String distNode = getDistNode();

							if (JenkinsResultsParserUtil.isNullOrEmpty(distNode)) {
								return;
							}

							StringBuilder sb = new StringBuilder();

							sb.append("time timeout ");
							sb.append(analyticsCloudRsyncTimeout / 1000);
							sb.append(" rsync -qs ");
							sb.append(distNode);
							sb.append(":");
							sb.append(distPath);
							sb.append("/");
							sb.append(imageTarFile.getName());
							sb.append(" ");
							sb.append(JenkinsResultsParserUtil.getCanonicalPath(imageTarFile));
							sb.append(" ");

							try {
								Process process = JenkinsResultsParserUtil.executeBashCommands(false, new File("."), analyticsCloudRsyncTimeout, new String[] {sb.toString()});

								if (process.exitValue() != 0) {
									continue;
								}

								System.out.println(JenkinsResultsParserUtil.readInputStream(process.getInputStream()));

								break;
							}
							catch (Exception exception) {
								continue;
							}
							finally {
								if (retryCount >= 2) {
									System.out.println("WARNING: Unable to download " + imageTarFile.getName() + " after " + retryCount + " retries");
								}

								retryCount++;
							}

							break;
						}
					}

					public void downloadImageTarFiles() {
						File distDir = new File(project.getProperty("project.dir") + "/dist");

						downloadImageTarFile(new File(distDir, "liferay-docker-asah.tar"));
						downloadImageTarFile(new File(distDir, "liferay-docker-faro.tar"));
					}

					public void dumpYamlMap(Map yamlMap) {
						Yaml yaml = getYaml();

						FileWriter fileWriter = new FileWriter(new File(project.getProperty("analytics.cloud.docker.test.yaml")));

						yaml.dump(yamlMap, fileWriter);
					}

					public String getAnalyticsCloudAsahImageNames(Map dockerComposeMap) {
						StringBuilder sb = new StringBuilder();

						Map servicesMap = dockerComposeMap.get("services");

						for (String serviceName : servicesMap.keySet()) {
							Map serviceMap = servicesMap.get(serviceName);

							if (serviceName.contains("faro")) {
								continue;
							}

							String imageName = serviceMap.get("image");

							if (JenkinsResultsParserUtil.isNullOrEmpty(imageName)) {
								imageName = "com-liferay-osb-asah-private-" + serviceName;
							}

							sb.append(imageName);
							sb.append(",");
						}

						if (sb.length() > 0) {
							sb.setLength(sb.length() - 1);
						}

						return sb.toString();
					}

					public String getDistNode() {
						String distNodes = project.getProperty("env.DIST_NODES");

						if (JenkinsResultsParserUtil.isNullOrEmpty(distNodes)) {
							return null;
						}

						return JenkinsResultsParserUtil.getRandomString(Arrays.asList(distNodes.split(",")));
					}

					public String getDistPath() {
						String distPath = project.getProperty("env.DIST_PATH");

						if (JenkinsResultsParserUtil.isNullOrEmpty(distPath)) {
							return null;
						}

						distPath = distPath.replaceAll("\\(", "\\\\(");
						distPath = distPath.replaceAll("\\)", "\\\\)");

						return distPath;
					}

					public Map getDockerComposeMap() {
						Yaml yaml = getYaml();

						InputStream inputStream = new FileInputStream(project.getProperty("analytics.cloud.asah.dir") + "/docker-compose.yml");

						return yaml.load(inputStream);
					}

					public List getServiceNames(Map dockerComposeMap) {
						Map servicesMap = dockerComposeMap.get("services");

						return new ArrayList(servicesMap.keySet());
					}

					public getShortHostname() {
						String hostname = project.getProperty("env.HOSTNAME");

						String hostnameRegex = "(cloud-[^\\.]+|test-\\d+-\\d+-\\d+)(\\.lax\\.liferay\\.com)?";

						if (!hostname.matches(hostnameRegex)) {
							return null;
						}

						return hostname.replaceAll(hostnameRegex, "$1");
					}

					public Yaml getYaml() {
						DumperOptions dumperOptions = new DumperOptions();

						dumperOptions.setIndent(4);

						return new Yaml(dumperOptions);
					}

					public boolean serviceImagesAvailable(Map dockerComposeMap) {
						Map servicesMap = dockerComposeMap.get("services");

						for (String serviceName : servicesMap.keySet()) {
							File serviceImageTarFile = new File(project.getProperty("project.dir") + "/dist/liferay-docker-" + serviceName + ".tar");

							if (!serviceImageTarFile.exists()) {
								System.out.println("Could not find " + serviceImageTarFile);

								return false;
							}
						}

						return true;
					}

					public void updateDockerNetwork(Map dockerComposeMap) {
						String shortHostname = getShortHostname();

						if (shortHostname == null) {
							return;
						}

						Map defaultMap = new HashMap();
						Map externalMap = new HashMap();
						Map nameMap = new HashMap();
						Map networksMap = new HashMap();

						dockerComposeMap.put("networks", networksMap);

						networksMap.put("default", defaultMap);

						defaultMap.put("external", externalMap);

						externalMap.put("name", shortHostname);
					}

					public void updateOSBFaroFrontendService(Map dockerComposeMap) {
						Map servicesMap = dockerComposeMap.get("services");

						Map osbFaroFrontendServiceMap = servicesMap.get("osbfarofrontend");

						osbFaroFrontendServiceMap.put("container_name", project.getProperty("analytics.cloud.faro.container.name"));
						osbFaroFrontendServiceMap.put("image", project.getProperty("analytics.cloud.faro.image.name"));

						List ports = osbFaroFrontendServiceMap.get("ports");

						ports.remove("8080:8080");
						ports.remove("11311:11311");

						ports.add(project.getProperty("analytics.cloud.faro.dxp.port") + ":8080");
						ports.add(project.getProperty("analytics.cloud.faro.osgi.console.port") + ":11311");

						osbFaroFrontendServiceMap.put("ports", ports);
					}

					public void updateServiceImages(Map dockerComposeMap) {
						if (!"@{start.analytics.cloud}".equals("true")) {
							return;
						}

						Map servicesMap = dockerComposeMap.get("services");

						for (String serviceName : servicesMap.keySet()) {
							Map serviceMap = servicesMap.get(serviceName);

							if (serviceMap.containsKey("image")) {
								continue;
							}

							serviceMap.put("image", "com-liferay-osb-asah-private-" + serviceName);
						}
					}

					public void updateVolumes(Map dockerComposeMap) {
						String hostGitDir = project.getProperty("host.git.dir");

						if (JenkinsResultsParserUtil.isNullOrEmpty(hostGitDir)) {
							return;
						}

						Map servicesMap = dockerComposeMap.get("services");

						for (String serviceName : servicesMap.keySet()) {
							Map serviceMap = servicesMap.get(serviceName);

							List updatedVolumes = new ArrayList();

							List currentVolumes = serviceMap.get("volumes");

							if (currentVolumes == null) {
								continue;
							}

							for (String currentVolume : currentVolumes) {
								updatedVolumes.add(currentVolume.replaceAll("\\./", hostGitDir + "/com-liferay-osb-asah-private/"));
							}

							serviceMap.put("volumes", updatedVolumes);
						}
					}

					downloadImageTarFiles();

					Map dockerComposeMap = getDockerComposeMap();

					updateDockerNetwork(dockerComposeMap);
					updateOSBFaroFrontendService(dockerComposeMap);
					updateServiceImages(dockerComposeMap);
					updateVolumes(dockerComposeMap);

					dumpYamlMap(dockerComposeMap);

					project.setProperty("analytics.cloud.asah.image.names", getAnalyticsCloudAsahImageNames(dockerComposeMap));
				]]>
			</beanshell>

			<local name="analytics.cloud.faro.build.gradle" />

			<condition else="${analytics.cloud.faro.dir}/build.gradle" property="analytics.cloud.faro.build.gradle" value="${analytics.cloud.faro.dir}/build-ext.gradle">
				<available file="${analytics.cloud.faro.dir}/build-ext.gradle" />
			</condition>

			<replaceregexp
				file="${analytics.cloud.faro.build.gradle}"
				match="def dockerContainerId = \&quot;([^\&quot;]+)\&quot;"
				replace="def dockerContainerId = \&quot;${analytics.cloud.faro.container.name}\&quot;"
			/>

			<replaceregexp
				file="${analytics.cloud.faro.build.gradle}"
				match="network \&quot;([^\&quot;]+)\&quot;"
				replace="network \&quot;${analytics.cloud.project.name}_default\&quot;"
			/>

			<replaceregexp
				file="${analytics.cloud.faro.dir}/osb-faro-docker/local/Dockerfile"
				match="FARO_URL=http://localhost:8080"
				replace="FARO_URL=${analytics.cloud.faro.frontend.url}"
			/>

			<echo file="${analytics.cloud.asah.dir}/local.env">OSB_ASAH_BACKEND_URL=${analytics.cloud.asah.backend.url}
OSB_ASAH_POSTGRESQL_ENABLED=false
OSB_ASAH_PUBLISHER_URL=${analytics.cloud.asah.publisher.url}
OSB_FARO_FRONTEND_URL=${analytics.cloud.faro.frontend.url}</echo>

			<if>
				<isset property="test.portal.license.url" />
				<then>
					<mkdir dir="${analytics.cloud.faro.dir}/osb-faro-docker/common/license/" />

					<mirrors-get
						dest="${analytics.cloud.faro.dir}/osb-faro-docker/common/license/"
						src="${test.portal.license.url}"
					/>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="execute-analytics-cloud">
		<attribute name="dir" />
		<attribute default="execute.analytics.cloud.result" name="resultproperty" />
		<attribute default="600000" name="timeout" />

		<text name="commands" trim="true" />

		<sequential>
			<local name="tstamp.execute" />

			<tstamp>
				<format pattern="yyyyMMddkkmmssSSS" property="tstamp.execute" />
			</tstamp>

			<trycatch property="execute.error">
				<try>
					<echo file="@{dir}/${tstamp.execute}.sh">
						@{commands}
					</echo>

					<local name="execute.path" />

					<local name="java.jdk.home" />
					<local name="java.jdk.opts" />

					<get-java-jdk-home architecture="x64" type="zulu" version="21" />
					<get-java-jdk-opts architecture="x64" type="zulu" version="21" />

					<propertyregex
						input="${env.PATH}"
						override="true"
						property="execute.path"
						regexp="/opt/java/(jdk|openjdk|zulu(-x64)?)[^/]+/bin"
						replace="${java.jdk.home}/bin"
					/>

					<exec dir="@{dir}" executable="/bin/bash" failonerror="true" resultproperty="@{resultproperty}" timeout="@{timeout}">
						<arg value="@{dir}/${tstamp.execute}.sh" />
						<env key="JAVA_HOME" value="${java.jdk.home}" />
						<env key="JAVA_OPTS" value="${java.jdk.opts}" />
						<env key="PATH" value="${execute.path}" />
					</exec>
				</try>
				<catch>
					<fail message="${execute.error}" />
				</catch>
				<finally>
					<delete file="@{dir}/${tstamp.execute}.sh" />
				</finally>
			</trycatch>
		</sequential>
	</macrodef>

	<macrodef name="print-analytics-cloud-logs">
		<sequential>
			<execute>
				docker stats --no-stream
			</execute>

			<property location="${analytics.cloud.asah.dir}/docker-compose.test.yml" name="analytics.cloud.docker.test.yaml" />

			<local name="container.names" />

			<beanshell>
				<![CDATA[
					import com.liferay.jenkins.results.parser.JenkinsResultsParserUtil;

					import java.util.regex.Matcher;
					import java.util.regex.Pattern;

					public static List getContainerNames() {
						File dockerComposeFile = new File(project.getProperty("analytics.cloud.docker.test.yaml"));

						if (!dockerComposeFile.exists()) {
							return new ArrayList();
						}

						List containerNames = new ArrayList();

						String content = JenkinsResultsParserUtil.read(dockerComposeFile);

						Pattern pattern = Pattern.compile("container_name: (.*)");

						Matcher matcher = pattern.matcher(content);

						while (matcher.find()) {
							containerNames.add(matcher.group(1));
						}

						return containerNames;
					}

					project.setProperty("container.names", JenkinsResultsParserUtil.join(",", getContainerNames()))
				]]>
			</beanshell>

			<local name="docker.logs.dir" />

			<condition else="/tmp/docker-logs" property="docker.logs.dir" value="${env.BUILD_DIR}/docker-logs">
				<and>
					<isset property="env.BUILD_DIR" />
					<isset property="env.BUILD_USER_CONTENT_URL" />
				</and>
			</condition>

			<mkdir dir="${docker.logs.dir}" />

			<for list="${container.names}" param="container.name">
				<sequential>
					<local name="container.file.name" />

					<beanshell>
						<![CDATA[
							String containerFileName = "@{container.name}.log";

							File containerFile = new File(project.getProperty("docker.logs.dir"), containerFileName);

							if (containerFile.exists()) {
								continue;
							}

							project.setProperty("container.file.name", containerFileName);
						]]>
					</beanshell>

					<execute failonerror="false">
						<![CDATA[
							docker logs @{container.name} > ${docker.logs.dir}/${container.file.name}
						]]>
					</execute>

					<if>
						<isset property="env.BUILD_USER_CONTENT_URL" />
						<then>
							<echo>${env.BUILD_USER_CONTENT_URL}/docker-logs/${container.file.name}</echo>
						</then>
						<else>
							<print-file file.name="${docker.logs.dir}/${container.file.name}" />
						</else>
					</if>
				</sequential>
			</for>

			<for list="${analytics.cloud.jstack.dumps}" param="analytics.cloud.jstack.dump">
				<sequential>
					<local name="analytics.cloud.container.name" />
					<local name="analytics.cloud.java.process" />

					<propertyregex
						input="@{analytics.cloud.jstack.dump}"
						override="true"
						property="analytics.cloud.container.name"
						regexp="([^=]+)=([^=]+)"
						replace="\1"
					/>

					<propertyregex
						input="@{analytics.cloud.jstack.dump}"
						override="true"
						property="analytics.cloud.java.process"
						regexp="([^=]+)=([^=]+)"
						replace="\2"
					/>

					<local name="analytics.cloud.jstack.log.file.name" />

					<property name="analytics.cloud.jstack.log.file.name" value="${analytics.cloud.container.name}.${analytics.cloud.java.process}.jstack.log" />

					<execute failonerror="false">
						<![CDATA[
							docker exec ${analytics.cloud.container.name} jstack -l ${analytics.cloud.java.process} > ${docker.logs.dir}/${analytics.cloud.jstack.log.file.name}
						]]>
					</execute>

					<if>
						<isset property="env.BUILD_USER_CONTENT_URL" />
						<then>
							<echo>${env.BUILD_USER_CONTENT_URL}/docker-logs/${analytics.cloud.jstack.log.file.name}</echo>
						</then>
						<else>
							<print-file file.name="${docker.logs.dir}/${analytics.cloud.jstack.log.file.name}" />
						</else>
					</if>
				</sequential>
			</for>
		</sequential>
	</macrodef>

	<macrodef name="pull-docker-image-dependencies">
		<attribute default="" name="analytics.cloud.image.names.excludes" />
		<attribute name="analytics.cloud.repository.dir" />

		<sequential>
			<local name="analytics.cloud.image.names.excludes" />

			<property name="analytics.cloud.image.names.excludes" value="@{analytics.cloud.image.names.excludes}" />

			<beanshell>
				<![CDATA[
					import com.liferay.jenkins.results.parser.JenkinsResultsParserUtil;

					String excludedImageNames = project.getProperty("analytics.cloud.image.names.excludes");

					JenkinsResultsParserUtil.pullDockerImageDependencies(new File("@{analytics.cloud.repository.dir}"), excludedImageNames.split(","), project.getProperty("analytics.cloud.ecr.registry"));
				]]>
			</beanshell>
		</sequential>
	</macrodef>

	<macrodef name="start-analytics-cloud">
		<sequential>
			<if>
				<equals arg1="${env.OSB_ASAH_STAGING_ENABLED}" arg2="true" />
				<then>
					<echo>Skipping start-analytics-cloud due to staging</echo>
				</then>
				<else>
					<fail message="Please set the property ${env.DOCKER_ENABLED}." unless="env.DOCKER_ENABLED" />

					<build-analytics-cloud-images />

					<create-analytics-cloud-docker-compose start.analytics.cloud="true" />

					<print-file file.name="${analytics.cloud.docker.test.yaml}" />

					<trycatch>
						<try>
							<trycatch property="analytics.cloud.error">
								<try>
									<local name="analytics.cloud.start.result" />

									<execute-analytics-cloud dir="${analytics.cloud.asah.dir}" resultproperty="analytics.cloud.start.result" timeout="${analytics.cloud.start.timeout}">
										#!/bin/bash

										touch local.env

										docker system prune --volumes -f

										docker-compose --file=${analytics.cloud.docker.test.yaml} --project-name=${analytics.cloud.project.name} up --detach

										while [[ -n $(docker ps | grep "health: starting") ]] || [[ -n $(docker ps | grep "unhealthy") ]]
										do
											echo "Waiting for docker compose to be healthy."

											sleep 30
										done

										echo "Docker compose is healthy."

										while [[ -z $(docker logs ${analytics.cloud.faro.container.name} | grep "Completed demo data creation") ]]
										do
											echo "Waiting for Faro demo data to be created."

											sleep 15
										done

										echo "Faro demo data was created."

										docker logs ${analytics.cloud.faro.container.name}

										docker system df
									</execute-analytics-cloud>

									<if>
										<not>
											<equals arg1="${analytics.cloud.start.result}" arg2="0" />
										</not>
										<then>
											<fail message="Failed to start Analytics Cloud with error code ${analytics.cloud.start.result}." />
										</then>
									</if>
								</try>
								<catch>
									<print-analytics-cloud-logs />

									<stop-analytics-cloud />

									<fail message="${analytics.cloud.error}" />
								</catch>
							</trycatch>
						</try>
						<catch>
							<fail message="${analytics.cloud.error}" />
						</catch>
					</trycatch>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="start-analytics-cloud-integration">
		<sequential>
			<fail message="Please set the property ${env.DOCKER_ENABLED}." unless="env.DOCKER_ENABLED" />

			<replaceregexp
				file="${analytics.cloud.asah.dir}/docker-compose.integration-test.yml"
				match="\&quot;9200:9200\&quot;"
				replace="&quot;${analytics.cloud.asah.elasticsearch.port}:9200&quot;"
			/>

			<local name="short.hostname" />

			<propertyregex
				input="${env.HOSTNAME}"
				override="true"
				property="short.hostname"
				regexp="(cloud-[^\.]+|test-\d+-\d+-\d+)(\.lax\.liferay\.com)?"
				replace="\1"
			/>

			<if>
				<isset property="short.hostname" />
				<then>
					<echo append="true" file="${analytics.cloud.asah.dir}/docker-compose.integration-test.yml"><![CDATA[
networks:
    default:
        external:
            name: ${short.hostname}]]></echo>
				</then>
			</if>

			<pull-docker-image-dependencies
				analytics.cloud.image.names.excludes="${analytics.cloud.asah.image.names.excludes}"
				analytics.cloud.repository.dir="${analytics.cloud.asah.dir}"
			/>

			<execute dir="${analytics.cloud.asah.dir}">
				docker-compose -f docker-compose.integration-test.yml up -d

				docker ps
			</execute>

			<exec executable="/bin/bash" outputproperty="network.ip.address">
				<arg value="-c" />
				<arg value="docker inspect ${short.hostname} -f '{{range .NetworkSettings.Networks}}{{.Gateway}}{{end}}'" />
			</exec>

			<echo file="${analytics.cloud.asah.dir}/temp-build-ext.gradle">import org.apache.tools.ant.taskdefs.condition.Os

subprojects {
	tasks.withType(Test) {
		doFirst {
			environment "LCP_ENGINE_ELASTICSEARCH_SERVER_IP", "${network.ip.address}"
			environment "LCP_PROJECT_ID", "test"
			environment "POSTGRESQL_SERVER_IP", "test_postgresql"
			environment "OSB_ASAH_BIG_QUERY_URL", "http://${network.ip.address}:9050"
			environment "OSB_ASAH_PUBSUB_EMULATOR_URL", "http://${network.ip.address}:8095"
			environment "OSB_ASAH_REDIS_URL", "http://${network.ip.address}:6379"
			environment.remove("GOOGLE_APPLICATION_CREDENTIALS")
		}

		maxHeapSize = "4096m"
	}
}

if (Os.isFamily(Os.FAMILY_WINDOWS)) {
	subprojects {
		afterEvaluate {
			project.tasks.withType(Test) {
				environment "DOCKER_COMPOSE_LOCATION", "C:/Program Files/Docker/Docker/resources/bin/docker-compose.exe"
				environment "DOCKER_LOCATION", "C:/Program Files/Docker/Docker/resources/bin/docker.exe"
			}
		}
	}
}</echo>

			<copy
				file="${analytics.cloud.asah.dir}/temp-build-ext.gradle"
				tofile="${analytics.cloud.asah.dir}/build-ext.gradle"
			/>

			<execute dir="${analytics.cloud.asah.dir}">
				docker ps

				docker network ls

				docker network inspect ${short.hostname}

				cat build-ext.gradle

				./gradlew testIntegration
			</execute>
		</sequential>
	</macrodef>

	<macrodef name="stop-analytics-cloud">
		<sequential>
			<if>
				<equals arg1="${env.OSB_ASAH_STAGING_ENABLED}" arg2="true" />
				<then>
					<echo>Skipping stop-analytics-cloud due to staging</echo>
				</then>
				<else>
					<fail message="Please set the property ${env.DOCKER_ENABLED}." unless="env.DOCKER_ENABLED" />

					<create-analytics-cloud-docker-compose start.analytics.cloud="true" />

					<property location="${analytics.cloud.asah.dir}/docker-compose.test.yml" name="analytics.cloud.docker.test.yaml" />

					<execute dir="${analytics.cloud.asah.dir}">
						docker ps -a

						touch local.env

						docker-compose --file=${analytics.cloud.docker.test.yaml} --project-name=${analytics.cloud.project.name} down --volumes

						docker system df
					</execute>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="stop-analytics-cloud-integration">
		<sequential>
			<fail message="Please set the property ${env.DOCKER_ENABLED}." unless="env.DOCKER_ENABLED" />

			<execute dir="${analytics.cloud.asah.dir}">
				docker ps -a

				docker-compose -f docker-compose.integration-test.yml down --volumes

				docker system df
			</execute>
		</sequential>
	</macrodef>

	<target name="build-analytics-cloud-images">
		<build-analytics-cloud-images />
	</target>

	<target name="start-analytics-cloud">
		<stop-analytics-cloud />

		<start-analytics-cloud />
	</target>

	<target name="start-analytics-cloud-integration">
		<stop-analytics-cloud-integration />

		<start-analytics-cloud-integration />
	</target>

	<target name="stop-analytics-cloud">
		<print-analytics-cloud-logs />

		<stop-analytics-cloud />
	</target>

	<target name="stop-analytics-cloud-integration">
		<print-analytics-cloud-logs />

		<stop-analytics-cloud-integration />
	</target>
</project>