build.gradle

//
// Sparkling Water build file.
// This is a multi-module build file.
//

// The build script settings to fetch plugins and put them on
// classpath
buildscript {
    repositories {
        mavenCentral()
        jcenter()
        gradlePluginPortal()
    }

    dependencies {
        classpath 'org.github.ngbinh.scalastyle:gradle-scalastyle-plugin_2.11:1.0.1'
        classpath "com.bmuschko:gradle-docker-plugin:3.6.1"
        classpath 'com.github.jengelman.gradle.plugins:shadow:5.0.0'
        classpath 'net.researchgate:gradle-release:2.6.0'
        classpath 'com.netflix.nebula:gradle-lint-plugin:10.4.2'
        classpath 'kr.motd.gradle:sphinx-gradle-plugin:2.2.3'
        classpath 'ru.vyarus:gradle-use-python-plugin:1.2.0'
        classpath 'com.github.jk1:gradle-license-report:1.7'
    }
}

apply plugin: 'base'

// For multiproject setup we have to apply release plugin here (we share same release number cross all modules)
if (project.hasProperty("doRelease")) {
    apply from: 'gradle/release.gradle'
}

//
// Common configuration
//
ext {
    // Published projects
    publishedProjects = [
            project(':sparkling-water-repl'),
            project(':sparkling-water-core'),
            project(':sparkling-water-examples'),
            project(':sparkling-water-ml'),
            project(':sparkling-water-package'),
            project(":sparkling-water-doc")
    ]
    // Projects with integration tests
    integTestProjects = [
            project(':sparkling-water-core'),
            project(':sparkling-water-examples')
    ]

    // Projects with benchmarks
    benchProjects = [
            project(':sparkling-water-core'),
            project(':sparkling-water-benchmarks')
    ]

    // Scala projects
    scalaProjects = [
            project(':sparkling-water-repl'),
            project(':sparkling-water-core'),
            project(':sparkling-water-examples'),
            project(':sparkling-water-ml'),
            project(':sparkling-water-app-streaming'),
            project(':sparkling-water-package'),
            project(':sparkling-water-benchmarks'),
            project(':sparkling-water-macros')
    ]
    javaProjects = [
            project(':sparkling-water-extension-stack-trace')
    ]
    pythonProjects = [
            project(':sparkling-water-py')
    ]
    rProjects = [
            project(':sparkling-water-r')
    ]
    docProjects = [
            project(':sparkling-water-doc')
    ]

    defaultScalaBaseVersion = '2.11'
    supportedScalaBaseVersions = ['2.11': '2.11.12']
}

def versionSpecificProps = new Properties()
file("$rootDir/gradle-spark${spark}.properties").withInputStream { versionSpecificProps.load(it) }

def loadVersionSpecificProp(propName, versionSpecificProps) {
    // first check if the property was specified/override via -P
    if (project.hasProperty(propName)) {
        return project.properties.get(propName)
    } else {
        return versionSpecificProps.getProperty(propName)
    }
}

def loadVersion(versionSpecificProps){
    if (project.properties.get("version") != "unspecified") {
        return project.properties.get("version")
    } else {
        return versionSpecificProps.getProperty("version")
    }
}

//
// For all projects (this and all subprojects) specify common properties and tasks
//
configure(allprojects) { project ->
    apply plugin: 'idea'
    apply plugin: 'eclipse'
    apply from: "$rootDir/gradle/artifacts.gradle"
    apply plugin: 'nebula.lint'
    gradleLint.rules = ['all-dependency']
    gradleLint.alwaysRun = false // Run linter manually

    // Version of main components
    ext {
        scalaBaseVersion = project.findProperty('scalaBaseVersion') ?: defaultScalaBaseVersion
        scalaVersion = supportedScalaBaseVersions[scalaBaseVersion]

        // h2oBuild property is defined in gradle.properties
        h2oVersion = "$h2oMajorVersion.$h2oBuild"
        sparkVersion = loadVersionSpecificProp("sparkVersion", versionSpecificProps)
        sparkMajorVersion = sparkVersion.count(".") == 1 ? sparkVersion : sparkVersion.substring(0, sparkVersion.lastIndexOf('.'))
        junitVersion = '4.11'

        minSupportedJavaVersion = loadVersionSpecificProp("minSupportedJavaVersion", versionSpecificProps)
        supportedEmrVersion = loadVersionSpecificProp("supportedEmrVersion", versionSpecificProps)
        extraJVMArgs = loadVersionSpecificProp("extraJVMArgs", versionSpecificProps)
        unsupportedMinorSparkVersions = loadVersionSpecificProp("unsupportedMinorSparkVersions", versionSpecificProps)
        // Nightly build versions have format x.y.z-SNAPSHOT-w where w is the SNAPSHOT build number
        isNightlyBuild = loadVersion(versionSpecificProps).toString().contains("-SNAPSHOT-")
    }

    // All project inherits the same versioning number
    version = loadVersion(versionSpecificProps).toString().replace("-SNAPSHOT", "")
}

