build.gradle

buildscript {
	repositories {
		mavenCentral()
		maven {
			url "https://plugins.gradle.org/m2/"
		}
	}
	dependencies {
		classpath(
			"org.yaml:snakeyaml:1.24",
		)
	}
}

plugins {
	id "java"
	id "scala"
	id "signing"
	id "maven-publish"
	id "com.bmuschko.docker-remote-api" version "6.4.0"
	id "com.diffplug.gradle.spotless" version "3.18.0"
	id "io.codearte.nexus-staging" version "0.20.0"
	id "de.marcphilipp.nexus-publish" version "0.2.0"
}

repositories {
	maven { url "https://maven.google.com" }
	maven { url "https://jitpack.io" }
	mavenCentral()
}

description = "Mongoose is a high-load storage performance testing tool"
group = "com.github.emc-mongoose"
version = defineVersion()
sourceCompatibility = 11
targetCompatibility = 11

import java.nio.file.Files
import java.nio.file.Paths
import java.nio.file.StandardOpenOption
import org.yaml.snakeyaml.Yaml

ext {
	depVersion = [
		confuse            : "1.2.1",
		confuseIoYaml      : "1.0.0",
		commonsCodec       : "1.11",
		commonsLang        : "2.6",
		disruptor          : "3.4.2",
		fastutil           : "8.2.2",
		//fiber4j            : "1.1.0",
		fiber4j            : "59d6ec1215",
		jackson            : "2.9.8",
		//javaCommons        : "2.3.6",
		javaCommons        : "f48e91c8ba",
		jetty              : "9.4.14.v20181114",
		junit              : "4.12",
		scala              : "2.12.6",
		slf4j              : "1.7.25",
		log4j              : "2.19.0",
		prometheus         : "0.6.0",
		nashorn            : "15.6",
	]
	log4j2PluginsDatPath = Paths.get(
		"META-INF", "org", "apache", "logging", "log4j", "core", "config", "plugins", "Log4j2Plugins.dat",
	)
	rootPkg = "com.emc.mongoose.base"
	mainClass = "${rootPkg}.Main"
	provided3rdPartyClasses = [
		"it/unimi/dsi/fastutil/bytes/ByteIterator.class",
		"it/unimi/dsi/fastutil/Stack.class",
		"it/unimi/dsi/fastutil/Arrays.class",
		"it/unimi/dsi/fastutil/Swapper.class",
		"it/unimi/dsi/fastutil/Hash.class",
		"it/unimi/dsi/fastutil/Hash\$Strategy.class",
		"it/unimi/dsi/fastutil/Function.class",
		"it/unimi/dsi/fastutil/HashCommon.class",
		"it/unimi/dsi/fastutil/objects/AbstractObjectCollection.class",
		"it/unimi/dsi/fastutil/objects/ObjectSet.class",
		"it/unimi/dsi/fastutil/objects/ObjectBidirectionalIterator.class",
		"it/unimi/dsi/fastutil/objects/Object2IntMap.class",
		"it/unimi/dsi/fastutil/objects/Object2IntMap\$FastEntrySet.class",
		"it/unimi/dsi/fastutil/objects/ObjectList.class",
		"it/unimi/dsi/fastutil/objects/AbstractObjectList.class",
		"it/unimi/dsi/fastutil/objects/ObjectCollection.class",
		"it/unimi/dsi/fastutil/objects/AbstractObjectListIterator.class",
		"it/unimi/dsi/fastutil/objects/ObjectArrayList.class",
		"it/unimi/dsi/fastutil/objects/AbstractObject2IntFunction.class",
		"it/unimi/dsi/fastutil/objects/Object2IntFunction.class",
		"it/unimi/dsi/fastutil/objects/ObjectIterators.class",
		"it/unimi/dsi/fastutil/objects/AbstractObject2IntMap.class",
		"it/unimi/dsi/fastutil/objects/ObjectArrays.class",
		"it/unimi/dsi/fastutil/objects/AbstractObjectBidirectionalIterator.class",
		"it/unimi/dsi/fastutil/objects/ObjectIterator.class",
		"it/unimi/dsi/fastutil/objects/ObjectArraySet.class",
		"it/unimi/dsi/fastutil/objects/Object2IntOpenHashMap.class",
		"it/unimi/dsi/fastutil/objects/ObjectListIterator.class",
		"it/unimi/dsi/fastutil/objects/ObjectIterable.class",
		"it/unimi/dsi/fastutil/objects/AbstractObjectSet.class",
		"it/unimi/dsi/fastutil/objects/AbstractObjectIterator.class",
		"it/unimi/dsi/fastutil/BidirectionalIterator.class",
		"it/unimi/dsi/fastutil/shorts/ShortIterator.class",
		"it/unimi/dsi/fastutil/ints/IntArrayList.class",
		"it/unimi/dsi/fastutil/ints/AbstractIntIterator.class",
		"it/unimi/dsi/fastutil/ints/IntListIterator.class",
		"it/unimi/dsi/fastutil/ints/AbstractIntCollection.class",
		"it/unimi/dsi/fastutil/ints/AbstractInt2IntMap.class",
		"it/unimi/dsi/fastutil/ints/AbstractInt2ObjectFunction.class",
		"it/unimi/dsi/fastutil/ints/AbstractIntBidirectionalIterator.class",
		"it/unimi/dsi/fastutil/ints/Int2IntFunction.class",
		"it/unimi/dsi/fastutil/ints/AbstractIntSet.class",
		"it/unimi/dsi/fastutil/ints/Int2IntOpenHashMap.class",
		"it/unimi/dsi/fastutil/ints/IntArraySet.class",
		"it/unimi/dsi/fastutil/ints/IntList.class",
		"it/unimi/dsi/fastutil/ints/IntStack.class",
		"it/unimi/dsi/fastutil/ints/IntIterator.class",
		"it/unimi/dsi/fastutil/ints/IntBidirectionalIterator.class",
		"it/unimi/dsi/fastutil/ints/IntIterable.class",
		"it/unimi/dsi/fastutil/ints/Int2ObjectFunction.class",
		"it/unimi/dsi/fastutil/ints/Int2ObjectOpenHashMap.class",
		"it/unimi/dsi/fastutil/ints/Int2ObjectOpenHashMap\$KeyIterator.class",
		"it/unimi/dsi/fastutil/ints/Int2ObjectOpenHashMap\$KeySet.class",
		"it/unimi/dsi/fastutil/ints/Int2ObjectOpenHashMap\$MapIterator.class",
		"it/unimi/dsi/fastutil/ints/IntArrays.class",
		"it/unimi/dsi/fastutil/ints/IntCollection.class",
		"it/unimi/dsi/fastutil/ints/AbstractInt2IntFunction.class",
		"it/unimi/dsi/fastutil/ints/Int2ObjectMap.class",
		"it/unimi/dsi/fastutil/ints/Int2ObjectMap\$FastEntrySet.class",
		"it/unimi/dsi/fastutil/ints/Int2IntMap.class",
		"it/unimi/dsi/fastutil/ints/Int2IntMap\$FastEntrySet.class",
		"it/unimi/dsi/fastutil/ints/IntIterators.class",
		"it/unimi/dsi/fastutil/ints/IntComparator.class",
		"it/unimi/dsi/fastutil/ints/AbstractIntListIterator.class",
		"it/unimi/dsi/fastutil/ints/AbstractIntList.class",
		"it/unimi/dsi/fastutil/ints/AbstractInt2ObjectMap.class",
		"it/unimi/dsi/fastutil/ints/IntSet.class",
		"it/unimi/dsi/fastutil/longs/Long2LongFunction.class",
	]
	jarFileName = "mongoose"
	javaHome = System.properties["java.home"]
	jreOutputDir = "${project.buildDir}${File.separator}jre"
	modulesDepsFilePath = "${project.buildDir}${File.separator}modules.deps"
}

