build.gradle

/*
 * Copyright 2014-2021 Real Logic Limited.
 *
 * 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.
 */

plugins {
    id 'java-library'
    id 'com.github.johnrengelman.shadow' version '7.0.0' apply false
    id 'biz.aQute.bnd.builder' version '5.3.0' apply false
    id "com.github.ben-manes.versions" version "0.39.0"
}

defaultTasks 'clean', 'build', ':agrona-concurrency-tests:concurrencyTests'

static def getBuildJavaVersion() {
    def buildJavaVersion = System.getenv('BUILD_JAVA_VERSION') ?: JavaVersion.current().getMajorVersion()
    if (buildJavaVersion.indexOf('.') > 0) {
        buildJavaVersion = buildJavaVersion.substring(0, buildJavaVersion.indexOf('.'))
    }
    if (buildJavaVersion.indexOf('-') > 0) {
        buildJavaVersion = buildJavaVersion.substring(0, buildJavaVersion.indexOf('-'))
    }
    Integer.parseInt(buildJavaVersion)
}
int buildJavaVersion = getBuildJavaVersion()

def toolchainLauncher = javaToolchains.launcherFor {
    languageVersion = JavaLanguageVersion.of(buildJavaVersion)
}

def toolchainCompiler = javaToolchains.compilerFor {
    languageVersion = JavaLanguageVersion.of(buildJavaVersion)
}

def toolchainJavadocTool = javaToolchains.javadocToolFor {
    languageVersion = JavaLanguageVersion.of(buildJavaVersion)
}

def byteBuddyVersion = '1.11.18'
def findbugsAnnotations = '3.0.1'
def checkstyleVersion = '9.0'
def hamcrestVersion = '2.2'
def mockitoVersion = '3.12.4'
def junitVersion = '5.8.1'
def guavaTestLib = '30.1.1-jre'
def junit4Version = '4.13.2'
def jmhVersion = '1.33'
def jcstressVersion = '0.14'

def agronaGroup = 'org.agrona'
def agronaVersion = '1.12.1-SNAPSHOT'

def getConfigProperty(final String projectPropertyName, final String envVarName) {
    String value = project.findProperty(projectPropertyName)
    if (!value) {
        value = System.getenv(envVarName)
        if (!value) {
            return null
        }
    }

    value = value.trim()

    return value ? value : null
}

ext {
    isReleaseVersion = !agronaVersion.endsWith('-SNAPSHOT')

    ossrhReleasesRepoUrl = 'https://oss.sonatype.org/service/local/staging/deploy/maven2/'
    ossrhSnapshotsRepoUrl = 'https://oss.sonatype.org/content/repositories/snapshots/'
    ossrhUsername = getConfigProperty('ossrhUsername', 'OSSRH_USERNAME')
    ossrhPassword = getConfigProperty('ossrhPassword', 'OSSRH_PASSWORD')

    signingKey = getConfigProperty('signingKey', 'SIGNING_GPG_SECRET_KEY')         // NOTE: ASCII armored secret key
    signingPassword = getConfigProperty('signingPassword', 'SIGNING_GPG_PASSWORD') // NOTE: Plain text
}

def projectPom = {
    name = 'agrona'
    // optionally artifactId can be defined here
    description = 'High performance primitives and utility library.'
    url = 'https://github.com/real-logic/agrona'

    scm {
        connection = 'scm:git:https://github.com/real-logic/agrona.git'
        developerConnection = 'scm:git:https://github.com/real-logic/agrona.git'
        url = 'https://github.com/real-logic/agrona.git'
    }

    licenses {
        license {
            name = 'The Apache License, Version 2.0'
            url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
        }
    }

    developers {
        developer {
            id = 'tmontgomery'
            name = 'Todd L. Montgomery'
            email = 'tmont@nard.net'
            url = 'https://github.com/tmontgomery'
        }
        developer {
            id = 'mjpt777'
            name = 'Martin Thompson'
            email = 'mjpt777@gmail.com'
            url = 'https://github.com/mjpt777'
        }
        developer {
            id = 'RichardWarburton'
            name = 'Richard Warburton'
            email = 'richard.warburton@gmail.com'
            url = 'https://github.com/RichardWarburton'
        }
        developer {
            id = 'nitsanw'
            name = 'Nitsan Wakart'
            email = 'nitsanw@yahoo.com'
            url = 'https://github.com/nitsanw'
        }
        developer {
            id = 'mikeb01'
            name = 'Mike Barker'
            email = 'mikeb01@gmail.com'
            url = 'https://github.com/mikeb01'
        }
        developer {
            id = 'vyazelenko'
            name = 'Dmitry Vyazelenko'
            email = 'vyazelenko@yahoo.com'
            url = 'https://github.com/vyazelenko'
        }
    }
}

