build.gradle

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

ext.java8 = System.properties['java.version'].startsWith('1.8')

subprojects {
    apply plugin: 'java'

    sourceCompatibility = '1.7'
    targetCompatibility = '1.7'

    [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'

    group               = "co.paralleluniverse"
    version             = "0.7.1-SNAPSHOT"
    status              = "integration"
    description         = "lightweight threads and actors for the JVM."
    ext.url             = "http://puniverse.github.com/quasar"
    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/puniverse/quasar"
    ext.scmConnection   = "https://github.com/puniverse/quasar.git"
    ext.distDir         = "$buildDir/dist"
    ext.isReleaseVersion = !version.endsWith("SNAPSHOT")
    ext.baselib         = "${rootProject.projectDir}/baselib"
    ext.quasarJar = "${rootProject.projectDir}/quasar-core/build/libs/quasar-core-${version}.jar" // project(':quasar-core').jar.archivePath
    
    ext.asmVer    = '5.0.4'
    ext.kotlinVer = '0.12.200'
    
    ext.java8 = rootProject.ext.java8

    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" }
            maven { url "http://download.oracle.com/maven/" }
        }
    }

    configurations.all {
        resolutionStrategy {
            failOnVersionConflict()
        }
    }

    sourceSets {
        jmh
    }
    
    configurations {
        compileOnly
        provided
        // markdownDoclet
    }

    dependencies {
        compile("io.dropwizard.metrics:metrics-core:3.1.2") {
            exclude group: 'org.slf4j', module: '*'
        }
        provided "org.apache.ant:ant:1.9.4"
        compile "com.google.guava:guava:18.0"
        testCompile 'junit:junit:4.12'
        testCompile('org.truth0:truth:0.23') {
            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 sourceSets.main.output
        jmhCompile 'org.openjdk.jmh:jmh-core:1.9.3'
        jmhCompile 'org.openjdk.jmh:jmh-generator-annprocess:1.9.3'
        
        compileOnly 'org.kohsuke.metainf-services:metainf-services:1.5'
        // compileOnly 'com.google.auto.service:auto-service:1.0-rc1' // same as metainf-services
        // markdownDoclet "ch.raffael.pegdown-doclet:pegdown-doclet:1.1.1"
    }

    sourceSets {
        main.compileClasspath += configurations.compileOnly
        test.compileClasspath += configurations.compileOnly

        main.compileClasspath += configurations.provided
        test.compileClasspath += configurations.provided
        test.runtimeClasspath += configurations.provided
    }

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

    compileJava.dependsOn processResources
    classes {
        doLast {
            scanAndInstrument(sourceSets.main, [configurations.provided, configurations.runtime])
        }
    }

    test.dependsOn jar
    
    tasks.withType(Test) {
        useJUnit()
        // systemProperty 'co.paralleluniverse.fibers.verifyInstrumentation', 'true'
        
        // systemProperty "java.util.logging.config.file", "jul.properties"
        systemProperty "log4j.configurationFile", "${rootProject.projectDir}/log4j.xml"
        // systemProperty "Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"

        // systemProperty 'co.paralleluniverse.debugMode', 'true'
        systemProperty 'co.paralleluniverse.monitoring.flightRecorderLevel', '5'
        systemProperty 'co.paralleluniverse.globalFlightRecorder', 'true'
        systemProperty 'co.paralleluniverse.flightRecorderDumpFile', 'quasar.log'
        systemProperty 'co.paralleluniverse.monitoring.flightRecorderSize', '200000'

        if(project.name != 'quasar-core') {
            jvmArgs "-javaagent:${quasarJar}" // =vdmc (verbose, debug, allow monitors, check class)
        }
        jvmArgs "-Xmx2048m"
        
        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"
        }
    }

    task run(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'

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

    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://docs.guava-libraries.googlecode.com/git-history/v18.0/javadoc/"
            ]
        }
    }

    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
    }

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

    artifacts {
        archives jar
        archives sourcesJar
        archives javadocJar
    }

    signing {
        required { isReleaseVersion && gradle.taskGraph.hasTask("uploadArchives") }
        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:'co.paralleluniverse.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:'co.paralleluniverse.fibers.instrument.InstrumentationTask', 
        classpath: cp)
    ant.instrumentation(verbose:'true', check:'true', debug:'true') {
        fileset(dir: sset.output.classesDir) {
            exclude(name: 'co/paralleluniverse/fibers/instrument/*.class')
        }
    }
}
    
