build.gradle

buildscript {
    repositories {
        mavenCentral()
        jcenter()
    }
    dependencies {
        classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.2'
        classpath 'net.saliman:gradle-cobertura-plugin:2.3.1'
    }
}

ext.java8 = gradle.ext.java8 // See settings.gradle

subprojects {
    apply plugin: 'java'

    sourceCompatibility = '1.8'
    targetCompatibility = '1.8'

    tasks.withType(JavaCompile) {
        options.encoding = 'UTF-8'
    }

    group               = "com.github.fromage.quasi"
    version             = "0.7.10"
    status              = "integration"
    description         = "Fibers for the JVM"
    ext.url             = "http://github.com/fromage/quasi"
    ext.vendor          = "Parallel Universe Software Co."
    ext.licenseName1    = "The GNU Lesser General Public License, version 3"
    ext.licenseUrl1     = "http://www.gnu.org/licenses/lgpl-3.0.txt"
    ext.licenseName2    = "Eclipse Public License - v 1.0"
    ext.licenseUrl2     = "http://www.eclipse.org/legal/epl-v10.html"
    ext.scmUrl          = "https://github.com/fromage/quasi"
    ext.scmConnection   = "https://github.com/fromage/quasi.git"
    ext.distDir         = "$buildDir/dist"
    ext.isReleaseVersion = !version.endsWith("SNAPSHOT")
    ext.baselib         = "${rootProject.projectDir}/baselib"
    ext.java8 = rootProject.ext.java8
    ext.jdkVer = "8"
    ext.quasiJar = "${rootProject.projectDir}/quasi-core/build/libs/quasi-core-${version}.jar" // project(':quasi-core').jar.archivePath

    ext.asmVer    = '6.2'

    if (!project.hasProperty("sonatypeUsername") || !project.hasProperty("sonatypePassword")) {
        println "sonatype username or password not set"
        ext.sonatypeUsername = ""
        ext.sonatypePassword = ""
    }

    if (!project.hasProperty('mainClass')) { // must use project.hasProperty() rather than hasProperty in subprojects (gradle bug)
        ext.mainClass = ''
    }

    repositories {
        flatDir {
            dirs baselib
        }
        repositories {
            mavenLocal()
            mavenCentral()
            maven { url "https://oss.sonatype.org/content/repositories/releases" }
            maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
            jcenter()
        }
    }

    configurations.all {
        resolutionStrategy {
            failOnVersionConflict()
        }
    }

    configurations {
        compileOnly
        provided
        // markdownDoclet
    }

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

        test {
            compileClasspath += configurations.compileOnly + configurations.provided
            runtimeClasspath += configurations.provided
        }

        jmh {
            compileClasspath += main.compileClasspath + main.output + test.compileClasspath + test.output
            runtimeClasspath += compileClasspath + main.runtimeClasspath + test.runtimeClasspath
        }
    }

    compileJmhJava {
        sourceCompatibility = '1.8'
        targetCompatibility = '1.8'
    }

    dependencies {
        compile("io.dropwizard.metrics:metrics-core:3.2.3") {
            exclude group: 'org.slf4j', module: '*'
        }
        provided "org.apache.ant:ant:1.9.9" // version 1.10 and upwards requires JDK 8
        compile "com.google.guava:guava:20.0" // version 21.0 and upwards requires JDK 8
        testCompile 'junit:junit:4.12'
        testCompile('com.google.truth:truth:0.34') {
            exclude group: 'com.google.guava', module: 'guava'
            exclude group: 'junit', module: 'junit'
        }
        testCompile 'org.hamcrest:hamcrest-all:1.3'
        testCompile("org.mockito:mockito-all:1.10.19") {
            exclude group: "org.ow2.asm", module: '*'
        }
        testCompile "org.ow2.asm:asm:$asmVer"

        jmhCompile 'org.openjdk.jmh:jmh-core:1.19'
        jmhCompile 'org.openjdk.jmh:jmh-generator-annprocess:1.19'

        compileOnly 'org.kohsuke.metainf-services:metainf-services:1.7'
        // compileOnly 'com.google.auto.service:auto-service:1.0-rc1' // same as metainf-services
        // markdownDoclet "ch.raffael.pegdown-doclet:pegdown-doclet:1.1.1"
    }

    //    tasks.withType(JavaCompile) {
    //        // options.compilerArgs << "-Xlint:unchecked"
    //        // options.compilerArgs << "-Xlint:deprecation"
    //    }

    compileJava.dependsOn processResources
    compileJava {
        if (project.name != 'quasi-kotlin') {
            doLast {
                scanAndInstrument(sourceSets.main, [configurations.provided, configurations.runtime])
            }
        }
    }

    test.dependsOn jar

    tasks.withType(Test) {
        useJUnit()
        // systemProperty 'com.github.fromage.quasi.fibers.verifyInstrumentation', 'true'

        // systemProperty "java.util.logging.config.file", "jul.properties"

        // Uncomment and add ${rootProject.projectDir}/log4j.xml, if not present, for logging
        // systemProperty "log4j.configurationFile", "${rootProject.projectDir}/log4j.xml"

        // systemProperty "Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"

        // systemProperty 'com.github.fromage.quasi.debugMode', 'true'
        systemProperty 'com.github.fromage.quasi.monitoring.flightRecorderLevel', '5'
        systemProperty 'com.github.fromage.quasi.globalFlightRecorder', 'true'
        systemProperty 'com.github.fromage.quasi.flightRecorderDumpFile', 'quasi.log'
        systemProperty 'com.github.fromage.quasi.monitoring.flightRecorderSize', '200000'

        if (project.name != 'quasi-core') {
            jvmArgs "-javaagent:${quasiJar}" // =vdmc (verbose, debug, allow monitors, check class)
        }

        jvmArgs "-Xmx2048m"
        if (!project.ext.java8) {
            jvmArgs "-XX:MaxPermSize=512m" // Travis is having some trouble with PermGen
        }
        // jvmArgs "-XX:-UseCompressedOops"

        beforeTest { desc ->
            logger.quiet("Running test: " + desc)
        }

        afterTest { desc, result ->
            if(result.resultType == TestResult.ResultType.FAILURE) {
                logger.quiet("Failed test ${desc.name} [${desc.className}] with exception: ${result.exception}")
                if(result.exception != null) {
                    result.exception.printStackTrace()
                }
            }
        }

        doLast() {
            println "file://" + getReports().getHtml().getDestination() + "/index.html"
        }
    }

    ['run', 'debug'].each { name ->
        project.task(name, type: JavaExec, dependsOn:[testClasses]) {
            classpath = sourceSets.main.runtimeClasspath
            if(project.hasProperty('mainClass')){
                main = project.mainClass
            }
            if(project.hasProperty('args')){
                args project.args.split('\\s+')
            }

            jvmArgs '-Xmx2048m'
            // jvmArgs "-Xbootclasspath/p:${System.getProperty("user.home")}/jsr166.jar"
            // systemProperty 'com.github.fromage.quasi.fibers.DefaultFiberPool.parallelism', '1'

            systemProperty "log4j.configurationFile", "${rootProject.projectDir}/log4j.xml"
            systemProperty "Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"
            // systemProperty 'com.github.fromage.quasi.fibers.verifyInstrumentation', 'true'
            jvmArgs "-javaagent:${quasiJar}" // =vdmc (verbose, debug, allow monitors, check class)

            // jvmArgs '-XX:+UnlockCommercialFeatures', '-XX:+FlightRecorder', '-XX:StartFlightRecording=duration=60s,filename=recording.jfr,settings=heap'
        }
    }
    debug.debug = true

    project.afterEvaluate {
        run.dependsOn project(':quasi-core').tasks["jdk8ShadowJar"]
    }

    tasks.withType(JavaExec) {
        classpath += sourceSets.test.runtimeClasspath + sourceSets.test.output + sourceSets.jmh.runtimeClasspath + sourceSets.jmh.output
    }

    //    tasks.withType(Debug) {
    //        classpath = sourceSets.test.runtimeClasspath
    //    }

    configure (javadoc) {
        classpath += configurations.provided
        options {
            // docletpath = configurations.markdownDoclet.files.asType(List)
            // doclet = 'ch.raffael.doclets.pegdown.PegdownDoclet'
            // addStringOption("parse-timeout", "10")
            options.addStringOption('Xdoclint:none', '-quiet')
            // stylesheetFile = rootProject.file('./baselib/javadoc.css')
            links = [
                "http://docs.oracle.com/javase/7/docs/api/",
                "http://google.github.io/guava/releases/19.0/api/docs/"
            ]
        }
    }
    defaultTasks 'build'

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

    task artifacts {
        group = "Help"
        description = "Displays the artifacts associated with each configuration of " + project
        doFirst {
            configurations.findAll().each { config ->
                println "${config}:"
                // config.allArtifacts.each { file -> println "--- " + file }
                config.allArtifacts.getFiles().each { file -> println "" + file }
                println ' '
            }
        }
    }

    ///////// Publish Artifacts
    apply plugin: 'maven'
    apply plugin: 'signing'

    artifacts {
        archives jar
        archives sourcesJar
        archives javadocJar
    }

    signing {
        required { isReleaseVersion && gradle.taskGraph.hasTask("uploadArchives") }
        useGpgCmd()
        sign configurations.archives
    }

    uploadArchives {
        repositories {
            mavenDeployer {
                beforeDeployment { deployment -> signing.signPom(deployment) }

                repository(
                    url: (isReleaseVersion ?
                        "https://oss.sonatype.org/service/local/staging/deploy/maven2" :
                        "https://oss.sonatype.org/content/repositories/snapshots")) {
                    // User and Password are taken from ~/.gradle/gradle.properties
                    authentication(userName: project.sonatypeUsername, password: project.sonatypePassword)
                }
                pom.project {
                    name project.name
                    packaging 'jar'
                    description project.description
                    url project.url
                    scm {
                        url project.scmUrl
                        connection project.scmConnection
                        developerConnection project.scmConnection
                    }
                    licenses {
                        license {
                            name project.licenseName1
                            url project.licenseUrl1
                            distribution 'repo'
                        }
                        license {
                            name project.licenseName2
                            url project.licenseUrl2
                            distribution 'repo'
                        }
                    }
                    developers {
                        developer {
                            id 'pron'
                            name 'Ron Pressler'
                        }
                    }
                }
            }
        }
    }
}

