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()
    }

    dependencies {
        classpath 'org.jboss.tattletale:tattletale:1.2.0.Beta2'
        classpath 'com.github.jengelman.gradle.plugins:shadow:5.2.0'
    }
}

plugins {
    id 'com.google.protobuf' version '0.8.19'
    id 'com.github.ben-manes.versions' version '0.38.0'
    id 'com.github.spotbugs' version '4.6.1'
    id 'com.jfrog.artifactory' version '4.29.2'
    id 'de.undercouch.download' version '4.1.1'
    id 'org.sonarqube' version '3.3'
}

ext {
    SpotBugsTask = com.github.spotbugs.snom.SpotBugsTask
    fdbEnvironment = [:]
}

defaultTasks 'build'

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

allprojects {
    apply plugin: 'base'
    apply plugin: 'java-library'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'
    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"
        if (project.hasProperty("apiVersion")) {
            systemProperty "com.apple.foundationdb.apiVersion", project.getProperty("apiVersion")
        }
    }

    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")
    }

    // 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, dependsOn: 'compileJava') {
        description = "Assembles a Jar archive containing the main sources."
        group = JavaBasePlugin.DOCUMENTATION_GROUP
        appendix = null
        classifier = "sources"
        from sourceSets.main.allSource
    }

    // 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
    }

    signing {
        if (System.getenv("GPG_KEY_ID") != null) {
            def signingKeyId = System.getenv('GPG_KEY_ID')
            def signingKey = System.getenv('GPG_KEY')
            def signingPassword = System.getenv('GPG_PASSPHRASE')
            useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)
            sign configurations.archives
        }
    }

    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()
    }
}

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

    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11

    def publishBuild = Boolean.parseBoolean(findProperty('publishBuild') ?: 'false')
    if (publishBuild) {
        autoServiceVersion = autoServiceVersion
    } else {
        autoServiceVersion = autoServiceVersionForDevelopment
    }

    project.configurations.all {
        resolutionStrategy.eachDependency {details ->
            if (details.requested.group == 'com.google.auto.service'
                    && details.requested.name == 'auto-service') {
                details.useVersion autoServiceVersion
            }
        }
    }

    ext {
        coreProjectName = "fdb-record-layer-core"
        shadedProjectName = "fdb-record-layer-core-shaded"
    }

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

    afterEvaluate { project ->
        if (plugins.hasPlugin('java')) {
            javadoc {
                // exclude generated Protobuf classes
                exclude "**/*Proto.java"
                exclude "**/*ProtoV3.java"
                exclude "com/apple/foundationdb/record/planprotos/*.java"
                exclude "com/apple/foundationdb/record/query/plan/cascades/debug/eventprotos/*.java"
                options.addBooleanOption('Xwerror', true)

		// Quiet javadoc errors for missing comments, etc.
		// It would be good to have more coverage, but this allows us to move forward with incomplete docs
                options.addBooleanOption('Xdoclint:none', true)

                options.addStringOption('source', '11')
                options.with {
                    overview "src/main/javadoc/overview.html"

                    // Make our Javadocs link to external resources
                    // These use "linksOffline" in order to ensure that we can do offline builds as well as to tweak
                    // a few package lists. These should be periodically regenerated by running the
                    // ${packageListDir}/genpackagelists.py script. (See that script for more details.)
                    def packageListDir = "${project.rootDir}/build/package-lists"
                    linksOffline "https://apple.github.io/foundationdb/javadoc/", "${packageListDir}/fdb-java/"
                    linksOffline "https://developers.google.com/protocol-buffers/docs/reference/java/", "${packageListDir}/protobuf/"

                    // This is for dependent sub-projects so that their links to things in the Record Layer work
                    linksOffline "https://static.javadoc.io/org.foundationdb/fdb-extensions/${project.version}/", "${packageListDir}/fdb-extensions/"
                    linksOffline "https://static.javadoc.io/org.foundationdb/fdb-record-layer-core/${project.version}/", "${packageListDir}/fdb-record-layer-core/"
                }
            }
            compileJava {
                //enable compilation in a separate daemon process
                options.fork = true

                //enable incremental compilation
                options.incremental = true

                //target byte-code compatibility with Java 11 (regardless of build JDK)
                options.release = 11
            }
        }
    }

    apply from: rootProject.file('gradle/check.gradle')
    apply from: rootProject.file('gradle/strict.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 fdbEnvironmentFile = new File("${rootProject.projectDir}/fdb-environment.properties")
if (fdbEnvironmentFile.exists()) {
    fdbEnvironmentFile.eachLine { line ->
        def eq = line.indexOf('=')
        if (eq > 0) ext.fdbEnvironment.put(line.substring(0, eq), line.substring(eq + 1))
    }
}
if (!ext.fdbEnvironment.isEmpty()) {
    def fdbenv = ext.fdbEnvironment
    allprojects {
        tasks.withType(Test) { task ->
            task.environment(fdbenv)
        }
    }
}