// 
// Common configuration for all subprojects
//
configure(subprojects) { project ->
    repositories {
        // Should be enabled only in development mode
        if (project.hasProperty('useMavenLocal') || h2oBuild.endsWith("-SNAPSHOT")) {
            mavenLocal()
        }

        mavenCentral()
        jcenter()

        // Public Sonatype repository
        maven {
            url "https://oss.sonatype.org/content/repositories/releases/"
        }

        // Snapshot repository of H2O builds
        maven {
            url "http://h2o-release.s3.amazonaws.com/h2o/master/$h2oBuild/maven/repo/"
        }

        // We add the local nexus repository because of mojo2. It is defined as the last one so all the artifacts are
        // resolved from public repositories first
        maven {
            url "$localNexusLocation/releases/"
            credentials {
                username project.findProperty("localNexusUsername") ?: "<NA>"
                password project.findProperty("localNexusPassword") ?: "<NA>"
            }
        }

        if (sparkVersion.endsWith("-SNAPSHOT")) {
            maven {
                url "https://repository.apache.org/content/repositories/snapshots/"
            }
        }
    }

    if (project in scalaProjects) {
        apply from: "$rootDir/gradle/scala.gradle"
    }

    if (project in pythonProjects) {
        apply from: "$rootDir/gradle/python.gradle"
    }

    if (project in rProjects) {
        apply from: "$rootDir/gradle/r.gradle"
    }

    if (project in javaProjects) {
        apply plugin: 'java'

        sourceCompatibility = minSupportedJavaVersion
        targetCompatibility = minSupportedJavaVersion
    }
    // All subprojects needs Spark support
    apply from: "$rootDir/gradle/spark.gradle"

    if (project in docProjects) {
        apply plugin: 'java'
        apply plugin: 'kr.motd.sphinx'

        configurations {
            publishArchives
        }
    }

    // Publish artifacts
    if (project in publishedProjects) {
        apply from: "$rootDir/gradle/publish.gradle"
    }

    if (project in integTestProjects) {
        apply from: "$rootDir/gradle/itest.gradle"
    }

    if (project in benchProjects) {
        apply from: "$rootDir/gradle/bench.gradle"
    }
}

clean.doFirst {
    delete file("build/")
    delete file("h2ologs/")
    delete file("null/")
    delete file("metastore_db/")
}

def createStagingId(def username, def password) {
    def proc = ['./createStagingId.sh', username, password].execute([], file("${rootDir.toString()}/gradle/publish"))
    return proc.text
}

def uploadFiles(def username, def password, def repoDir, def stagingId) {
    def proc = ['./uploadToNexus.sh', username, password, repoDir, stagingId].execute([], file("${rootDir.toString()}/gradle/publish"))
    proc.waitFor()
}

def closeBucket(def username, def password, def stagingId) {
    def proc = ['./closeBucket.sh', username, password, stagingId].execute([], file("${rootDir.toString()}/gradle/publish"))
    proc.waitFor()
}

task publishToNexus {
    doLast {
        def stagingId = createStagingId(project.findProperty('nexusUsername'), project.findProperty('nexusPassword')).replace('\n', '')
        uploadFiles(project.findProperty('nexusUsername'), project.findProperty('nexusPassword'), "${rootDir}/dist/build/dist/maven/repo", stagingId)
        closeBucket(project.findProperty('nexusUsername'), project.findProperty('nexusPassword'), stagingId)
    }
}