build.gradle

import javax.tools.ToolProvider

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath "net.ltgt.gradle:gradle-errorprone-plugin:0.0.12"
    }
}

plugins {
    id 'java'
    id 'maven'
    id 'maven-publish'
    id "nebula.ospackage" version "4.3.0"
    id "com.jfrog.bintray" version "1.7"
    id "jacoco"
}

def currentJvm = org.gradle.internal.jvm.Jvm.current()

// don't enable errorprone for JDK 7 - it does not work
if (!currentJvm.toString().startsWith("1.7")) {
    apply plugin: 'net.ltgt.errorprone'
    dependencies.create('com.google.errorprone:error_prone_core:2.0.5')
}

group 'com.sun.tools.btrace'
version = '1.3.11'
description = 'BTrace - a safe, dynamic tracing tool for the Java platform'

sourceCompatibility = 7
targetCompatibility = 7

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

    repositories {
        jcenter()
        mavenLocal()
        mavenCentral()
    }
}

// Support for releasing to BinTray; see https://github.com/bintray/gradle-bintray-plugin
// Add 'gradle.properties' file containing the following properties:
// * bintray.user
// * bintray.key
// * gpg.passphrase
bintray {
    user = project.hasProperty("bintray.user") ? project.property("bintray.user") : System.getenv('BINTRAY_USER')
    key = project.hasProperty("bintray.key") ? project.property("bintray.key") : System.getenv('BINTRAY_API_KEY')

    publications = ['agent', 'client', 'boot']

    dryRun = System.properties['bintrayUpload'] != null ? !(Boolean.getBoolean('bintrayUpload')) : true
    publish = true

    pkg {
        repo = 'maven'
        name = 'btrace'
        desc = 'BTrace'
        userOrg = 'btraceio'
        websiteUrl = 'https://github.com/btraceio/btrace'
        issueTrackerUrl = 'https://github.com/btraceio/btrace/issues'
        vcsUrl = 'https://github.com/btraceio/btrace.git'
        licenses = ['GPL-2.0+CE']
        labels = []
        publicDownloadNumbers = true
        version {
            name = project.version //Bintray logical version name
            released  = new java.util.Date()
            vcsTag = 'v' + project.version
            //Optional configuration for GPG signing
            gpg {
                sign = project.hasProperty("gpg.passphrase") //Determines whether to GPG sign the files. The default is false
                passphrase = sign ? project.property("gpg.passphrase") : "" //Optional. The passphrase for GPG signing'
            }
        }
    }
}

def pomDetails = {
    resolveStrategy = Closure.DELEGATE_FIRST
    url 'https://github.com/btraceio/btrace'
    scm {
        url 'https://github.com/btraceio/btrace'
        connection 'scm:git:https://github.com/btraceio/btrace.git'
        developerConnection 'scm:git:https://github.com/btraceio/btrace.git'
    }
    licenses {
        license {
            name 'GNU General Public License, version 2, with the Classpath Exception'
            url 'http://openjdk.java.net/legal/gplv2+ce.html'
        }
    }
    developers {
        developer {
            id 'yardus'
            name 'Jaroslav Bachorik'
            email 'j.bachorik@btrace.io'
        }
    }
}
def env = System.getenv()
def javaHome = env['JAVA_HOME']

def props = System.getProperties()
def osFamily = props['os.family']
def osName = props['os.name']

def asmVersion = '5.2'
def jcToolsVersion = '2.1.1'
def junitVersion = '4.6'

def agentExcludes = ['**/dtrace/*', '**/btrace/*.class', '**/asm/signature/**', \
                     '**/asm/util/**', '**/asm/xml/**', '**/aggregation/**', \
                     '**/compiler/*', '**/client/**', '**/comm/*', \
                     'com/sun/btrace/api/**', 'com/sun/btrace/spi/**', \
                     'com/sun/btrace/instr/**', '**/org/jctools/**', \
                     '**/org/jctools/queues/atomic/**',
                     '**/org/jctools/queues/spec/**', '**/META-INF/*']
def bootExcludes = ['**/dtrace/**', '**/agent/**', '**/compiler/**', '**/client/**', \
                    '**/resources/**', '**/runtime/**', 'com/sun/btrace/util/**', \
                    '**/asm/**', 'com/sun/btrace/api/**', 'com/sun/btrace/spi/**',
                    '**/org/jctools/queues/atomic/**',
                    '**/org/jctools/queues/spec/**', '**/META-INF/**']
def clientExcludes = ['**/agent/**', \
                      '**/util/TimeStamp*', '**/util/MethodId', \
                      '**/util/SamplingSupport', '**/util/templates/**', \
                      '**/instr/**', '**/META-INF/*']