wrapper {
	gradleVersion = "6.4"
}

configurations {
	partial.extendsFrom compileOnly
	provided
	testCompile {
		extendsFrom(compileOnly, provided)
	}
}

sourceSets {
	main {
		compileClasspath += configurations.provided
	}
}

dependencies {

	compileOnly("it.unimi.dsi:fastutil:${depVersion.fastutil}") {
		transitive = false
	}
	annotationProcessor "org.apache.logging.log4j:log4j-core:${depVersion.log4j}"
	provided(
		"commons-codec:commons-codec:${depVersion.commonsCodec}",
		"commons-lang:commons-lang:${depVersion.commonsLang}",
		"com.fasterxml.jackson.core:jackson-annotations:${depVersion.jackson}",
		"com.fasterxml.jackson.core:jackson-core:${depVersion.jackson}",
		"com.fasterxml.jackson.core:jackson-databind:${depVersion.jackson}",
		"com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:${depVersion.jackson}",
		"com.github.akurilov:confuse:${depVersion.confuse}",
		"com.github.akurilov:confuse-io-yaml:${depVersion.confuseIoYaml}",
		//"com.github.akurilov:fiber4j:${depVersion.fiber4j}",
		"com.github.dlarge:fiber4j:${depVersion.fiber4j}",
		//"com.github.akurilov:java-commons:${depVersion.javaCommons}",
		"com.github.dlarge:java-commons:${depVersion.javaCommons}",
		"com.lmax:disruptor:${depVersion.disruptor}",
		"io.prometheus:simpleclient:${depVersion.prometheus}",
		"io.prometheus:simpleclient_servlet:${depVersion.prometheus}",
		"io.prometheus:simpleclient_hotspot:${depVersion.prometheus}",
		"org.apache.logging.log4j:log4j-api:${depVersion.log4j}",
		"org.apache.logging.log4j:log4j-core:${depVersion.log4j}",
		"org.eclipse.jetty:jetty-server:${depVersion.jetty}",
		"org.eclipse.jetty:jetty-servlet:${depVersion.jetty}",
		"org.eclipse.jetty:jetty-rewrite:${depVersion.jetty}",
		// actually the deps below are the runtime deps
		"org.apache.logging.log4j:log4j-jul:${depVersion.log4j}",
		"org.apache.logging.log4j:log4j-slf4j-impl:${depVersion.log4j}",
		"org.slf4j:slf4j-api:${depVersion.slf4j}",
		"org.openjdk.nashorn:nashorn-core:${depVersion.nashorn}",
	)

	testCompile(
		"com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:${depVersion.jackson}",
		"junit:junit:${depVersion.junit}",
		"org.scala-lang:scala-compiler:${depVersion.scala}",
		"org.scala-lang:scala-library:${depVersion.scala}",
		"com.github.docker-java:docker-java:[3,)",
		"org.apache.commons:commons-csv:1.1",
		"com.google.guava:guava:25.1-jre",
		"org.apache.commons:commons-math3:3.6.1",
		"org.mockito:mockito-core:2.23.0",
	)
}