allprojects {
    repositories {
        mavenCentral()
    }

    configurations.all {
        resolutionStrategy {
            failOnVersionConflict()

            force "junit:junit:${junit4Version}"
        }
    }

    tasks.withType(JavaExec).configureEach {
        javaLauncher.set(toolchainLauncher)
    }
}

jar.enabled = false

subprojects {
    apply plugin: 'java-library'
    apply plugin: 'checkstyle'

    group = agronaGroup
    version = agronaVersion

    checkstyle.toolVersion = "${checkstyleVersion}"

    tasks.withType(Sign) {
        onlyIf {
            isReleaseVersion && gradle.taskGraph.hasTask(tasks.publish)
        }
    }

    tasks.withType(Jar) {
        enabled = true
        includeEmptyDirs = false
    }

    tasks.withType(JavaCompile) {
        doFirst {
            mkdir 'build/resources/main' // Avoid Javac warning about non-existing directory
        }

        if (buildJavaVersion >= 9) {
            javaCompiler.set(toolchainCompiler)
        }
        else {
            options.fork = true
            def javaHome = toolchainCompiler.get().metadata.installationPath.asFile.toPath().toAbsolutePath()
            options.forkOptions.javaHome = javaHome.toFile()
        }

        options.compilerArgs.addAll(['-Xlint:all', '-Werror']) // Enable all warnings and treat them as errors
        options.compilerArgs.add('-XDignore.symbol.file') // Suppress warnings about using Unsafe
        options.encoding = 'UTF-8'
        options.deprecation = true
    }

    test {
        if (buildJavaVersion >= 9) {
            jvmArgs('--add-opens', 'java.base/sun.nio.ch=ALL-UNNAMED')
        }

        useJUnitPlatform()

        testLogging {
            for (def level : LogLevel.values())
            {
                def testLogging = get(level)
                testLogging.exceptionFormat = 'full'
                testLogging.events = ["FAILED", "STANDARD_OUT", "STANDARD_ERROR"]
            }
        }

        javaLauncher.set(toolchainLauncher)
    }

    javadoc {
        title = '<h1>Agrona</h1>'
        options.bottom = '<i>Copyright &#169; 2014-2021 Real Logic Limited. All Rights Reserved.</i>'
        options.encoding = 'UTF-8'
        options.docEncoding = 'UTF-8'
        options.charSet = 'UTF-8'
        if (buildJavaVersion >= 18) { // early access JavaDoc location is different
            options.links("https://download.java.net/java/early_access/jdk${buildJavaVersion}/docs/api/")
        }
        else if (buildJavaVersion >= 11) {
            options.links("https://docs.oracle.com/en/java/javase/${buildJavaVersion}/docs/api/")
        }
        else {
            options.links("https://docs.oracle.com/javase/${buildJavaVersion}/docs/api/")
        }

        if (buildJavaVersion >= 10) {
            options.addBooleanOption 'html5', true
        }

        javadocTool.set(toolchainJavadocTool)
    }
}

