build.gradle

/*
 * build.gradle
 *
 * This source file is part of the FoundationDB open source project
 *
 * Copyright 2015-2018 Apple Inc. and the FoundationDB project authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

buildscript {
    repositories {
        if (Boolean.parseBoolean(mavenLocalEnabled)) {
            mavenLocal()
            logger.warn 'Warning: you have enabled maven local repository. This should only be used on local workstations to test undeployed library dependencies.'
        }
        mavenCentral()
        jcenter()
    }

    dependencies {
        classpath 'com.github.ben-manes:gradle-versions-plugin:0.13.0'
        classpath 'org.jboss.tattletale:tattletale:1.2.0.Beta2'
        classpath 'de.undercouch:gradle-download-task:3.1.1'
        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.7'
        classpath 'com.github.jengelman.gradle.plugins:shadow:4.0.2'
        //classpath 'gradle.plugin.com.github.spotbugs:spotbugs-gradle-plugin:1.6.4'
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
    }
}

plugins {
    id 'com.github.spotbugs' version '1.6.4'
    id 'org.sonarqube' version '2.6'
}

ext {
    SpotBugsTask = com.github.spotbugs.SpotBugsTask
}

defaultTasks 'build'

apply from: 'gradle/root.gradle'
apply from: 'gradle/sonar.gradle'

allprojects {
    apply plugin: 'base'
    apply plugin: 'java'
    apply plugin: 'maven-publish'
    apply plugin: 'project-reports'
    apply plugin: 'com.github.ben-manes.versions'
    apply plugin: 'de.undercouch.download'

    // Configure all source files to be read using UTF-8
    project.tasks.withType(JavaCompile) {
        options.encoding = "utf-8"
    }
    project.tasks.withType(Javadoc) {
        options.encoding = "utf-8"
    }
    project.tasks.withType(Test) {
        systemProperty "file.encoding", "utf-8"
    }

    buildDir = ".out"
    ext {
        distDir = ".dist"
    }

    // Add -SNAPSHOT to version of non-release builds
    def isReleaseBuild = Boolean.parseBoolean(getProperty('releaseBuild'))
    if (!isReleaseBuild) {
        def versionString = project.version.toString()
        if (!versionString.endsWith("-SNAPSHOT")) {
            project.version = versionString + "-SNAPSHOT"
        }
    }

    // Configure JUnit tests
    tasks.withType(Test) {
        reports.junitXml.destination = project.file("${->project.buildDir}/test-results")
        testLogging.events = ["passed", "skipped", "failed"]
    }

    // Configure JAR generation
    tasks.jar.configure {
        description = "Produces a Jar with the main classes in .out/."
        manifest {
            attributes "Built-JDK": System.getProperty("java.version"),
                    "Specification-Title": project.name,
                    "Specification-Version": "${-> project.version}",
                    "Specification-Vendor": "Apple Inc.",
                    "Implementation-Title": project.name,
                    "Implementation-Version": "${-> project.version}",
                    "Implementation-Vendor": "Apple Inc."
        }
        doFirst {
            manifest {
                attributes "Built-Date": new Date(),
                        "Built-By": System.getProperty("user.name")
            }
        }
    }

    // Create the sources jar
    task sourcesJar(type: Jar) {
        description = "Assembles a Jar archive containing the main sources."
        group = JavaBasePlugin.DOCUMENTATION_GROUP
        appendix = null
        classifier = "sources"
        from sourceSets.main.allSource

        // gradle doesn't currently support autowiring for (generated) sources dirs, so we wire manually
        // we do this here so that we can keep codegen plugins generic/replaceable
        dependsOn {
            afterEvaluate {
                tasks.compileProtobuf
            }
        }
    }

    // Create the Javadoc jar
    task javadocJar(type: Jar) {
        description = "Assembles a Jar archive containing the main Javadoc."
        group = JavaBasePlugin.DOCUMENTATION_GROUP
        appendix = null
        classifier = "javadoc"
        from tasks.javadoc
    }

    // Distribution
    task createDistribution(type: Sync) {
        // source directory depends on the subproject
        into distDir
    }

    // Create umbrella task for all packaging operations
    tasks.create("package", DefaultTask) {
        description = "Produces main, sources, and Javadoc artifacts in .dist/."
        dependsOn createDistribution
    }

    build {
        dependsOn tasks.jar, tasks.package
    }

    repositories {
        if (System.getenv("ARTIFACT_VERSION") != null) {
           version = "${System.getenv('ARTIFACT_VERSION')}"
        } else if (System.getenv("RECORD_LAYER_BUILD_NUMBER") != null) {
           version = "${version}.${System.getenv('RECORD_LAYER_BUILD_NUMBER')}"
        }
        if (Boolean.parseBoolean(mavenLocalEnabled)) {
            mavenLocal()
            logger.warn 'Warning: you have enabled maven local repository. This should only be used on local workstations to test undeployed library dependencies.'
        }
        mavenCentral()
        jcenter()
    }
}

apply from: file('gradle/coverage.gradle')

subprojects {
    apply from: rootProject.file('gradle/testing.gradle')

    sourceCompatibility = '1.8.0'
    targetCompatibility = '1.8.0'

    ext {
        if (System.getenv('PROTO_VERSION') != null) {
            protoMajorVersion = System.getenv('PROTO_VERSION')
        } else {
            protoMajorVersion = '2'
        }
        if (protoMajorVersion == "2") {
            protobufVersion = protobuf2Version
        } else if (protoMajorVersion == "3") {
            protobufVersion = protobuf3Version
        } else {
            throw new GradleException("Unknown protobuf major version: ${protoMajorVersion}")
        }
        if (protoMajorVersion != "2") {
            coreProjectName = "fdb-record-layer-core-pb${protoMajorVersion}"
            shadedProjectName = "fdb-record-layer-core-pb${protoMajorVersion}-shaded"
        } else {
            coreProjectName = "fdb-record-layer-core"
            shadedProjectName = "fdb-record-layer-core-shaded"
        }
    }

    artifacts {
        add("archives", tasks.sourcesJar)
        add("archives", tasks.javadocJar)
    }

    afterEvaluate { project ->
        if (plugins.hasPlugin('java')) {
            javadoc {
                // exclude generated Protobuf classes
                exclude "**/*Proto.java"
                // warnings are errors
                options.addBooleanOption('Xwerror', true)
                options.overview = "src/main/javadoc/overview.html"
            }
            compileJava {
                //enable compilation in a separate daemon process
                options.fork = true

                //enable incremental compilation
                options.incremental = true
            }
        }
    }

    apply from: rootProject.file('gradle/check.gradle')

    if(System.getenv("DO_NOT_CHECK") != null) {
        task check(overwrite: true, dependsOn: quickCheck) { }
    }

    check.dependsOn quickCheck
}

// Script for upgrading gradle. To upgrade the gradle version, set the property to the version
// you want and run the command _twice_.
wrapper {
    def gradleVersion = getProperty("gradleVersion") ?: project.gradle.gradleVersion
    conventionMapping.distributionUrl = {
        // use gradle-all rather than gradle-bin distribution because IntelliJ's Gradle integration
        // works better with the former
        "https://services.gradle.org/distributions/gradle-$gradleVersion-all.zip" as String
    }
}

clean.doLast {
    delete ".idea_build"
    allprojects.each { p ->
        delete p.tasks.createDistribution.destinationDir
    }
}

if (!JavaVersion.current().isJava8Compatible()) {
    throw new Exception("Java 8 is required to build fdb-record-layer")
}

def fdbEnvironment = new File("${rootProject.projectDir}/fdb-environment.properties")
if (fdbEnvironment.exists()) {
    def env = [:]
    fdbEnvironment.eachLine { line ->
        def eq = line.indexOf('=')
        if (eq > 0) env.put(line.substring(0, eq), line.substring(eq + 1))
    }
    if (!env.isEmpty()) {
        allprojects {
            tasks.withType(Test) { task ->
                task.environment(env)
            }
        }
    }
}