build.gradle

apply plugin: 'com.github.johnrengelman.shadow'
apply plugin: 'java'
apply plugin: 'com.github.hierynomus.license'

description = "H2O Application Assembly"
// Exclude unwanted dependencies
configurations {
    compile.exclude module: 'junit'
    compile.exclude module: 'mockito-all'
    compile.exclude module: 'zookeeper'
    compile.exclude module: 'javax.mail.glassfish'
    compile.exclude module: 'servlet-api'
}

// Dependencies
dependencies {
    compile project(":h2o-app")
    compile project(":h2o-web")
    compile project(":h2o-avro-parser")
    compile project(":h2o-persist-s3")
    compile project(":h2o-persist-hdfs")
    if (project.hasProperty("doIncludeOrc") && project.doIncludeOrc == "true") {
        compile project(":h2o-orc-parser")
    }
    compile project(":h2o-parquet-parser")
    compile "org.slf4j:slf4j-log4j12:1.7.10"
}

//
// Bundle optional modules
// The process is defined by convention. There are two flags:
//  - -Pwith${componentName}=true - enables component "componentName" and includes it in assembly
//  - -P${componentName}Version=3.14 - overrides default component version
//
for (comp in optionalComponents) {
    def compName = comp['name']
    def compVersion = comp['version']
    def compEnabled = comp['enabled']
    def compPropName = "with${compName.capitalize()}"
    def compPropVersionName = "${compName}Version"

    if (!project.hasProperty(compPropVersionName)) {
        project.ext.set(compPropVersionName, compVersion)
    }
    if (compEnabled || project.hasProperty(compPropName) && project.property(compPropName)) {
        logger.lifecycle("== ${project.path}: Using optional component: ${compName}, version ${project.findProperty(compPropVersionName)}")
        apply from: "$rootDir/gradle/components/${compName}.gradle"
    }
    
}

shadowJar { 
  zip64 true
  mergeServiceFiles()
  classifier = ''
  // CDH 5.3.0 provides joda-time v1.6 which is too old, shadow the library instead
  if (!project.hasProperty("jacocoCoverage")) {
    relocate 'org.joda.time', 'ai.h2o.org.joda.time'
  }
  exclude 'META-INF/*.DSA'
  exclude 'META-INF/*.SF'
  exclude 'synchronize.properties'
  exclude 'uploader.properties'
  exclude 'test.properties'
  exclude 'cockpitlite.properties'
  exclude 'devpay_products.properties'
  manifest {
    attributes 'Main-Class': 'water.H2OApp'
  }
  transform(com.github.jengelman.gradle.plugins.shadow.transformers.IncludeResourceTransformer.class) {
    file = file("${buildDir}/reports/license/dependency-license.xml")
    resource = "META-INF/license/h2o-depenencies-licenses.xml"
  }
}

artifacts {
  archives shadowJar
}

//
// Support make infrastructure by copying the resulting assembly into parent
// project build directory
//

def assembly = "main.jar"
def allInOne = "h2o.jar"

task copyJar(type: Copy) {
    from ("${project.buildDir}/libs"){
        include assembly
    }
    into "${project.parent.parent.buildDir}"
    rename { it.replace(assembly, allInOne) }
}

downloadLicenses {
    ext.apacheTwo = license('Apache License, Version 2.0', 'http://opensource.org/licenses/Apache-2.0')
    ext.bsd = license('BSD License', 'http://www.opensource.org/licenses/bsd-license.php')

    licenses = [
            'commons-beanutils:commons-beanutils:1.7.0': apacheTwo,
            'asm:asm-parent:3.1': bsd,
            'org.codehaus.jettison:jettison:1.1': apacheTwo,
            'javax.servlet.jsp:jsp-api:2.1': license('CDDL + GPLv2 with classpath exception', 'https://glassfish.dev.java.net/nonav/public/CDDL+GPL.html'),
            'org.apache.zookeeper:zookeeper:3.4.6': apacheTwo
    ]

    aliases = [
            (apacheTwo) : ['The Apache Software License, Version 2.0', 'Apache 2', 'Apache License Version 2.0', 'Apache License, Version 2.0', 'Apache License 2.0', license('Apache License', 'http://www.apache.org/licenses/LICENSE-2.0')],
            (bsd) : ['BSD', license('New BSD License', 'http://www.opensource.org/licenses/bsd-license.php')]
    ]
}

task licenseReport(dependsOn: project.tasks.getByName('downloadLicenses')) {
    doLast {
        def jsonLicensesFile = file("${buildDir}/reports/license/dependency-license.json")
        def csvLicensesFile = file("${buildDir}/reports/license/dependency-license.csv")
        def licenses = new groovy.json.JsonSlurper().parseText(jsonLicensesFile.text)
        csvLicensesFile.withWriter('UTF-8') { w ->
            boolean xgboostDefined = false
            w.write('"Dependency","File","License Name","License URL"\n')
            licenses.dependencies.each { dep ->
                dep.licenses.each {
                    xgboostDefined |= dep.file.startsWith("xgboost4j")
                    boolean licenseValid = it.name != "No license found"
                    if (! licenseValid) {
                        if (dep.name == "asm:asm-parent:3.1") {
                            // FIXME: manual override, this doesn't work for some reason!
                            w.write("${dep.name},${dep.file},\"BSD License\",http://www.opensource.org/licenses/bsd-license.php\n")
                        } else
                            throw new StopExecutionException("License not found for dependency ${dep.name}. Please define dependency manually.")
                    }
                    w.write("${dep.name},${dep.file},\"${it.name}\",${it.url}\n")
                }
            }
            if (! xgboostDefined) {
                // Manually add XGBoost
                logger.error('ERROR: XGBoost dependency is manually defined, please consider changing it!')
                w.write("ml.dmlc:xgboost-jvm:0.7,xgboost4j-0.7.jar,\"Apache License 2.0\",http://opensource.org/licenses/Apache-2.0\n")
            }
        }
    }
}

// Include licences
shadowJar.dependsOn(licenseReport)
// Execute always copyJar
shadowJar.finalizedBy copyJar
// Run shadowJar as par of build
jar.finalizedBy shadowJar