build.gradle

import static org.gradle.api.JavaVersion.*

apply plugin: 'java'
apply plugin: 'maven'
apply plugin: 'signing'
apply plugin: 'net.researchgate.release'

group = 'com.hardis.collectd'
archivesBaseName = "jcollectd"

repositories { jcenter() }

sourceCompatibility = VERSION_1_6
targetCompatibility = VERSION_1_6

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

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

task generateHtmlFromMarkdown {
    inputs.file 'README.markdown'
    outputs.file "$buildDir/README.html"

    doLast() {
        file(buildDir).mkdir() // Not sure why we need this (outputs.file should do this for us) but we do

        new ByteArrayOutputStream().withStream { os ->
            def result = exec {
                executable = 'markdown'
                args = ['README.markdown']
                standardOutput = os
            }
            outputs.files.singleFile.text = os.toString()
        }
    }
}

task assembleBinaryDistro(type: Tar) {
    compression 'gzip'

    from (projectDir) {
        include 'build.gradle'
        include 'LICENSE'
        include 'README.markdown'
        include 'etc/*.xml'
    }
    from generateHtmlFromMarkdown.outputs

    into('lib') { 
      from jar.outputs
      from sourcesJar.outputs
    }
    into('javadoc') { from javadoc.outputs }
    into('src/main') { from sourceSets.main.allJava }
    into('src/test') { from sourceSets.test.allJava }
}

task wrapper(type: Wrapper) {
   gradleVersion = '3.3' //version required
}

afterReleaseBuild.dependsOn uploadArchives

artifacts {
    archives sourcesJar
    archives javadocJar
}

signing {
    sign configurations.archives
}

jar {
    manifest {
        attributes ('Main-Class': 'org.collectd.mx.MBeanReceiver',
                    'Premain-Class': 'org.collectd.mx.RemoteMBeanSender')
    }

    // Get the git commit hash (and add it to the manifest) in a doFirst (instead of a config block) so it only actually
    // runs if the task is run (and not if the task is UP-TO-DATE)
   // doFirst() { jar.manifest.attributes('Commit': getGitCommitHash()) }
    from (projectDir) {   
        include 'etc/*.xml'
    }
}

javadoc {
    project.configure(options) {
        author = "false"
        bottom = "Copyright &#169; 2009 <a target=\"_top\" href=\"http://www.hyperic.com/\">Hyperic, Inc.</a>. All Rights Reserved."
        charSet = "UTF-8"
        docTitle = "Jcollectd"
        header = "<b>Java collectd API</b>"
        use = "true"
        version = "false"
        windowTitle = "Java collectd API"
    }
}

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

      repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
        authentication(userName: project.ext.mavenUser, password: project.ext.mavenPassword)
      }

      snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
        authentication(userName: project.ext.mavenUser, password: project.ext.mavenPassword)
      }

      pom.project {
        name 'jcollectd'
        packaging 'jar'
        // optionally artifactId can be defined here 
        description 'The jcollectd package implements the collectd protocol in Java, making it possible for Java applications to push data into collectd over the wire.'
        url 'https://github.com/hardisgroupcom/jcollectd'

        scm {
          connection 'scm:git:https://github.com/hardisgroupcom/jcollectd.git'
          developerConnection 'scm:git:https://github.com/hardisgroupcom/jcollectd.git'
          url 'https://github.com/hardisgroupcom/jcollectd'
        }

        licenses {
          license {
            name 'GNU GENERAL PUBLIC LICENSE Version 2, June 1991'
            url 'https://www.gnu.org/licenses/old-licenses/gpl-2.0.fr.html'
          }
        }

        developers {
          developer {
            name 'Doug MacEachern'           
            organization 'Hyperic' 
          }        
        }
      }
    }
  }
}

// In this section you declare the dependencies for your production and test code
dependencies {
    compile files(org.gradle.internal.jvm.Jvm.current().toolsJar)     
    testCompile "junit:junit:4.11" 
}

buildscript {
  repositories {
    maven {
      url 'https://plugins.gradle.org/m2/'
    }
  }
  dependencies {
    classpath 'net.researchgate:gradle-release:2.4.0'
  }
}

// Get the git commit hash for the current tree using the system git executable.
// The executable must but on the PATH for this to work. If there is any type of error
// the method will return "unknown"
def getGitCommitHash() {
    def hashOutput = new ByteArrayOutputStream()
    def hashError = new ByteArrayOutputStream()

    def result = exec {
        executable = 'git'
        args = ['describe', '--tags', '--always', 'HEAD']
        standardOutput = hashOutput
        errorOutput = hashError
        ignoreExitValue = true
    }

    if(result.getExitValue() != 0) {
        logger.warn "Something with wrong while getting the git commit hash. See error output below. Using 'unknown' as the commit hash value."
        logger.warn hashError.toString()
        return "unknown"
    }

    return hashOutput.toString()
}