test {
	useJUnit()
	exclude "com/emc/mongoose/integration/*"
	exclude "com/emc/mongoose/params/*"
	exclude "com/emc/mongoose/perf/*"
	exclude "com/emc/mongoose/util/*"
	exclude "**/TemplateTest.*"
	exclude "**/*PerfTest.*"
	jvmArgs "-XX:MaxDirectMemorySize=2g"
	jvmArgs "-XX:+HeapDumpOnOutOfMemoryError"
	maxHeapSize "2g"
	testLogging {
		events = [
			"standardOut", "skipped", "started", "failed",
		]
		showExceptions = true
		showStandardStreams = true
	}
}

task perfTest(type: Test) {
	useJUnit()
	include "com/emc/mongoose/perf/*"
	jvmArgs "-XX:MaxDirectMemorySize=2g"
	jvmArgs "-XX:+HeapDumpOnOutOfMemoryError"
	maxHeapSize "2g"
	testLogging {
		events = [
			"standardOut", "skipped", "started", "failed",
		]
		showExceptions = true
		showStandardStreams = true
	}
}

task integrationTest(type: Test) {
	useJUnit()
	include "com/emc/mongoose/integration/*"
	exclude "**/RollingAppenderTest*"
	jvmArgs "-XX:MaxDirectMemorySize=2g"
	jvmArgs "-XX:+HeapDumpOnOutOfMemoryError"
	maxHeapSize "2g"
	testLogging {
		events = [
			"standardOut", "skipped", "started", "failed",
		]
		showExceptions = true
		showStandardStreams = true
	}
}

String defineVersion() {
	def configFilePath = [ project.rootDir, "src", "main", "resources", "config", "defaults.yaml", ]
		.join(File.separator);
	def inputFile = new File(configFilePath)
	def parser = new Yaml()
	def y = parser.load(inputFile.text)
	y.run.version
}

task mongooseVersion {
	group = "versioning"
	description = "Prints Mongoose version."
	doLast { logger.quiet version }
}