def scanAndInstrument(sset, configs) {
    def cp = '' + sset.output.classesDir + ':' + sset.output.resourcesDir + ':' + configs*.asPath.join(':')

    ant.taskdef(
        name:'scanSuspendables', classname:'com.github.fromage.quasi.fibers.instrument.SuspendablesScanner',
        classpath: cp)
    ant.scanSuspendables(
        auto: false,
        supersFile:"$sset.output.resourcesDir/META-INF/suspendable-supers",
        append: true) {
        fileset(dir: sset.output.classesDir)
    }

    ant.taskdef(name:'instrumentation', classname:'com.github.fromage.quasi.fibers.instrument.InstrumentationTask',
        classpath: cp)
    ant.instrumentation(verbose:'true', check:'true', debug:'true') {
        fileset(dir: sset.output.classesDir) {
            exclude(name: 'com/github/fromage/quasi/fibers/instrument/*.class')
        }
    }
}

project (':quasi-core') {
    /*
     * see:
     *   https://docs.gradle.org/current/userguide/java_plugin.html
     *   http://examples.javacodegeeks.com/core-java/gradle/gradle-sourcesets-example/
     *   http://stackoverflow.com/questions/15870662/gradle-create-a-new-jar-from-each-sourceset
     *   http://stackoverflow.com/questions/18190614/compiling-a-project-with-different-java-source-compatibility
     *   https://softnoise.wordpress.com/2014/09/07/gradle-sub-project-test-dependencies-in-multi-project-builds/
     */

    apply plugin: 'com.github.johnrengelman.shadow'

    // remove default artifact
    configurations.runtime.artifacts.with { archives ->
        archives.each {
            archives.remove(it)
        }
    }

    [compileJava, compileTestJava, classes, jar]*.enabled = false

    sourceSets {
        main {
            java {
                srcDir 'src/main/java'
                srcDir 'src/jdk8/java'
            }
        }

        jdk8 {
            java {
                srcDir 'src/main/java'
                srcDir 'src/jdk8/java'
            }

            compileClasspath += main.compileClasspath
            runtimeClasspath += compileClasspath
        }

        jdk8test {
            java {
                srcDir 'src/test/java'
                srcDir 'src/jdk8Test/java'
            }

            compileClasspath += jdk8.output + test.compileClasspath
            runtimeClasspath += compileClasspath + test.runtimeClasspath
        }

        jmh {
            java {
                srcDir 'src/jmh/java'
            }

            compileClasspath += jdk8.output + jdk8test.compileClasspath + jdk8test.output
            runtimeClasspath += compileClasspath + jdk8test.runtimeClasspath
        }

        classloadertest {
            java {
                srcDir 'src/classloadertest/java'
            }

            compileClasspath += jdk8.output + test.compileClasspath
            runtimeClasspath += compileClasspath + test.runtimeClasspath
        }
    }

    configurations {
        jdk8Archives.extendsFrom runtime
    }

    dependencies {
        compile ":high-scale-lib"
        compile "org.hdrhistogram:HdrHistogram:2.1.9"
        compile("org.latencyutils:LatencyUtils:2.0.3") {
            exclude group: "org.hdrhistogram", module: '*'
        }
        compile "org.ow2.asm:asm:$asmVer"
        compile "org.ow2.asm:asm-analysis:$asmVer"
        compile "org.ow2.asm:asm-commons:$asmVer"
        compile "org.ow2.asm:asm-util:$asmVer"

        // The exclusions are needed to get asm 5.0.4 whilst Kryo still depends on 5.0.3
        compile("com.esotericsoftware:kryo:4.0.0") {
            exclude group: "org.ow2.asm", module: '*'
        }
        compile("de.javakaffee:kryo-serializers:0.42") {
            exclude group: "com.esotericsoftware", module: '*'
            exclude group: "com.esotericsoftware.kryo", module: '*'
        }
        provided 'junit:junit:4.12'
    }

    def ssets = [sourceSets.jdk8]

    ssets.each { set ->
        configure(project.tasks["compile${capitalize(set.name)}Java"]) {
            doLast {
                rootProject.scanAndInstrument(set, [configurations["${set.name}Runtime"], configurations.provided, configurations.runtime])
            }
        }

        def shadowJarTask = task("${set.name}ShadowJar", type: com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar, dependsOn: classes) {
            classifier = '' // overwrite jar
            destinationDir = file("$buildDir/libs")

            from set.output

            configurations = [project.configurations.runtime, project.configurations["${set.name}Runtime"]]
            dependencies {
                include(dependency('org.ow2.asm:.*:.*'))
                include(dependency(':high-scale-lib'))
            }
            exclude 'META-INF/INDEX.LIST'

            relocate 'org.objectweb.asm.', 'com.github.fromage.quasi.asm.'

            manifest {
                attributes(
                    "Built-By"                  :   System.getProperty("user.name"),
                    "Implementation-Title"      :   project.name,
                    "Implementation-Version"    :   version,
                    "Implementation-Vendor"     :   vendor,
                    "Premain-Class"             :   "com.github.fromage.quasi.fibers.instrument.JavaAgent",
                    "Agent-Class"               :   "com.github.fromage.quasi.fibers.instrument.JavaAgent",
                    "Can-Retransform-Classes"   :   "true",
                    "Can-Redefine-Classes"      :   "true",
                    //  "Class-Path"                :   configurations.runtime.collect { "lib/"+it.getName() }.join(',')
                )
            }
        }

        def testTask = task("${set.name}Test", type: Test, dependsOn: [shadowJarTask, compileClassloadertestJava]) {
            testClassesDir = project.sourceSets["${set.name}test"].output.classesDir
            classpath = project.sourceSets["${set.name}test"].runtimeClasspath

            project.afterEvaluate {
                jvmArgs "-javaagent:${shadowJarTask.archivePath}" // =vdc
            }
        }

        artifacts {
            archives shadowJarTask
        }

        assemble.dependsOn shadowJarTask
        check.dependsOn testTask
    }

    compileJdk8Java {
        sourceCompatibility = '1.8'
        targetCompatibility = '1.8'
    }

    compileJdk8testJava {
        sourceCompatibility = '1.8'
        targetCompatibility = '1.8'
    }

    //        jdk8Jar {
    //            classifier = 'jdk8'
    //        }

    jdk8ShadowJar {
    }

    artifacts {
        jdk8Archives jdk8ShadowJar
    }

    tasks.withType(JavaExec) {
        classpath += sourceSets.jdk8test.runtimeClasspath + sourceSets.jdk8test.output
    }
    run.dependsOn compileJdk8Java, jdk8testClasses

    javadoc {
        options.encoding = 'UTF-8'
        source = sourceSets.jdk8.allJava
    }

    task shadowJar(dependsOn: tasks.withType(com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar), overwrite: true) {
    }

    assemble.dependsOn shadowJar
    build.dependsOn shadowJar
    install.dependsOn shadowJar
    signArchives.dependsOn shadowJar
    uploadArchives.dependsOn shadowJar

    def installer = install.repositories.mavenInstaller
    def deployer = uploadArchives.repositories.mavenDeployer

    [installer, deployer]*.pom*.whenConfigured {
        it.dependencies.removeAll { dep ->
            dep.artifactId.startsWith('jsr166e') ||
            dep.artifactId.startsWith('high-scale-lib') ||
            dep.groupId == 'org.ow2.asm'
        }
    }

    if (ext) {
        artifacts {
            archives sourcesJar
            archives javadocJar
        }
    }
}