project (':quasar-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'

    [compileJava, compileTestJava, classes, jar]*.enabled = false
        
    sourceSets {
        main {
            java {
                srcDir 'src/main/java'
                srcDir 'src/jdk7/java'
            }
        }
        
        jdk7 {
            java {
                srcDir 'src/main/java'
                srcDir 'src/jdk7/java'
            }
            
            compileClasspath += main.compileClasspath // += main.uoutput
            runtimeClasspath += main.runtimeClasspath // += main.uoutput
        }
        
        jdk7test {
            java {
                srcDir 'src/test/java'
            }
            
            compileClasspath += jdk7.output + test.compileClasspath
            runtimeClasspath += compileClasspath  + test.runtimeClasspath
        }
        
        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 + test.runtimeClasspath
        }
    }
    
    configurations {
        jdk7Archives.extendsFrom runtime
        jdk8Archives.extendsFrom runtime
        
        // jdk7TestCompile.extendsFrom testCompile
        // jdk7TestRuntime.extendsFrom testRuntime
        // jdk8testCompile sourceSets.jdk8.output
        // jdk8testCompile.extendsFrom testCompile
        // jdk8testRuntime.extendsFrom testRuntime
    }
    
    //    if (ext.java8) {
    //        sourceSets {
    //
    //        }
    //    }
    
    dependencies {
        jdk7Compile ":jsr166e"
        compile ":high-scale-lib"
        compile "org.hdrhistogram:HdrHistogram:2.1.3"
        compile("org.latencyutils:LatencyUtils:2.0.2") {
            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"
        compile "com.lmax:disruptor:3.3.2"
        compile("com.esotericsoftware.kryo:kryo:2.24.0") {
            exclude group: "org.ow2.asm", module: '*'
        }
        compile("de.javakaffee:kryo-serializers:0.29") {
            exclude group: "com.esotericsoftware", module: '*'
            exclude group: "com.esotericsoftware.kryo", module: '*'
        }
        provided 'junit:junit:4.12'
    }

    def ssets = [sourceSets.jdk7]
    if(ext.java8) {
        ssets += sourceSets.jdk8
    }
    
    ssets.forEach { set ->
        configure(project.tasks["${set.name}Classes"]) {
            doLast {
                rootProject.scanAndInstrument(set, [configurations["${set.name}Runtime"], configurations.provided, configurations.runtime])
            }
        }

        def jarTask = task("${set.name}Jar", type: Jar) {
            from set.output
            from zipTree("${baselib}/high-scale-lib.jar")  // include non-Maven jars
            exclude 'META-INF/INDEX.LIST'
            
            manifest {
                attributes(
	            "Built-By"                  :   System.getProperty("user.name"),
	            "Implementation-Title"      :   project.name,
	            "Implementation-Version"    :   version,
	            "Implementation-Vendor"     :   vendor,
	            "Premain-Class"             :   "co.paralleluniverse.fibers.instrument.JavaAgent",
                    "Agent-Class"               :   "co.paralleluniverse.fibers.instrument.JavaAgent",
	            "Can-Retransform-Classes"   :   "true",
                    "Can-Redefine-Classes"      :   "true",
                    //  "Class-Path"                :   configurations.runtime.collect { "lib/"+it.getName() }.join(',')
                )
            }
        }
        
        def shadowJarTask = task("${set.name}ShadowJar", type: com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar, dependsOn: jarTask) {
            outputs.upToDateWhen { false }

            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.', 'co.paralleluniverse.asm.'
            
            manifest.inheritFrom jarTask.manifest
        }
        
        def testTask = task("${set.name}Test", type: Test, dependsOn: shadowJarTask) {
            testClassesDir = project.sourceSets["${set.name}test"].output.classesDir
            classpath = project.sourceSets["${set.name}test"].runtimeClasspath
            
            project.afterEvaluate {
                jvmArgs "-javaagent:${shadowJarTask.archivePath}"
            }
        }
        
        artifacts {
            archives shadowJarTask
        }

        assemble.dependsOn shadowJarTask
        check.dependsOn testTask
    }

        
    compileJdk7Java {
        sourceCompatibility = '1.7'
        targetCompatibility = '1.7'
    }
    
    jdk7Jar {
        from zipTree("${baselib}/jsr166e.jar")  // include non-Maven jars
    }

    jdk7ShadowJar {
        dependencies {
            include(dependency(':jsr166e'))
        }
    }
    
    artifacts {
        jdk7Archives jdk7ShadowJar
    }
        
    if (ext.java8) {
        compileJdk8Java {
            sourceCompatibility = '1.8'
            targetCompatibility = '1.8'
        }
        
        compileJdk8testJava {
            sourceCompatibility = '1.8'
            targetCompatibility = '1.8'
        }
        
        jdk8Jar {
            classifier = 'jdk8'
        }
    
        jdk8ShadowJar {
            classifier = 'jdk8' + (classifier.empty ? '' :  '-')
        }
        
        artifacts {
            jdk8Archives jdk8ShadowJar
        }
    }
    
    javadoc {
        if (project.ext.java8) {
            source = sourceSets.jdk8.allJava
        } else {
            source = sourceSets.jdk7.allJava
        }
        
        //        excludes = [
        //        "co/paralleluniverse/common/logging/**",
        //        "co/paralleluniverse/common/monitoring/**",
        //        "co/paralleluniverse/common/util/**",
        //        ]
    }
    
    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
        }
    }
}