task mergeLog4j2PluginsDat(dependsOn: compileJava) {
	doLast {

		byte[] pluginsData
		byte[] customPluginsData

		configurations.provided
			.each {
			if(!it.isDirectory()) {
				zipTree(it)
					.filter {
					it.toString().endsWith(log4j2PluginsDatPath.toString())
				}
				.each {
					pluginsData = Files.readAllBytes(Paths.get(it.toString()))
				}
			}
		}

		sourceSets.main.output.classesDirs
			.any {
			customPluginsData = Files.readAllBytes(
				Paths.get(it.toString(), log4j2PluginsDatPath.toString(),)
			)
		}

		sourceSets.main.output.classesDirs
			.any {
			Files.write(
				Paths.get(it.toString(), log4j2PluginsDatPath.toString(),),
				pluginsData, StandardOpenOption.TRUNCATE_EXISTING
			)
			Files.write(
				Paths.get(it.toString(), log4j2PluginsDatPath.toString(),),
				customPluginsData, StandardOpenOption.APPEND
			)
		}
	}
}

jar {
	dependsOn += mergeLog4j2PluginsDat
	baseName = "mongoose"
	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
	excludes = [
		"**/*.css",
		"**/*.html",
		"META-INF/*.DSA",
		"META-INF/*.LIST",
		"META-INF/*.RSA",
		"META-INF/*.SF",
		"OSGI-INF/*",
		"module-info.class",
	]
	manifest {
		attributes(
			"Automatic-Module-Name": rootPkg,
			"Main-Class": mainClass,
			"Implementation-Title": project.description,
			"Implementation-Version": project.version,
			"Multi-Release": "true",
		)
	}
	provided3rdPartyClasses.each {
		final clsName = it
		from(configurations.partial.collect { zipTree(it) }) {
			include "**" + clsName
		}
	}
	from configurations.provided.collect {
		it.isDirectory() ? it : zipTree(it)
	}
}

javadoc {
	failOnError = false
	classpath += configurations.provided
}

task javadocJar(type: Jar, dependsOn: javadoc) {
	classifier = "javadoc"
	from javadoc.destinationDir
}

task sourcesJar(type: Jar, dependsOn: classes) {
	classifier = "sources"
	from sourceSets.main.allSource
}

// Maven Central deployment ////////////////////////////////////////////////////////////////////////////////////////////

artifacts {
	archives jar
	archives sourcesJar
	archives javadocJar
}

nexusStaging {
	packageGroup = project.group
	username = project.hasProperty("ossrhUsername") ? project.property("ossrhUsername") : null
	password = project.hasProperty("ossrhPassword") ? project.property("ossrhPassword") : null
	//stagingProfileId = "491ac45c9daed9"
	numberOfRetries = 100
	delayBetweenRetriesInMillis = 10000
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			artifactId = project.name
			groupId = project.group
			artifact jar
			artifact javadocJar
			artifact sourcesJar
			pom {
				name = project.name
				description = project.description
				url = "https://github.com/emc-mongoose/mongoose-base"
				scm {
					connection = "https://github.com/emc-mongoose/mongoose-base.git"
					developerConnection = "https://github.com/emc-mongoose/mongoose-base.git"
					url = "https://github.com/emc-mongoose/mongoose-base.git"
				}
				licenses {
					license {
						name = "The MIT License (MIT)"
						url = "https://github.com/emc-mongoose/mongoose-base/LICENSE"
					}
				}
				developers {
					developer {
						id = "akurilov"
						name = "Andrey Kurilov"
						email = "akurilov123@gmail.com"
					}
				}
			}
		}
	}
	repositories {
		maven {
			url = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
			credentials {
				username = project.hasProperty("ossrhUsername") ? project.property("ossrhUsername") : null
				password = project.hasProperty("ossrhPassword") ? project.property("ossrhPassword") : null
			}
		}
	}
}

signing {
	sign publishing.publications
}

task releaseToMavenCentral {
	dependsOn += publishToNexus
	dependsOn += closeAndReleaseRepository
}

// Custom JRE //////////////////////////////////////////////////////////////////////////////////////////////////////////

def execute(cmd, dir = null) {
	def stdOut = new StringBuilder(), stdErr = new StringBuilder()
	def proc = dir == null ? cmd.execute() : cmd.execute([], dir)
	proc.consumeProcessOutput(stdOut, stdErr)
	proc.waitForOrKill(100_000)
	println "${cmd}\n\t$stdErr"
	stdOut.toString()
}