task javadoc(type: Javadoc, dependsOn: subprojects.javadoc) {
    title = "Quasi ${project(':quasi-core').version}"
    destinationDir = file("javadoc")

    source = project(':quasi-core').sourceSets.jdk8.allJava

    classpath = files(subprojects.collect { project -> project.sourceSets.main.compileClasspath })
    options {
        // docletpath = project(':quasi-core').configurations.markdownDoclet.files.asType(List)
        // doclet = 'ch.raffael.doclets.pegdown.PegdownDoclet'
        // addStringOption("parse-timeout", "10")
        // stylesheetFile = rootProject.file('./baselib/javadoc.css')
        if(project.ext.java8) {
            options.addStringOption('Xdoclint:none', '-quiet')
        }
        links = [
        "http://docs.oracle.com/javase/7/docs/api/",
        "http://docs.guava-libraries.googlecode.com/git-history/v18.0/javadoc/"
        ]
    }
    excludes = [
        "com/github/fromage/quasi/actors/spi/**",
        "com/github/fromage/quasi/actors/ActorMonitor.java",
        "com/github/fromage/quasi/actors/GlobalRegistry.java",
        "com/github/fromage/quasi/actors/JMXActorMonitor.java",
        "com/github/fromage/quasi/actors/LifecycleListener.java",
        "com/github/fromage/quasi/actors/LifecycleListenerProxy.java",
        "com/github/fromage/quasi/actors/MutabilityTester.java",
        "com/github/fromage/quasi/actors/RemoteActorProxyFactoryService.java",
        "com/github/fromage/quasi/actors/RemoteActorRef.java",
        "com/github/fromage/quasi/actors/RemoteActorProxyFactory.java",
        "com/github/fromage/quasi/common/benchmark/**",
        "com/github/fromage/quasi/common/classloader/**",
        "com/github/fromage/quasi/common/logging/**",
        "com/github/fromage/quasi/common/monitoring/**",
        "com/github/fromage/quasi/common/reflection/**",
        "com/github/fromage/quasi/common/test/**",
        "com/github/fromage/quasi/common/util/**",
        "com/github/fromage/quasi/concurrent/forkjoin/**",
        "com/github/fromage/quasi/concurrent/util/**",
        "com/github/fromage/quasi/data/record/DynamicGeneratedRecord.java",
        "com/github/fromage/quasi/data/record/DynamicRecord.java",
        "com/github/fromage/quasi/fibers/DefaultFiberPool.java",
        "com/github/fromage/quasi/fibers/FibersMonitor.java",
        "com/github/fromage/quasi/fibers/FiberTimedScheduler.java",
        "com/github/fromage/quasi/fibers/Instrumented.java",
        "com/github/fromage/quasi/fibers/NoopFibersMonitor.java",
        "com/github/fromage/quasi/fibers/instrument/**",
        "com/github/fromage/quasi/io/serialization/**",
        "com/github/fromage/quasi/remote/**",
        "com/github/fromage/quasi/strands/channels/SelectActionImpl.java",
        "com/github/fromage/quasi/strands/channels/disruptor/**", // not ready
        "com/github/fromage/quasi/strands/queues/**",
    ]
}

task clean(dependsOn: subprojects.clean) << {
    delete 'javadoc'
}

def capitalize(s) { s[0].toUpperCase() + s[1..-1].toLowerCase() }