project (':quasar-actors') {
    //project.evaluationDependsOn(':quasar-core')

    dependencies {
        provided project(path: ':quasar-core', configuration: 'jdk7Archives')
        // compile 'org.mutabilitydetector:MutabilityDetector:0.9.2'
        compile "org.slf4j:slf4j-api:1.7.12"
        compile "net.bytebuddy:byte-buddy:0.6.5"
        testRuntime("org.apache.logging.log4j:log4j-slf4j-impl:2.3") {
            exclude group: "org.slf4j", module: '*'
        }
        testRuntime "org.apache.logging.log4j:log4j-api:2.3"
        testRuntime "org.apache.logging.log4j:log4j-core:2.3"
        testRuntime "com.lmax:disruptor:3.3.2" // required for log4j
    }
}

project (':quasar-galaxy') {
    dependencies {
        provided project(path: ':quasar-core', configuration: 'jdk7Archives')
        compile project(':quasar-actors')

        compile ("co.paralleluniverse:galaxy:1.4")  {
            exclude group: 'com.lmax', module: 'disruptor'
            exclude group: 'de.javakaffee', module: 'kryo-serializers'
            exclude group: 'com.google.guava', module: 'guava'
            exclude group: "org.slf4j", module: '*'
        }

        testCompile ('org.gridkit.lab:telecontrol-ssh:0.7.24'){
            exclude group: 'org.ow2.asm', module: '*'
            exclude group: 'org.slf4j', module: '*'
        }
        testRuntime files(jar.archivePath)
    }


    tasks.withType(Test) {
        systemProperty "co.paralleluniverse.quasarJar", "${quasarJar}"
        systemProperty "jgroups.bind_addr", "127.0.0.1"
        systemProperty "galaxy.multicast.address", "225.0.0.1"
        systemProperty "galaxy.multicast.port", "7050"
        systemProperty "co.paralleluniverse.galaxy.configFile", "${sourceSets.main.output.resourcesDir}/config/peer.xml"
        systemProperty "co.paralleluniverse.galaxy.autoGoOnline", "true"
    }

    tasks.withType(JavaExec) {
        main = mainClass
        systemProperty "log4j.configurationFile", "${rootProject.projectDir}/log4j.xml"
        systemProperty "Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"
        // systemProperty 'co.paralleluniverse.fibers.verifyInstrumentation', 'true'
        // systemProperty "co.paralleluniverse.io.useJDKSerialization", "true"
        jvmArgs "-javaagent:${quasarJar}" // =v, =d
        jvmArgs "-ea", "-XX:MaxDirectMemorySize=100M"
        systemProperty "jgroups.bind_addr", "127.0.0.1"
        systemProperty "galaxy.multicast.address", "225.0.0.1"
        systemProperty "galaxy.multicast.port", "7050"
        systemProperty "co.paralleluniverse.galaxy.configFile", "${sourceSets.main.output.resourcesDir}/config/peer.xml"
        systemProperty "co.paralleluniverse.galaxy.autoGoOnline", "true"
    }
}