task listAllModulesDeps(dependsOn: jar) {
	doLast {
		def modulesDepsFile = new File(modulesDepsFilePath)
		modulesDepsFile.delete()
		def cmd = [
			"${javaHome}${File.separator}bin${File.separator}jdeps",
			"--module-path ${javaHome}${File.separator}jmods",
			"--list-deps ${jar.outputs.files.iterator().next()}",
		].join(' ')
		def deps = execute(cmd).takeWhile { it != '/' } + '\n'
		modulesDepsFile.append(deps)
	}
}

task dedupModulesDeps(dependsOn: listAllModulesDeps) {
	doLast {
		def deps = execute("sort -b -u ${modulesDepsFilePath}")
			.lines()
			.findAll { !it.isBlank() }
			.join('\n')
		def modulesDepsFile = new File(modulesDepsFilePath)
		modulesDepsFile.delete()
		modulesDepsFile.append(deps)
	}
}

task jre(dependsOn: dedupModulesDeps) {
	doLast {
		def modulesToAdd = new File(modulesDepsFilePath)
			.readLines()
			*.trim()
			.join(',')
		execute(
			[
				"${javaHome}${File.separator}bin${File.separator}jlink",
				"--no-header-files --no-man-pages --strip-debug --compress=2 --bind-services",
				"--module-path ${javaHome}${File.separator}jmods --add-modules ${modulesToAdd}",
				"--output ${jreOutputDir}",
			].join(' ')
		)
	}
}

// Docker tasks ////////////////////////////////////////////////////////////////////////////////////////////////////////

import com.bmuschko.gradle.docker.tasks.image.*
import com.bmuschko.gradle.docker.tasks.container.*

task dockerBuildImage(type: DockerBuildImage) {
	inputDir = project.projectDir
	dockerFile = project.file("ci${File.separator}docker${File.separator}Dockerfile")
	images.add("emcmongoose/${project.name}:${version}")
	images.add("emcmongoose/${project.name}:testing")
}

task dockerPushProductionImage(type: DockerPushImage, dependsOn: dockerBuildImage) {
	images.add("emcmongoose/${project.name}:${version}")
}

task dockerPushTestingImage(type: DockerPushImage, dependsOn: dockerBuildImage) {
	images.add("emcmongoose/${project.name}:testing")
}

// Robot Framework /////////////////////////////////////////////////////////////////////////////////////////////////////

task dockerBuildImageRobotest(type: DockerBuildImage) {
	inputDir = project.projectDir
	dockerFile = project.file("ci${File.separator}docker${File.separator}Dockerfile.robotest")
	images.add("emcmongoose/${project.name}-robotest:${version}")
}

task dockerCreateContainerRobotest(type: DockerCreateContainer, dependsOn: [dockerBuildImage, dockerBuildImageRobotest]) {
	attachStderr = true
	attachStdout = true
	hostConfig.autoRemove = true
	hostConfig.binds = [
		"${project.buildDir}": "/root/mongoose/build",
		"/var/run/docker.sock": "/var/run/docker.sock",
	]
	envVars = [
		"HOST_WORKING_DIR": projectDir.absolutePath,
		"MONGOOSE_VERSION": version,
		"MONGOOSE_IMAGE_VERSION": version,
		"SERVICE_HOST": "localhost",
		"SUITE": System.getenv("SUITE"),
		"TEST": System.getenv("TEST"),
	]
	imageId = dockerBuildImageRobotest.getImageId()
	hostConfig.network = "host"
	tty = true
	doLast {
		println "Created the container for the ${System.env.SUITE}.${System.env.TEST} test"
	}
}

task dockerStartContainerRobotest(type: DockerStartContainer, dependsOn: dockerCreateContainerRobotest) {
	targetContainerId dockerCreateContainerRobotest.getContainerId()
}

task robotest(type: DockerWaitContainer, dependsOn: dockerStartContainerRobotest) {
	targetContainerId dockerCreateContainerRobotest.getContainerId()
	awaitStatusTimeout = 600 // 10 min w/o output -> fail on Travis CI
	doLast {
		if(0 != exitCode) {
			throw new GradleException("Some robotests FAILED")
		} else {
			println "Robotests PASSED"
		}
	}
}

// Code Formatting /////////////////////////////////////////////////////////////////////////////////////////////////////

spotless {
	format "misc", {
		target "**/*.gradle", "**/*.js", "**/*.groovy", "**/*.py", "**/*.scala"
		indentWithTabs()
		endWithNewline()
	}
	java {
		target "**/*.java"
		endWithNewline()
		removeUnusedImports()
		eclipse().configFile "spotless.eclipseformat.xml"
	}
}