build.gradle

import groovy.json.JsonSlurper
import groovy.json.JsonParserType

description = "Mongoose is a high-load storage performance testing tool"

buildscript {
	dependencies {
		classpath "com.google.gradle:osdetector-gradle-plugin:1.4.0"
	}
	repositories {
		mavenCentral()
	}
}

allprojects {
	apply plugin: "java"
	group = "com.github.emc-mongoose"
	version = defineVersion()
}

ext {

	depVersion = [
		commonsCodec : "1.10",
		commonsLang : "2.6",
		disruptor : "3.3.4",
		jackson : "2.9.0",
		javaCommons : "[1.0.8,)",
		javaCoroutines : "[1.0.13,)",
		javassist : "3.21.0-GA",
		slf4j : "1.7.24",
		log4j : "2.8.2",
		metrics : "3.2.4",
		nagaina : "[3.5.18,)",
		netty : "4.1.15.Final",
	]

	mutualProjects = subprojects.findAll {
		it != project("api") && it != project("load") && it != project("storage") &&
			it != project("tests")
	}

	setClassPath = {
		configurations -> [
			configurations.runtime
				.collect { file ->
					// it's 3rd party if jar file name doesn't contain the root project name
					if(-1 == file.name.indexOf(rootProject.name)) {
						["lib", file.name].join(File.separator)
					} else {
						file.name
					}
				}
				.join(" "),
		]
			.join(" ")
	}
}

subprojects {

	apply plugin: "maven"
	apply plugin: "signing"

	tasks.withType(JavaCompile) {
		sourceCompatibility = JavaVersion.VERSION_1_8
		targetCompatibility = JavaVersion.VERSION_1_8
	}

	task("create-dirs").doLast(
		{
			sourceSets*.java.srcDirs*.each { it.mkdirs() }
			sourceSets*.resources.srcDirs*.each { it.mkdirs() }
		}
	)

	repositories {
		mavenCentral()
	}

	jar {
		LinkedList names = new LinkedList()
		collectName(project, names)
		def name = names.join("-")
		archiveName "$name.$extension"
		manifest {
			attributes (
				"Implementation-Version": version,
				"Implementation-Title": "$name"
			)
		}
	}

	task sourcesJar(type: Jar, dependsOn: classes) {
		LinkedList names = new LinkedList()
		collectName(project, names)
		def name = names.join("-")
		classifier = "sources"
		archiveName "$name-$classifier.$extension"
		from sourceSets.main.allSource
	}

	task javadocJar(type: Jar, dependsOn: javadoc) {
		LinkedList names = new LinkedList()
		collectName(project, names)
		def name = names.join("-")
		classifier = "javadoc"
		archiveName "$name-$classifier.$extension"
		from javadoc.destinationDir
	}

	artifacts {
		archives jar
		archives sourcesJar
		archives javadocJar
	}

	test {
		jvmArgs "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005"
		jvmArgs "-XX:MaxDirectMemorySize=2g"
		jvmArgs "-XX:+HeapDumpOnOutOfMemoryError"
		maxHeapSize "2g"
		systemProperty "com.sun.management.jmxremote", "true"
		systemProperty "com.sun.management.jmxremote.port", "9010"
		systemProperty "com.sun.management.jmxremote.rmi.port", "9010"
		systemProperty "com.sun.management.jmxremote.local.only", "false"
		systemProperty "com.sun.management.jmxremote.authenticate", "false"
		systemProperty "com.sun.management.jmxremote.ssl", "false"
		testLogging {
			events "passed", "skipped", "failed", "standardOut"
			showExceptions = true
			showStandardStreams = true
		}
	}

	signing {
		required {
			gradle.taskGraph.hasTask("uploadArchives")
		}
		sign configurations.archives
	}

	// see http://central.sonatype.org/pages/gradle.html for details
	uploadArchives {

		// prevent the execution for empty (not leaf) subprojects and tests packages
		if(project.name.contains("tests") || !(project in mutualProjects)) {
			return
		}

		LinkedList nameParts = new LinkedList()
		collectName(project, nameParts)

		def ossrhUsername = project.hasProperty("ossrhUsername") ?
			project.property("ossrhUsername") : null
		def ossrhPassword = project.hasProperty("ossrhPassword") ?
			project.property("ossrhPassword") : null

		repositories {
			mavenDeployer {
				beforeDeployment {
					MavenDeployment deployment -> signing.signPom(deployment)
				}

				repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
					authentication(userName: ossrhUsername, password: ossrhPassword)
				}

				snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
					authentication(userName: ossrhUsername, password: ossrhPassword)
				}

				pom {

					groupId = rootProject.group
					name = nameParts.join("-")
					artifactId = name

					project {
						description = rootProject.description

						url "https://github.com/emc-mongoose/mongoose/wiki"

						scm {
							connection "https://github.com/emc-mongoose/mongoose.git"
							developerConnection "https://github.com/emc-mongoose/mongoose.git"
							url "https://github.com/emc-mongoose/mongoose.git"
						}

						licenses {
							license {
								name "The MIT License (MIT)"
								url "https://github.com/emc-mongoose/mongoose/wiki/License"
							}
						}

						developers {
							developer {
								id "akurilov"
								name "Andrey Kurilov"
								email "akurilov123@gmail.com"
							}
						}
					}
				}
			}
		}
	}
}

task wrapper(type: Wrapper) {
	gradleVersion = "3.5"
}

task dist(type: Tar) {
	group = "distribution"
	description = "Collect Mongoose as an archive"
	dependsOn tasks.withType(Jar)
	baseName = rootProject.name
	compression = Compression.GZIP
	destinationDir = new File("build", "dist")
	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
	into("$baseName-$rootProject.version") {
		into("config") {
			from { "config" }
		}
		into("lib") {
			for(Project p: mutualProjects) {
				from p.configurations.runtime {
					exclude "${rootProject.name}*.jar"
				}
			}
		}
		for(Project p: mutualProjects) {
			from p.jar.outputs.files
		}
		into("scenario") {
			from { "scenario" }
		}
	}
}

task printVersion {
	group = "versioning"
	description = "Prints Mongoose version."
	doLast { logger.quiet "Mongoose version: $version" }
}

void collectName(Project p, LinkedList<String> names) {
	names.addFirst p.name
	if(p.parent != null) {
		collectName(p.parent, names)
	}
}

String defineVersion() {
	def configFilePath = [rootDir, "config", "defaults.json"].join(File.separator);
	def inputFile = new File(configFilePath)
	def json = new JsonSlurper().setType(JsonParserType.LAX).parseText(inputFile.text)
	json.version
}