task javadoc(type: Javadoc, dependsOn: subprojects.javadoc) {
    title = "Quasar ${project(':quasar-core').version}"
    destinationDir = file("docs/javadoc")
    
    if (project.ext.java8) {
        source = project(':quasar-core').sourceSets.jdk8.allJava
    } else {
        source = project(':quasar-core').sourceSets.jdk7.allJava
    }
    source += project(':quasar-actors').sourceSets.main.allJava
    
    classpath = files(subprojects.collect { project -> project.sourceSets.main.compileClasspath })
    options {
        // docletpath = project(':quasar-core').configurations.markdownDoclet.files.asType(List)
        // doclet = 'ch.raffael.doclets.pegdown.PegdownDoclet'
        // addStringOption("parse-timeout", "10")
        // stylesheetFile = rootProject.file('./baselib/javadoc.css')
        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 = [
        "co/paralleluniverse/actors/spi/**",
        "co/paralleluniverse/actors/ActorMonitor.java",
        "co/paralleluniverse/actors/GlobalRegistry.java",
        "co/paralleluniverse/actors/JMXActorMonitor.java",
        "co/paralleluniverse/actors/LifecycleListener.java",
        "co/paralleluniverse/actors/LifecycleListenerProxy.java",
        "co/paralleluniverse/actors/MutabilityTester.java",
        "co/paralleluniverse/actors/RemoteActorProxyFactoryService.java",
        "co/paralleluniverse/actors/RemoteActorRef.java",
        "co/paralleluniverse/actors/RemoteActorProxyFactory.java",
        "co/paralleluniverse/common/benchmark/**",
        "co/paralleluniverse/common/classloader/**",
        "co/paralleluniverse/common/logging/**",
        "co/paralleluniverse/common/monitoring/**",
        "co/paralleluniverse/common/reflection/**",
        "co/paralleluniverse/common/util/**",
        "co/paralleluniverse/concurrent/forkjoin/**",
        "co/paralleluniverse/concurrent/util/**",
        "co/paralleluniverse/data/record/DynamicGeneratedRecord.java",
        "co/paralleluniverse/data/record/DynamicRecord.java",
        "co/paralleluniverse/fibers/DefaultFiberPool.java",
        "co/paralleluniverse/fibers/FibersMonitor.java",
        "co/paralleluniverse/fibers/FiberTimedScheduler.java",
        "co/paralleluniverse/fibers/Instrumented.java",
        "co/paralleluniverse/fibers/NoopFibersMonitor.java",
        "co/paralleluniverse/fibers/instrument/**",
        "co/paralleluniverse/io/serialization/**",
        "co/paralleluniverse/remote/**",
        "co/paralleluniverse/strands/channels/SelectActionImpl.java",
        "co/paralleluniverse/strands/channels/disruptor/**", // not ready
        "co/paralleluniverse/strands/queues/**",
    ]
}

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

task wrapper(type: Wrapper) {
    gradleVersion = '2.2.1'
}