build.gradle

/*
 * Copyright (c) 2011-2019 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.
 */
import org.gradle.api.internal.plugins.osgi.OsgiHelper

buildscript {
  repositories {
	maven { url "https://repo.spring.io/plugins-release" }
  }
  dependencies {
	classpath 'org.springframework.build.gradle:propdeps-plugin:0.0.7',
			'io.spring.gradle:spring-io-plugin:0.0.4.RELEASE',
			'com.google.gradle:osdetector-gradle-plugin:1.4.0'
  }
}

plugins {
  id "com.github.hierynomus.license" version "0.14.0"
  id 'org.asciidoctor.convert' version '1.5.11'
  id 'com.github.johnrengelman.shadow' version '5.0.0'
}

description = 'Reactive Streams Netty driver'

ext {
  if (project.hasProperty('versionBranch') && version.toString().endsWith(".BUILD-SNAPSHOT")) {
	versionBranch = versionBranch.replaceAll("\"", "").trim()
	if (!versionBranch.isEmpty()) {
	  realVersion = version.toString().replace("BUILD-SNAPSHOT", versionBranch + ".BUILD-SNAPSHOT")
	  project.version = realVersion
	  println "Building special snapshot ${project.version}"
	  println "OSGI version would be: ${new OsgiHelper().getVersion(project.version.toString())}"
	}
  }

  gradleScriptDir = "${rootProject.projectDir}/gradle"

  reactorCoreVersion = "3.3.1.BUILD-SNAPSHOT"
  reactorPoolVersion = "0.1.0.RELEASE"
  blockHoundVersion = "1.0.0.RC1"

  //Metrics
  micrometerVersion = 'latest.release'

  // Logging
  slf4jVersion = '1.7.12'
  logbackVersion = '1.1.2'
  testAddonVersion = reactorCoreVersion
  assertJVersion = '3.6.1'

  // Libraries
  nettyVersion = '4.1.39.Final'
  jacksonDatabindVersion = '2.5.1'

  // Testing
  mockitoVersion = '1.10.19'
  hoverflyJavaVersion = '0.11.1'

  javadocLinks = ["https://docs.oracle.com/javase/7/docs/api/",
				  "https://docs.oracle.com/javaee/6/api/",
				  "https://fasterxml.github.io/jackson-databind/javadoc/2.5/",
				  "https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
				  "https://projectreactor.io/docs/core/release/api/",
				  "https://netty.io/4.1/api/",
				  "https://projectreactor.io/docs/netty/release/api/",] as String[]
}