project(':agrona') {
    apply plugin: 'maven-publish'
    apply plugin: 'signing'
    apply plugin: 'biz.aQute.bnd.builder'

    dependencies {
        testImplementation files('build/classes/java/generated')
        testImplementation "org.hamcrest:hamcrest:${hamcrestVersion}"
        testImplementation "org.junit.jupiter:junit-jupiter-params:${junitVersion}"
        testImplementation "org.mockito:mockito-core:${mockitoVersion}"
        testImplementation "com.google.guava:guava-testlib:${guavaTestLib}"
        testImplementation "junit:junit:${junit4Version}" // Compatibility with JUnit 4
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junitVersion}"
        testRuntimeOnly "org.junit.vintage:junit-vintage-engine:${junitVersion}"
    }

    def generatedDir = file("${buildDir}/generated-src")
    sourceSets {
        generated {
            java.srcDir generatedDir
            compileClasspath += sourceSets.main.runtimeClasspath
        }
    }

    task generatePrimitiveSpecialisations(type: JavaExec) {
        mainClass.set('org.agrona.generation.SpecialisationGenerator')
        classpath = sourceSets.main.runtimeClasspath
        outputs.dir generatedDir
    }

    compileGeneratedJava.dependsOn generatePrimitiveSpecialisations
    compileTestJava.dependsOn compileGeneratedJava
    javadoc.dependsOn generatePrimitiveSpecialisations

    jar {
        from sourceSets.generated.output

        bnd """
            Automatic-Module-Name:  org.agrona.core
            Bundle-Name:            org.agrona.core
            Bundle-SymbolicName:    org.agrona.core
            Implementation-Title:   Agrona
            Implementation-Vendor:  Real Logic Limited
            Implementation-Version: ${agronaVersion}

            -exportcontents: org.agrona, org.agrona.*

            # Suppress headers that reduce reproducibility.
            -reproducible: true
            -noextraheaders: true
        """
    }

    task sourcesJar(type: Jar, dependsOn: generatePrimitiveSpecialisations) {
        archiveClassifier.set('sources')
        from sourceSets.main.allSource
        from sourceSets.generated.allSource
    }

    javadoc {
        source += sourceSets.generated.allJava
    }

    java {
        withSourcesJar()
        withJavadocJar()
    }

    publishing {
        publications {
            agrona(MavenPublication) {
                from components.java
                pom(projectPom)
            }
        }

        repositories {
            maven {
                name = 'MavenCentral'
                url(!isReleaseVersion ? ossrhSnapshotsRepoUrl : ossrhReleasesRepoUrl)
                credentials {
                    username = ossrhUsername
                    password = ossrhPassword
                }
            }
        }
    }

    signing {
        if (null != signingKey) {
            useInMemoryPgpKeys(signingKey, signingPassword)
        }
        sign publishing.publications.agrona
    }
}

