import java.text.SimpleDateFormat

import org.gradle.api.attributes.java.TargetJvmVersion

plugins {

id "com.diffplug.spotless" version "8.10.4"

id 'com.google.osdetector' version '1.7.3'

id 'org.gradle.test-retry' version '1.6.6'

id 'io.spring.nohttp' version '0.0.11'

id 'com.gradleup.shadow' version '9.6.1' apply false

id 'com.jfrog.artifactory' version '6.0.4' apply false

id 'me.champeau.gradle.japicmp' version '0.4.6' apply false

id 'de.undercouch.download' version '5.7.0' apply false

id 'biz.aQute.bnd.builder' version '7.4.0' apply false

id 'org.graalvm.buildtools.native' version '0.11.5' apply false

id 'io.spring.antora.generate-antora-yml' version '0.0.1' apply false

id 'net.ltgt.errorprone' version '5.1.1' apply false

id 'me.champeau.mrjar' version '0.1.1' apply false

}

description = 'Reactive Streams Netty driver'

repositories { //needed at root for nohttp-checkstyle

mavenCentral()

}

static def parseVersionParts(String v) {

def m = v =~ /^(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?(?:[.\-](.+))?$/

if (m.matches()) {

return [major: m[0][1] as int, minor: m[0][2] as int, micro: m[0][3] as int, patch: m[0][4] ? m[0][4] as int : null, qualifier: m[0][5] ?: ""]

}

return [major: 0, minor: 0, micro: 0, patch: null, qualifier: null]

}

def osgiVersion(String v) {

def versionNumber = parseVersionParts(v)

def patchPart = versionNumber.patch != null ? ".${versionNumber.patch}-" : "."

def result

if (versionNumber.qualifier == null || versionNumber.qualifier.size() == 0) {

result = "${versionNumber.major}.${versionNumber.minor}.${versionNumber.micro}${patchPart}RELEASE"

println "$v is a release, will use $result for bnd"

}

else if (versionNumber.qualifier.equalsIgnoreCase("SNAPSHOT")) {

def sdf = new SimpleDateFormat("yyyyMMddHHmm");

sdf.setTimeZone(TimeZone.getTimeZone("UTC"));

def buildTimestamp = sdf.format(new Date())

result = "${versionNumber.major}.${versionNumber.minor}.${versionNumber.micro}${patchPart}BUILD-$buildTimestamp"

println "$v is a snapshot, will use $result for bnd"

}

else {

result = "${versionNumber.major}.${versionNumber.minor}.${versionNumber.micro}${patchPart}${versionNumber.qualifier}"

println "$v is neither release nor snapshot, will use $result for bnd"

}

return result

}

ext {

if (project.hasProperty('versionBranch') && version.toString().endsWith("-SNAPSHOT")) {

versionBranch = versionBranch.replaceAll("\"", "").trim()

if (!versionBranch.isEmpty()) {

realVersion = version.toString() + "-" + versionBranch

project.version = realVersion

println "Building special snapshot ${project.version}"

}

}

osgiVersion = osgiVersion(version.toString())

os_suffix = ""

if (osdetector.classifier in ["linux-x86_64"] || ["osx-x86_64"] || ["osx-aarch_64"] || ["windows-x86_64"]) {

os_suffix = ":" + osdetector.classifier

}

//Metrics

micrometerVersion = '1.18.0-M2' //optional baseline

micrometerTracingVersion = '1.8.0-M2' //optional baseline

micrometerDocsVersion = '1.0.4' //optional baseline

contextPropagationDefaultVersion = '1.2.0' //optional baseline

if (!project.hasProperty("forceContextPropagationVersion")) {

contextPropagationVersion = contextPropagationDefaultVersion

}

else {

contextPropagationVersion = forceContextPropagationVersion

println "Context Propagation version defined from command line: ${forceContextPropagationVersion}"

}

braveVersion = '6.3.1'

zipkinSenderVersion = '3.5.3'

jspecifyVersion = '1.0.1'

// Logging

slf4jVersion = '1.7.36'

logbackVersion = '1.2.13'

// Netty

nettyDefaultVersion = '4.2.19.Final'

if (!project.hasProperty("forceNettyVersion")) {

nettyVersion = nettyDefaultVersion

}

else {

nettyVersion = forceNettyVersion

println "Netty version defined from command line: ${forceNettyVersion}"

}

nettyIoUringVersion = '0.0.26.Final'

// Testing

brotli4jVersion = '1.23.0'

zstdJniVersion = '1.5.7-22'

jacksonDatabindVersion = '2.22.3'

testAddonVersion = reactorCoreVersion

assertJVersion = '3.27.7'

awaitilityVersion = '4.3.0'

hoverflyJavaVersion = '0.19.1'

tomcatVersion = '9.0.122'

boringSslVersion = '2.0.84.Final'

junitVersion = '5.14.4'

junitPlatformLauncherVersion = '1.14.4'

mockitoVersion = '4.11.0'

blockHoundVersion = '1.0.17.RELEASE'

reflectionsVersion = '0.10.2'

errorproneCoreVersion = '2.10.0'

errorproneGuavaVersion = '30.0-jre'

bouncycastleVersion = '1.86'

// Antora

antoraPluginVersion = '1.0.0'

jdk = JavaVersion.current().majorVersion

jdkJavadoc = "https://docs.oracle.com/en/java/javase/$jdk/docs/api/"

println "JDK Javadoc link for this build is ${rootProject.jdkJavadoc}"

javadocLinks = [jdkJavadoc,

"https://www.reactive-streams.org/reactive-streams-1.0.4-javadoc/",

"https://projectreactor.io/docs/core/release/api/",

"https://netty.io/4.2/api/",

"https://projectreactor.io/docs/netty/release/api/"] as String[]

}

nohttp {

source.exclude "docs/modules/ROOT/assets/highlight/**"

source.exclude "**/build/**"

source.exclude "docs/.gradle/**"

source.exclude "docs/node_modules/**"

}

spotless {

if (project.hasProperty("spotlessFrom")) {

if (project.spotlessFrom == "ALL") {

println "[Spotless] Ratchet deactivated"

}

else {

println "[Spotless] Ratchet from $project.spotlessFrom"

ratchetFrom project.spotlessFrom

}

}

else if (System.getenv ()["GITHUB_ACTION"] != null) {

println "[Spotless] GitHub Action detected without explicit branch, not enforcing check"

enforceCheck = false

}

else {

String spotlessBranch = "origin/main"

println "[Spotless] Local run detected, ratchet from $spotlessBranch"

ratchetFrom spotlessBranch

}

java {

target '**/*.java'

licenseHeaderFile('codequality/spotless/licenseSlashstarStyle.txt')

}

format 'gradle', {

target '**/*.gradle'

// find start of gradle files by looking for either `import`, `apply`

// or start of blocks like `javadoc {` or `configure(rootProject) {`...

licenseHeaderFile('codequality/spotless/licenseSlashstarStyle.txt',

"^\\w+(\\(\\w+\\))?\\s?\\{?|import|apply|/\\*\\*")

}

}

subprojects {

group = 'io.projectreactor.netty'

apply plugin: 'java-library'

apply plugin: 'jacoco'

apply plugin: 'checkstyle'

apply plugin: 'org.gradle.test-retry'

apply from: "${rootDir}/gradle/toolchains.gradle"

java {

toolchain {

languageVersion = JavaLanguageVersion.of((name == "docs" || name == "reactor-netty-graalvm-smoke-tests") ? 17 : 8)

}

}

// Force TargetJvmVersion=8 on consumable configurations because the Artifactory

// plugin resets it to the toolchain JDK when it adds maven-publish to subprojects.

plugins.withType(JavaPlugin) {

configurations.matching { it.name == 'apiElements' || it.name == 'runtimeElements' }.configureEach { conf ->

conf.attributes {

attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 8)

}

}

}

apply from: "${rootDir}/gradle/setup.gradle"

apply from: "${rootDir}/gradle/javadoc.gradle"

apply from: "${rootDir}/gradle/errorprone.gradle"

apply from: "${rootDir}/gradle/japicmp.gradle"

jacoco {

toolVersion = '0.8.14'

}

jacocoTestReport {

reports {

xml.required = true

html.required = true

}

}

checkstyle {

configFile = file("${rootDir}/codequality/checkstyle.xml")

toolVersion = '9.3'

}

[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",

"-Xlint:rawtypes"

]

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.matching { it.isCanBeResolved() }.configureEach {

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")

systemProperty("reactor.netty.pool.getPermitsSamplingRate", "0.5")

systemProperty("reactor.netty.pool.returnPermitsSamplingRate", "0.5")

if (project.hasProperty("forceTransport")) {

systemProperty("forceTransport", forceTransport)

}

if (project.hasProperty("parallelTests")) {

maxParallelForks = Math.max(Runtime.runtime.availableProcessors(), 2)

}

scanForTestClasses = false

include '**/*Tests.*'

include '**/*Test.*'

include '**/*Spec.*'

exclude '**/*Abstract*.*'

useJUnitPlatform()

retry {

maxFailures = 10

maxRetries = 1

}

testLogging {

showExceptions = true

exceptionFormat = "full"

}

addTestOutputListener { descriptor, event ->

def evMsg = event.message

if (evMsg.contains("ResourceLeakDetector")) {

if (!evMsg.contains(" -Dio.netty.leakDetection")

&& !evMsg.contains("DEBUG io.netty.util.ResourceLeakDetectorFactory")) {

logger.error("ERROR: Test: " + descriptor + " produced resource leak: " + event.message)

}

}

}

}

repositories {

mavenCentral()

if (version.endsWith('-SNAPSHOT') || version.contains('-SNAPSHOT-')) { //classic or customized snapshots

if (System.getenv()["GITHUB_ACTION"] == null) {

mavenLocal()

}

else {

println 'GitHub Action detected, avoiding use of mavenLocal()'

}

maven { url = 'https://repo.spring.io/snapshot' }

maven { url = 'https://central.sonatype.com/repository/maven-snapshots' }

}

}

tasks.withType(GenerateModuleMetadata) {

enabled = false

}

tasks.withType(AbstractArchiveTask).configureEach {

preserveFileTimestamps = false

reproducibleFileOrder = true

}

jar {

manifest {

attributes("Build-Jdk-Spec": "${System.getProperty("java.specification.version")}",

"Implementation-Title": project.name,

"Implementation-Version": project.version)

}

from("${rootDir}/docs/src/docs/dist") {

include "LICENSE"

into "META-INF"

}

}

check.dependsOn jacocoTestReport

}

apply from: "gradle/releaser.gradle"

configurations.all {

// check for updates every build

resolutionStrategy.cacheChangingModulesFor 0, 'seconds'

}