def excludes = ['agent': agentExcludes, 'boot': bootExcludes, 'client': clientExcludes]

sourceSets {
    main {
        java {
            srcDir 'src/share/classes'
            def dtrace = file('/usr/share/lib/java/dtrace.jar')
            if (dtrace.exists()) {
                def dtraceJar = zipTree('/usr/share/lib/java/dtrace.jar')
                if (!dtraceJar.matching { include '**/org/opensolaris/os/dtrace/Consumer.class' }.isEmpty()) {
                    srcDir 'src/solaris'
                }
            }
        }

        resources {
            srcDir 'src/share/classes'
        }
    }

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

        resources {
            srcDir 'src/test/resources'
        }
    }
}

processResources {
    from 'src/share/classes'
    destinationDir compileJava.destinationDir

    include '**/com/sun/btrace/resources/**'
    include '**/com/sun/btrace/runtime/jaxb.index'
    include '**/com/sun/btrace/annotations/jaxb.index'

    def buildDate = (new Date()).format('YYYYMMdd')
    filter{ it.replaceAll('\\{btrace.version\\}', "$version ($buildDate)") }

    includeEmptyDirs = false
}


compileTestJava {
    exclude 'traces'
}


processTestResources {
    from 'src/test'
    destinationDir compileTestJava.destinationDir
    include 'traces/**/*.java'
    include 'traces/**/*.xml'
    include 'resources/classdata/**/*.clazz'
    include 'resources/classdata/**/*.btrc'
}

test {
    testLogging {
        events "failed"
        exceptionFormat "short"
    }
}

task unjar(type: Copy) {
    group 'Build'
    description 'Explode the pre-built asm jar.'

    from([
            zipTree("lib/btrace-asm-${asmVersion}.jar"),
            zipTree("lib/btrace-jctools-core-${jcToolsVersion}.jar")
        ])
    into compileJava.destinationDir
}


['agent', 'boot', 'client'].each { name ->
    tasks.create(name: "${name}Jar", type: Jar) {
        group 'Build'
        description "Build the btrace-${name} jar."
        inputs.files unjar.outputs

        appendix name
        from sourceSets.main.output
        exclude excludes["${name}"]
        destinationDir buildDir
        // unfortunately there's a hard-coded reference to "btrace-${name}.jar" in the code - so we have to strip the version
        archiveName "$baseName-$appendix.$extension"

        if (['agent', 'client'].contains(name)) {
            manifest {
                // alternatively we could "inline" the ${name}-manfifest's content
                from file("src/share/classes/META-INF/${name}-manifest.mf")
            }
        }
    }


    tasks.create(name: "${name}SourcesJar", type: Jar) {
        group 'Documentation'
        description "Build the btrace-${name} sources jar."

        appendix "${name}"
        classifier 'sources'
        from sourceSets.main.allSource
        exclude excludes["${name}"]
    }


    tasks.create(name: "${name}Javadoc", type: Javadoc) {
        group 'Documentation'
        description "Generates Javadoc API documentation for the btrace-${name}."

        title = "btrace-${name}"
        source = sourceSets.main.allJava
        destinationDir = file("${project.docsDir}/${name}/javadoc")
        classpath = files(compileJava.destinationDir) + configurations.compile.asFileTree
        exclude excludes["${name}"]
        options.addStringOption('Xdoclint:all,-missing', '-quiet')
        failOnError false
    }


    tasks.create(name: "${name}JavadocJar", type: Jar) {
        group 'Documentation'
        description "Build the btrace-${name} javadoc jar."

        appendix name
        classifier 'javadoc'
        from tasks["${name}Javadoc"].getOutputs()
    }
}


javadoc {
    classpath = files(compileJava.destinationDir) + configurations.compile.asFileTree
    options.addStringOption('Xdoclint:all,-missing', '-quiet')
    failOnError false
}


task buildTraces(type: Exec) {
    group 'Build'
    inputs.files clientJar.outputs
    inputs.files testClasses.outputs
    inputs.dir "src/test/traces"
    outputs.dir "${buildDir}/classes/traces"

    workingDir "$projectDir"
    environment('BTRACE_HOME', "$projectDir")
    def btracec = (osFamily == 'windows') ? 'btracec.bat' : 'btracec'
    executable "bin/${btracec}"
    args "-cp ${buildDir}/classes/java/test"
    args "-d ${buildDir}/classes/"
    args fileTree(dir: "src/test/traces", include: '**/*.java', exclude: 'verifier/**/*.java')
}


task buildDTrace(type:Exec) {
    group 'Build'
    description 'Build the native library for DTrace integration'
    onlyIf {osName == 'SunOS'}
    inputs.dir 'src/solaris/native'
    inputs.files bootJar.outputs
    outputs.dir "${buildDir}/i386"

    workingDir 'make'

    commandLine 'make'
}


