build-ext.gradle

import com.bmuschko.gradle.docker.tasks.image.DockerTagImage

import com.liferay.gradle.plugins.app.docker.AppDockerPlugin

import javax.management.remote.JMXConnectorFactory as JmxFactory
import javax.management.remote.JMXServiceURL as JmxUrl

import org.kt3k.gradle.plugin.CoverallsPlugin

buildscript {
	dependencies {
		classpath group: "com.liferay", name: "com.liferay.gradle.plugins.app.docker", version: "1.0.1"
		classpath group: "org.kt3k.gradle.plugin", name: "coveralls-gradle-plugin", version: "2.6.3"
	}

	repositories {
		maven {
			url "https://cdn.lfrs.sl/repository.liferay.com/nexus/content/groups/public"
		}
	}
}

apply plugin: CoverallsPlugin

allprojects {
	apply plugin: JacocoPlugin

	jacoco {
		toolVersion = "0.7.8"
	}

	repositories {
		mavenLocal()

		maven {
			url "https://cdn.lfrs.sl/repository.liferay.com/nexus/content/groups/public"
		}
	}
}

if (System.getenv('TRAVIS')) {
	configure(subprojects.findAll {!it.childProjects}) {
		liferay {
			deployDir = new File(getClientDeployDir())
		}

		task createClientDeployDir(type: Exec) {
			commandLine 'mkdir', '-m', '777', '-p', "${getClientDeployDir()}"
		}

		task createJacocoTestIntegrationFile(type: Exec) {
			doFirst {
				commandLine 'touch', "${rootDir}/build/jacoco/testIntegration.exec"
			}
		}

		task copyJacocoAgent(type: Copy) {
			configurations.jacocoAgent.asFileTree.each {
				from(zipTree(it))
			}
			into "${rootDir}/build/jacoco"

			finalizedBy createJacocoTestIntegrationFile
		}

		deploy {
			dependsOn createClientDeployDir
		}

		test {
			ignoreFailures = false
		}

		testIntegration {
			ignoreFailures = false

			testLogging {
				events "started", "passed", "skipped", "failed", "standardOut", "standardError"
				showExceptions true
				exceptionFormat "full"
				showCauses true
				showStackTraces true
			}
		}

		setUpTestableTomcat {
			enabled = false
		}

		startTestableTomcat {
			enabled = false
		}

		stopTestableTomcat {
			enabled = false
		}
	}

	apply plugin: AppDockerPlugin

	appDocker {
		imageName this.getImageName()
		imageUser this.getUserName()
		inputDir "adaptive-media-docker"

		def excludedModules = project.getProperty('com.liferay.adaptive.media.docker.excluded.modules').split(',')

		onlyIf {
			project -> !excludedModules.contains(project.name)
		}
	}

	docker {
		registryCredentials {
			username = System.getenv().get("DOCKER_USER")
			password = System.getenv().get("DOCKER_PWD")
		}
	}

	allprojects {
		ext {
			dockerDestinationDir = prepareAppDockerImageInputDir.destinationDir
		}
	}

	task checkDocker() {
		doLast {
			def url = "http://localhost:8080"

			println("Trying to reach " + url)

			while (true) {
				try {
					print(".")

					url.toURL().text

					println("Portal startup finished")

					break
				}
				catch (Exception e) {
					Thread.sleep(1000)
				}
			}
		}
	}

	task runDocker(type: Exec) {
		dependsOn subprojects.findAll {!it.childProjects}.copyJacocoAgent

		def javaOpts = project.getProperty('com.liferay.adaptive.media.java.opts')

		javaOpts += ' ' + project.getProperty('com.liferay.adaptive.media.jacoco.opts')

		if (project.hasProperty('debug')) {
			javaOpts += ' ' + project.getProperty('com.liferay.adaptive.media.debug.opts')
		}

		commandLine 'docker', 'run',
				'-e', "JACOCO_DIR=${rootDir}/build/jacoco",
				'-e', "JAVA_OPTS=$javaOpts",
				'-e', "ROOT_DIR=${rootDir}",
				'-p', '5005:5005',
				'-p', '8080:8080',
				'-p', '8099:8099',
				'-p', '8778:8778',
				'-p', '11311:11311',
				'-v', "${rootDir}/build/jacoco:/jacoco",
				'-v', "${getClientDeployDir()}:/liferay/deploy",
				'-d',
				'--name', "com-liferay-adaptive-media",
				getImageNameWithUserAndVersion()

		finalizedBy checkDocker
	}
}

def getClientDeployDir() {
	return "${rootDir}/${project.property('com.liferay.adaptive.media.deploy.dir')}"
}

def getImageName() {
	return project.property("com.liferay.adaptive.media.docker.image.name")
}

def getImageVersion() {
	return project.property("com.liferay.adaptive.media.docker.image.version")
}

def getUserName() {
	return project.property("com.liferay.adaptive.media.docker.username")
}

def getImageNameWithUser() {
	return getUserName() + "/" + getImageName()
}

def getImageNameWithUserAndVersion() {
	return getImageNameWithUser() + ":" + getImageVersion()
}

task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
	dependsOn = subprojects.findAll{!it.childProjects}.test
	additionalSourceDirs = files(subprojects.findAll{!it.childProjects}.sourceSets.main.allSource.srcDirs)
	sourceDirectories = files(subprojects.findAll{!it.childProjects}.sourceSets.main.allSource.srcDirs)
	classDirectories = files(subprojects.findAll{!it.childProjects}.sourceSets.main.output)

	executionData = files(subprojects.findAll{!it.childProjects}.jacocoTestReport.executionData, "${rootDir}/build/jacoco/testIntegration.exec")

	onlyIf = { true }

	afterEvaluate {
		classDirectories = files(classDirectories.files.collect {
			fileTree(dir: it,
					exclude: [
							'**/*Exception*',
							'**/model/*Model*',
							'**/model/*Soap*',
							'**/model/*Wrapper*',
							'**/model/impl/*BaseImpl*',
							'**/model/impl/*CacheModel*',
							'**/model/impl/*ModelImpl*',
							'**/service/*ServiceUtil*',
							'**/service/*ServiceWrapper*',
							'**/service/base/*',
							'**/service/http/*',
							'**/service/persistence/*Util*',
							'**/service/persistence/impl/*PersistenceImpl*',
							'**/service/persistence/impl/*FinderBaseImpl*',
							'**/service/util/*',
							'**/test/util/*',
							'adaptive-media-demo/**',
							'adaptive-media-demo-data-creator-api/**',
							'adaptive-media-demo-data-creator-impl/**',
					])
		})
	}

	reports {
		html.enabled = true
		xml.enabled = true
		xml.destination "${rootDir}/build/reports/jacoco/test/jacocoTestReport.xml"
		csv.enabled = false
	}

	doFirst {
		executionData = files(executionData.findAll { it.exists() })
	}
}

task dumpJacoco {
	doLast {
		def serverUrl = 'service:jmx:rmi:///jndi/rmi://localhost:8099/jmxrmi'
		String beanName = "org.jacoco:type=Runtime"
		def server = JmxFactory.connect(new JmxUrl(serverUrl)).MBeanServerConnection
		def gmxb = new GroovyMBean(server, beanName)

		gmxb.dump(true)
	}
}

tasks.coveralls {
	dependsOn jacocoRootReport
}

coveralls.sourceDirs = files(subprojects.findAll{!it.childProjects}.sourceSets.main.allSource.srcDirs).collect {
	file -> file.absolutePath
}