configure(rootProject) { project ->
  group = 'io.projectreactor.netty'

  apply plugin: 'java'
  apply plugin: 'jacoco'
  apply from: "$gradleScriptDir/setup.gradle"
  apply plugin: 'propdeps'
  apply plugin: 'osgi'
  apply from: "${gradleScriptDir}/ide.gradle"
  apply from: "${gradleScriptDir}/errorprone.gradle"
  apply plugin: 'com.google.osdetector'

  jacoco {
	toolVersion = '0.7.7.201606060606'
  }

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

  ext.bundleImportPackages = [ '!javax.annotation',
							   'io.netty.channel.kqueue;resolution:=optional;version="[4.1,5)"',
							   '!reactor.pool',
							   'io.micrometer.*;resolution:=optional',
							   '*']

  [compileJava, compileTestJava]*.options*.compilerArgs = ["-Xlint:varargs",
														   "-Xlint:cast",
														   "-Xlint:classfile",
														   "-Xlint:dep-ann",
														   "-Xlint:divzero",
														   "-Xlint:empty",
														   "-Xlint:finally",
														   "-Xlint:overrides",
														   "-Xlint:path",
														   "-Xlint:processing",
														   "-Xlint:static",
														   "-Xlint:try",
														   "-Xlint:deprecation",
														   "-Xlint:unchecked",
														   "-Xlint:-serial",      // intentionally disabled
														   "-Xlint:-options",     // intentionally disabled
														   "-Xlint:-fallthrough", // intentionally disabled
														   "-Xlint:rawtypes"
  ]

  compileJava {
	sourceCompatibility = 1.8
	targetCompatibility = 1.8
  }

  compileTestJava {
	sourceCompatibility = 1.8
	targetCompatibility = 1.8
  }

  if (JavaVersion.current().isJava8Compatible()) {
	compileTestJava.options.compilerArgs += "-parameters"
	tasks.withType(Javadoc) {
	  options.addStringOption('Xdoclint:none', '-quiet')
	  options.addStringOption('encoding', 'UTF-8')
	}
  }

  [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
  sourceSets.test.resources.srcDirs = ["src/test/resources", "src/test/java"]

  configurations.all {
	exclude group: 'commons-logging', module: 'commons-logging'
  }

  project.tasks.withType(Test).all {
	// run tests with IPv4 only when IPv6 is available
	if (project.hasProperty('preferIPv4Stack')) {
		systemProperty("java.net.preferIPv4Stack", "true")
	}
	// run tests with preferring IPv6 addresses
	if (project.hasProperty('preferIPv6Addresses')) {
		systemProperty("java.net.preferIPv6Addresses", "true")
	}
	systemProperty("java.awt.headless", "true")
	systemProperty("reactor.trace.cancel", "true")
	systemProperty("reactor.trace.nocapacity", "true")
	systemProperty("testGroups", project.properties.get("testGroups"))
	systemProperty("io.netty.leakDetection.level", "paranoid")
	scanForTestClasses = false
	include '**/*Tests.*'
	include '**/*Test.*'
	include '**/*Spec.*'
	exclude '**/*Abstract*.*'
  }

  test {
	testLogging {
	  events  "passed", "failed"
	  showExceptions true
	  exceptionFormat "full"
	  maxGranularity 3
	}

	onOutput { descriptor, event ->
	  if (event.message.contains("ResourceLeakDetector")) {
		logger.error("ERROR: Test: " + descriptor + " produced resource leak: " + event.message )
	  }
	}
  }

	sourceSets {
		jarFileTest
	}

	idea.module.testSourceDirs += sourceSets.jarFileTest.allSource.srcDirs

	repositories {
	mavenCentral()
	if (version.endsWith('BUILD-SNAPSHOT') || project.hasProperty('platformVersion')) {
	  if (System.getenv ()["bamboo_buildNumber"] == null) {
		mavenLocal()
	  } else {
		println 'Bamboo CI detected, avoiding use of mavenLocal()'
	  }
	  maven { url 'https://repo.spring.io/libs-snapshot' }
	}
	maven { url 'https://repo.spring.io/libs-milestone' }
	maven { url 'https://repo.spring.io/libs-release' }
	maven { url "https://oss.sonatype.org/content/repositories/releases/" }
	jcenter()
  }

	def os_suffix = ""
	if (osdetector.classifier in ["linux-x86_64"] || ["osx-x86_64"] || ["windows-x86_64"]) {
		os_suffix = ":" + osdetector.classifier
	}

	configurations {
		shaded
	}

	// dependencies that are common across all java projects
  dependencies {
	// JSR-305 annotations
	compileOnly "com.google.code.findbugs:jsr305:3.0.2"

	compile "io.netty:netty-handler-proxy:${nettyVersion}"
	compile "io.netty:netty-codec-http2:${nettyVersion}"
	optional "io.netty:netty-codec-haproxy:${nettyVersion}"

	//Metrics
	optional "io.micrometer:micrometer-core:${micrometerVersion}"

	// Logging
	optional "org.slf4j:slf4j-api:$slf4jVersion"

	compile "io.projectreactor:reactor-core:$reactorCoreVersion"
	shaded("io.projectreactor.addons:reactor-pool:$reactorPoolVersion") {
		exclude module: "reactor-core"
	}
	optional "io.projectreactor.tools:blockhound:$blockHoundVersion"

	compile "io.netty:netty-handler:${nettyVersion}"
	compile "io.netty:netty-codec-http:${nettyVersion}"
	compile "io.netty:netty-transport-native-epoll:${nettyVersion}:linux-x86_64"
	optional "io.netty:netty-transport-native-kqueue:${nettyVersion}"

	// Testing
	testCompile "com.fasterxml.jackson.core:jackson-databind:$jacksonDatabindVersion"
	testCompile "io.projectreactor:reactor-test:$testAddonVersion"
	testCompile "org.hamcrest:hamcrest-library:1.3"
	testCompile "org.assertj:assertj-core:$assertJVersion"
	testCompile "io.specto:hoverfly-java:${hoverflyJavaVersion}"
	testCompile "org.apache.tomcat.embed:tomcat-embed-core:9.0.20"

	testRuntime "org.slf4j:jcl-over-slf4j:$slf4jVersion"

	testRuntime "ch.qos.logback:logback-classic:$logbackVersion"

	// Needed for HTTP/2 testing
	testRuntime "io.netty:netty-tcnative-boringssl-static:2.0.25.Final" + os_suffix

	jarFileTestCompile 'org.assertj:assertj-core:3.12.2'
	jarFileTestCompile 'junit:junit:4.12'

	for (dependency in project.configurations.shaded.dependencies) {
	    compileOnly(dependency)
	}
  }


  if (project.hasProperty('platformVersion')) {
	apply plugin: 'spring-io'

	repositories {
	  maven { url 'https://repo.spring.io/libs-snapshot' }
	}

	dependencyManagement {
	  springIoTestRuntime {
		imports {
		  mavenBom "io.spring.platform:platform-bom:$platformVersion"
		}
	  }
	}
  }


  jar {
	classifier = 'original'

	manifest {
	  instruction 'Import-Package', bundleImportPackages.join(',')
	  attributes("Created-By": "${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})",
			  "Implementation-Title": project.name,
			  "Implementation-Version": project.version,
			  "Automatic-Module-Name": "reactor.netty")
	}
  }

  check.dependsOn jacocoTestReport

  shadowJar {
	  classifier = null

	  dependsOn(project.tasks.jar)

	  manifest {
		  inheritFrom project.tasks.jar.manifest
	  }

	  configurations = [project.configurations.shaded]

	  project.afterEvaluate {
		  dependencies {
			  def shadedDependencies = project.configurations
					  .shaded
					  .dependencies
					  .collect { "${it.group}:${it.name}".toString() }
					  .toSet()

			  // Exclude every compile-scoped dependency (including the transitive ones)
			  for (id in project.configurations.compile.resolvedConfiguration.resolvedArtifacts*.moduleVersion*.id) {
				  def module = "${id.group}:${id.name}".toString()
				  if (!shadedDependencies.contains(module)) {
					  project.configurations.shaded.exclude(group: id.group, module: id.name)
					  exclude(dependency(module))
				  }
			  }
		  }
	  }

	  exclude 'META-INF/maven*/**'
  }

  task relocateShadowJar(type: com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation) {
	  target = tasks.shadowJar
	  prefix = "reactor.netty.internal.shaded"
  }

  tasks.shadowJar.dependsOn tasks.relocateShadowJar

  artifacts.archives shadowJar

  task jarFileTest(type: Test) {
	  testClassesDirs = sourceSets.jarFileTest.output.classesDirs
	  classpath = sourceSets.jarFileTest.runtimeClasspath

	  systemProperty("jarFile", shadowJar.outputs.files.singleFile)

	  dependsOn(shadowJar)
  }
  project.tasks.check.dependsOn(jarFileTest)

  project.tasks.compileTestJava.classpath += configurations.shaded
  project.tasks.test.classpath += configurations.shaded

  task shadedJarTest(type: Test) {
	  testClassesDirs = sourceSets.test.output.classesDirs

	  Set<? super File> mainOutputs = [
			  project.sourceSets.main.output.resourcesDir,
			  project.sourceSets.main.java.outputDir,
	  ]

	  classpath = shadowJar.outputs.files
	  // Exclude main outputs since we have the shaded JAR on the classpath already
	  classpath += sourceSets.test.runtimeClasspath.filter { !(it in mainOutputs) }

	  //The imports are not relocated, we do relocation only for the main sources not the tests
	  exclude '**/*PooledConnectionProviderTest*.*'

	  dependsOn(shadowJar)
  }
  project.tasks.check.dependsOn(shadedJarTest)
}

configurations.all {
  // check for updates every build
  resolutionStrategy.cacheChangingModulesFor 0, 'seconds'

  license {
    header rootProject.file('codequality/HEADER')
    includes(["**/*.java", "**/*.css"])
    strictCheck true
    mapping {
        java = 'SLASHSTAR_STYLE'
        css = 'SLASHSTAR_STYLE'
    }
  }
}