def distContent = copySpec {
    into('bin') {
        from 'bin'
    }

    into('build') {
        from "$buildDir"
        include '*.jar'
        include 'i386/*.so'
    }

    into ('docs') {
        from 'docs'
        include 'javadoc/**'
        include 'usersguide.html'
    }

    into ('samples') {
        from 'samples'
    }

    into('.') {
        from '.'
        include '*.md'
        include '*.txt'
        include 'COPYRIGHT'
        include 'LICENSE'
    }
}


task createBinDistZip(type: Zip) {
    group 'Build'
    description 'Build the binary distribution zip-file.'
    inputs.files agentJar.outputs
    inputs.files bootJar.outputs
    inputs.files clientJar.outputs
    inputs.files buildDTrace.outputs

    appendix = 'bin'
    with distContent
}


task createBinDistTgz(type: Tar) {
    group 'Build'
    description 'Build the binary distribution tgz-file.'
    inputs.files agentJar.outputs
    inputs.files bootJar.outputs
    inputs.files clientJar.outputs
    inputs.files buildDTrace.outputs

    compression = Compression.GZIP

    appendix = 'bin'
    with distContent
}


ospackage {
    maintainer = 'Jaroslav Bachorik'

    if (project.version.endsWith('-SNAPSHOT')) {
        version = project.version - '-SNAPSHOT'
        release = (new Date()).format('YYYYMMdd.HHmmss')
    }

    postInstall file('packaging/debian/btrace/DEBIAN/postinst')

    requires('openjdk-7-jdk').or('openjdk-8-jdk')

    from(buildDir) {
        into '/usr/lib/btrace'
        include 'btrace-*.jar'
    }

    from('packaging/debian/btrace/usr/bin') {
        into '/usr/bin'
    }
}

buildDeb {
    inputs.files agentJar.outputs
    inputs.files bootJar.outputs
    inputs.files clientJar.outputs
}

buildRpm {
    inputs.files agentJar.outputs
    inputs.files bootJar.outputs
    inputs.files clientJar.outputs
}

task buildDistributions {
    dependsOn createBinDistZip, createBinDistTgz
    dependsOn buildDeb, buildRpm
}

test {
    dependsOn cleanTest
    inputs.files buildTraces.outputs
    inputs.files buildDTrace.outputs
    testLogging.showStandardStreams = true
}

dependencies {
    compile files("lib/btrace-asm-${asmVersion}.jar",
                  "lib/btrace-jctools-core-${jcToolsVersion}.jar",
                  "${javaHome}/lib/tools.jar",  // ATTENTION: build.xml uses "${javaHome}/../lib/tools.jar"
        files(((URLClassLoader) ToolProvider.getSystemToolClassLoader()).getURLs()),
              "/usr/share/lib/java/dtrace.jar")

    testCompile files("test-lib/asm-all-${asmVersion}.jar",
                    "test-lib/junit-${junitVersion}.jar")

    testRuntime files("%buildDir/btrace-agent.jar") {
        builtBy 'agentJar'
    }
    testRuntime files("%buildDir/btrace-boot.jar") {
        builtBy 'bootJar'
    }
    testRuntime files("$buildDir/btrace-client.jar") {
        builtBy 'clientJar'
    }
}

publishing {
    publications {
        agent(MavenPublication) {
            artifactId 'btrace-agent'
            artifact agentJar
            artifact agentSourcesJar {
                classifier "source"
            }
            artifact agentJavadocJar {
                classifier "javadoc"
            }
            pom.withXml {
                asNode().children().last() + pomDetails
            }
        }

        client(MavenPublication) {
            artifactId 'btrace-client'
            artifact clientJar
            artifact clientSourcesJar {
                classifier "sources"
            }
            artifact clientJavadocJar {
                classifier "javadoc"
            }
            pom.withXml {
                asNode().children().last() + pomDetails
            }
        }

        boot(MavenPublication) {
            artifactId 'btrace-boot'
            artifact bootJar
            artifact bootSourcesJar {
                classifier "sources"
            }
            artifact bootJavadocJar {
                classifier "javadoc"
            }
            pom.withXml {
                asNode().children().last() + pomDetails
            }
        }
    }

    /* ---- configure the repository URL . . .
    repositories {
    maven {
    if (version endsWith('-SNAPSHOT') {
    url 'https://oss.sonatype.org/content/repositories/snapshots'
    } else {
    // signing is missing!
    url 'https://oss.sonatype.org/service/local/staging/deploy/maven2'
    }
    }
    }
     */
}

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

check.dependsOn jacocoTestReport