build.gradle

/*
 * Copyright (c) 2011-2017 Pivotal Software Inc, All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
buildscript {
	//we define kotlin version for benefit of both core and test (see kotlin-gradle-plugin below)
	ext.kotlinVersion = '1.3.71'
	repositories {
		maven { url "https://repo.spring.io/plugins-release" }
	}
	dependencies {
		classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
	}
}


plugins {
	id "com.github.johnrengelman.shadow" version "4.0.2"
	id 'org.asciidoctor.convert' version '1.5.11'
	id "me.champeau.gradle.japicmp" version "0.2.6"
	id "de.undercouch.download" version "3.4.3"
	id "org.unbroken-dome.test-sets" version "3.0.0" apply false
	//note: build scan plugin now must be applied in settings.gradle
	id "com.jfrog.artifactory" version "4.15.2" apply false
	id 'biz.aQute.bnd.builder' version '5.0.1' apply false
}

apply plugin: "io.reactor.gradle.detect-ci"
apply from: "gradle/asciidoc.gradle" //asciidoc (which is generated from root dir)
apply from: "gradle/releaser.gradle"

ext {
	jdk = JavaVersion.current().majorVersion
	jdkJavadoc = "https://docs.oracle.com/javase/$jdk/docs/api/"
	if (JavaVersion.current().isJava11Compatible()) {
		jdkJavadoc = "https://docs.oracle.com/en/java/javase/$jdk/docs/api/"
	}
	println "JDK Javadoc link for this build is ${rootProject.jdkJavadoc}"

	/*
	 * Note that some versions can be bumped by a script.
	 * These are found in `gradle.properties`...
	 *
	 * Versions not necessarily bumped by a script (testing, etc...) below:
	 */
	// Misc not often upgraded
	jsr305Version = '3.0.2'
	jsr166BackportVersion = '1.0.0.RELEASE'

	// Blockhound
	blockhoundVersion = '1.0.3.RELEASE'

	// Logging
	slf4jVersion = '1.7.12'
	logbackVersion = '1.1.2'

	// Testing
	jUnitVersion = '4.13'
	jUnitJupiterVersion = '5.6.0'
	assertJVersion = '3.11.1'
	mockitoVersion = '2.23.0'
	jUnitParamsVersion = '1.1.1'
	awaitilityVersion = '3.1.2'
	throwingFunctionVersion = '1.5.0'
	javaObjectLayoutVersion = '0.9'
	testNgVersion = '6.8.5'
}

//only publish scan if a specific gradle entreprise server is passed
//typically, for local usage, you would temporarily set the env with:
// `GRADLE_ENTERPRISE_URL=https://myge.example.com/ gradle foo`
if (System.getenv('GRADLE_ENTERPRISE_URL')) {
	gradleEnterprise {
		buildScan {
			captureTaskInputFiles = true
			obfuscation {
				ipAddresses { addresses -> addresses.collect { '0.0.0.0' } }
			}
			publishAlways()
			server = System.getenv('GRADLE_ENTERPRISE_URL')
		}
	}
}

configure(subprojects) { p ->
	apply plugin: 'java'
	apply plugin: 'jacoco'
	apply from: "${rootDir}/gradle/setup.gradle"

	description = 'Non-Blocking Reactive Foundation for the JVM'
	group = 'io.projectreactor'

	repositories {
		mavenLocal()
		if (version.endsWith('-SNAPSHOT') || version.contains('-SNAPSHOT-')) { //classic or customized snapshots
			maven { url 'https://repo.spring.io/libs-snapshot' }
		}

		mavenCentral()
		jcenter()
		maven { url 'https://repo.spring.io/libs-milestone' }
		maven { url "https://oss.sonatype.org/content/repositories/releases/" }

	}

	jacoco {
		toolVersion = '0.8.5'
	}

	jacocoTestReport {
		reports {
			xml.enabled = true
			html.enabled = true
		}
	}

	//includes for base test task (see below for additional common configurations)
	test {
		include '**/*Tests.*'
		include '**/*Test.*'
		include '**/*Spec.*'
	}

	//all test tasks will show FAILED for each test method,
	// common exclusions, no scanning
	p.tasks.withType(Test).all {
		testLogging {
			events "FAILED"
			showExceptions true
			exceptionFormat "FULL"
			stackTraceFilters "ENTRY_POINT"
			maxGranularity 3
		}

		if (isCiServer) {
			def stdout = new LinkedList<TestOutputEvent>()
			beforeTest { TestDescriptor td ->
				stdout.clear()
			}
			onOutput { TestDescriptor td, TestOutputEvent toe ->
				stdout.add(toe)
			}
			afterTest { TestDescriptor td, TestResult tr ->
				if (tr.resultType == TestResult.ResultType.FAILURE && stdout.size() > 0) {
					def stdOutput = stdout.collect {
						it.getDestination().name() == "StdErr"
							? "STD_ERR: ${it.getMessage()}"
							: "STD_OUT: ${it.getMessage()}"
					}
						.join()
					println "This is the console output of the failing test below:\n$stdOutput"
				}
			}
		}

		if (JavaVersion.current().isJava9Compatible()) {
			println "Java 9+: lowering MaxGCPauseMillis to 20ms in ${project.name} ${name}"
			jvmArgs = ["-XX:MaxGCPauseMillis=20"]
		}

		systemProperty("java.awt.headless", "true")
		systemProperty("testGroups", p.properties.get("testGroups"))
		scanForTestClasses = false
		exclude '**/*Abstract*.*'
		exclude '**/*OperatorTest*.*'

		//allow re-run of failed tests only without special test tasks failing
		// because the filter is too restrictive
		filter.setFailOnNoMatchingTests(false)

		//display intermediate results for special test tasks
		afterSuite { desc, result ->
			if (!desc.parent) { // will match the outermost suite
				println('\n' + "${desc} Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)")
			}
		}
	}
}

assemble.dependsOn docsZip

gradle.allprojects() { p ->
	apply plugin: "io.reactor.gradle.custom-version"
}

configure(subprojects) { p ->
	//these apply once the above configure is done, but before project-specific build.gradle have applied
	apply plugin: "io.reactor.gradle.java-conventions"
	apply plugin: "io.reactor.gradle.optional-dependencies"
	apply from: "${rootDir}/gradle/javadoc.gradle"

	//these apply AFTER project-specific build.gradle have applied
	afterEvaluate {
		if (p.plugins.hasPlugin("kotlin")) {
			println "Applying Kotlin conventions to ${p.name}"
			compileKotlin {
				kotlinOptions.jvmTarget = "1.8"
				kotlinOptions.freeCompilerArgs = ["-Xjsr305=strict"]
			}
			compileTestKotlin {
				kotlinOptions.jvmTarget = "1.8"
				kotlinOptions.freeCompilerArgs = ["-Xjsr305=strict"]
			}
		}
	}
}