project(':agrona-agent') {
    apply plugin: 'maven-publish'
    apply plugin: 'signing'
    apply plugin: 'com.github.johnrengelman.shadow'

    dependencies {
        implementation project(':agrona')
        implementation "net.bytebuddy:byte-buddy:${byteBuddyVersion}"
        // Avoid Javac warning about missing dependency from ByteBuddy
        compileOnly "com.google.code.findbugs:findbugs-annotations:${findbugsAnnotations}"
        testCompileOnly "com.google.code.findbugs:findbugs-annotations:${findbugsAnnotations}"
        testImplementation "org.junit.jupiter:junit-jupiter-api:${junitVersion}"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junitVersion}"
        testImplementation "net.bytebuddy:byte-buddy-agent:${byteBuddyVersion}"
    }

    shadowJar {
        archiveClassifier.set('')

        manifest.attributes(
            'Implementation-Title': 'Agrona',
            'Implementation-Version': agronaVersion,
            'Implementation-Vendor': 'Real Logic Limited',
            'Premain-Class': 'org.agrona.agent.BufferAlignmentAgent',
            'Agent-Class': 'org.agrona.agent.BufferAlignmentAgent',
            'Can-Redefine-Classes': 'true',
            'Can-Retransform-Classes': 'true',
            'Automatic-Module-Name': 'org.agrona.agent'
        )

        relocate 'net.bytebuddy', 'org.agrona.shadow.net.bytebuddy'
    }

    jar.finalizedBy shadowJar

    task sourcesJar(type: Jar, dependsOn: ':agrona:generatePrimitiveSpecialisations') {
        archiveClassifier.set('sources')
        from sourceSets.main.allSource
        from project(':agrona').sourceSets.main.allSource
        from project(':agrona').sourceSets.generated.allSource
    }

    javadoc {
        source += sourceSets.main.allJava
        source += project(':agrona').sourceSets.main.allJava
        source += project(':agrona').sourceSets.generated.allJava
    }
    javadoc.dependsOn ':agrona:generatePrimitiveSpecialisations'

    task javadocJar(type: Jar, dependsOn: javadoc) {
        archiveClassifier.set('javadoc')
        from javadoc.destinationDir
    }

    publishing {
        publications {
            agronaAgent(MavenPublication) {
                artifact shadowJar
                artifact sourcesJar
                artifact javadocJar
                pom(projectPom)
            }
        }
        repositories {
            maven {
                name = 'MavenCentral'
                url(!isReleaseVersion ? ossrhSnapshotsRepoUrl : ossrhReleasesRepoUrl)
                credentials {
                    username = ossrhUsername
                    password = ossrhPassword
                }
            }
        }
    }

    signing {
        if (null != signingKey)
        {
            useInMemoryPgpKeys(signingKey, signingPassword)
        }
        sign publishing.publications.agronaAgent
    }
}

project(':agrona-benchmarks') {
    apply plugin: 'com.github.johnrengelman.shadow'

    dependencies {
        implementation "org.openjdk.jmh:jmh-core:${jmhVersion}"
        annotationProcessor "org.openjdk.jmh:jmh-generator-annprocess:${jmhVersion}"
        implementation project(':agrona')
    }

    shadowJar {
        archiveFileName = 'benchmarks.jar'
        archiveClassifier.set('benchmarks')
        manifest.attributes('Main-Class': 'org.openjdk.jmh.Main')
    }

    jar.finalizedBy shadowJar
}

project(':agrona-concurrency-tests') {
    apply plugin: 'com.github.johnrengelman.shadow'

    dependencies {
        annotationProcessor "org.openjdk.jcstress:jcstress-core:${jcstressVersion}"
        implementation "org.openjdk.jcstress:jcstress-core:${jcstressVersion}"
        implementation project(':agrona')
    }

    compileJava {
        if (11 == buildJavaVersion) {
            options.compilerArgs.add('-Xlint:-processing')
        }
    }

    shadowJar {
        archiveFileName = 'concurrency-tests.jar'
        archiveClassifier.set('concurrency-tests')
        manifest.attributes('Main-Class': 'org.openjdk.jcstress.Main')
    }

    jar.finalizedBy shadowJar

    task concurrencyTests(type: JavaExec, group: 'verification') {
        classpath = files(tasks.shadowJar)
        workingDir = project.buildDir
        args = ['-jvmArgs', '-Dagrona.disable.bounds.checks=true -XX:+UseParallelGC']
    }
}

task testReport(type: TestReport) {
    destinationDir = file("$buildDir/reports/allTests")
    // Include the results from the `test` task in all subprojects
    reportOn subprojects*.test
}

def isNonStable = { String version ->
    def stableKeyword = ['RELEASE', 'FINAL', 'GA'].any { it -> version.toUpperCase().contains(it) }
    def regex = /^[0-9,.v-]+(-r|-jre)?$/
    return !stableKeyword && !(version ==~ regex)
}

tasks.named("dependencyUpdates").configure {
    // Reject all non stable versions
    rejectVersionIf {
        isNonStable(it.candidate.version)
    }
}

task copyTestLogs(type: Copy) {
    from '.'
    include '**/*.log'
    include '**/jcstress-results-*.gz'
    include 'LICENSE'
    exclude 'build'
    into 'build/test_logs'

    includeEmptyDirs = false
}

wrapper {
    gradleVersion = '7.1.1'
    distributionType = 'ALL'
}