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.
 */

import org.apache.tools.ant.taskdefs.condition.Os
import org.yaml.snakeyaml.Yaml

import javax.inject.Inject

// Gives tasks access to an injected `ExecOperations` for running external processes from a `doLast` block.
interface InjectedExecOps {
    @Inject
    ExecOperations getExecOps()
}

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 libs.snakeyaml
    }
}

plugins {
    alias(libs.plugins.protobuf)
    alias(libs.plugins.spotbugs)
    alias(libs.plugins.download)
}

ext {
    fdbEnvironment = [:]
    // Name of the directory (under the root project's build directory) that subprojects publish
    // their artifacts into for publishing to Maven Central
    stagingRepoDirName = 'staging-repo'
}

// Configure publishing to maven central.
//
// Both publishBuild and centralPublish must be set for these tasks to be registered at all.
// This avoids registering the tasks if we are not going to be publishing to maven central
if (Boolean.parseBoolean(publishBuild) && Boolean.parseBoolean(centralPublish)) {
    apply from: rootProject.file('gradle/central-publishing.gradle')
}

defaultTasks 'build'

apply from: 'gradle/root.gradle'

def isReleaseBuild = Boolean.parseBoolean(getProperty('releaseBuild'))

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

    // Propagate debugging option to tests
    // This makes sure that all tests are running in debug mode by default which is convenient, when e.g. working
    // with IntelliJ because we do not have to set the 'debugBuild' configuration for each test individually,
    // though this requires making sure that we set 'debugBuild' to false explicitly when producing a release
    // or snapshot build to make sure that the tests are _not_ running in that mode and rather running in prod-like
    // environment.
    project.tasks.withType(Test).configureEach {
        systemProperty "debugBuild", System.getProperty("debugBuild", "true")
        dependsOn("sourcesJar")
    }

    layout.buildDirectory.set(layout.projectDirectory.dir(".out"))
    ext {
        distDir = ".dist"
    }

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

    // Configure JUnit tests
    tasks.withType(Test).configureEach {
        reports.junitXml.outputLocation = project.layout.buildDirectory.dir("test-results")
    }

    def projectName = it.name
    def projectVersion = it.version

    // 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": projectName,
                    "Specification-Version": "${-> projectVersion}",
                    "Specification-Vendor": "Apple Inc.",
                    "Implementation-Title": projectName,
                    "Implementation-Version": "${-> projectVersion}",
                    "Implementation-Vendor": "Apple Inc."
        }
        doFirst {
            manifest {
                attributes "Built-Date": new Date(),
                        "Built-By": System.getProperty("user.name")
            }
        }
    }

    // Create the sources jar
    tasks.register('sourcesJar', Jar) {
        dependsOn 'compileJava'
        description = "Assembles a Jar archive containing the main sources."
        group = JavaBasePlugin.DOCUMENTATION_GROUP
        archiveAppendix = null
        archiveClassifier = "sources"
        from sourceSets.main.allSource
    }

    // Create the Javadoc jar
    tasks.register('javadocJar', Jar) {
        description = "Assembles a Jar archive containing the main Javadoc."
        group = JavaBasePlugin.DOCUMENTATION_GROUP
        archiveAppendix = null
        archiveClassifier = "javadoc"
        from tasks.named('javadoc')
    }

    // Distribution
    tasks.register('createDistribution', Sync) {
        // source directory depends on the subproject
        into distDir
    }

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

    build {
        dependsOn tasks.named('jar'), tasks.named('package')
    }

    signing {
        def signingKey = findProperty("signingKey")
        def signingPassword = findProperty("signingPassword")
        if (signingKey != null && signingPassword != null) {
            useInMemoryPgpKeys(signingKey, signingPassword)
        }
    }

    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')

    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(21)
        }

        // Pin `sourceCompatibility`/`targetCompatibility` to match the bytecode and API target that we set for
        // `JavaCompile` tasks via `options.release` below. This also makes IntelliJ’s Gradle importer set the
        // appropriate `languageLevel` in `.idea/misc.xml`.
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }

    def publishBuild = Boolean.parseBoolean(findProperty('publishBuild') ?: 'false')
    def autoServiceVersion = publishBuild ? libs.versions.autoService.asProvider().get() : libs.versions.autoService.development.get()

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

    def projectName = it.name
    ext {
        coreProjectName = "fdb-record-layer-core"
        shadedProjectName = "fdb-record-layer-core-shaded"
        publishLibrary = true
        downloadsDirectory = rootProject.layout.projectDirectory.dir(".downloaded-build-assets/${projectName}")
    }

    tasks.named('assemble') {
        dependsOn tasks.named('sourcesJar'), tasks.named('javadocJar'), tasks.named('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', '17')
                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://foundationdb.github.io/fdb-record-layer/api/fdb-extensions/", "${packageListDir}/fdb-extensions/"
                    linksOffline "https://foundationdb.github.io/fdb-record-layer/api/fdb-record-layer-core/", "${packageListDir}/fdb-record-layer-core/"
                }
            }

            // Override some options on every compile task (main and test).
            tasks.withType(JavaCompile).configureEach {
                // Enable compilation in a separate daemon process.
                options.fork = true

                // Enable incremental compilation.
                options.incremental = true

                // Compile against the Java 17 API and emit Java 17 bytecode.
                options.release = 17
            }
        }
    }

    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'

    // At the end of a release build, we want to update all the yamsql files to replace !current_version with the
    // version being built
    tasks.register('updateYamsql') {
        mustRunAfter 'test'
        mustRunAfter 'build'
        def execOps = objects.newInstance(InjectedExecOps).execOps
        def projectVersion = project.version
        def yamsqlFiles = sourceSets["test"].resources.srcDirs.collect { resourceDir ->
            fileTree(dir: resourceDir).matching {
                include '**/*.yamsql'
                exclude '/initial-version/*'
                exclude '/supported-version/*'
            }
        }
        doLast {
            if (isReleaseBuild) {
                // don't replace !current_version in the supported-version resources, as those are there to test
                // supported_version, we want the !current_version to stick around
                println("Replacing !current_version...")
                yamsqlFiles.each { tree ->
                    tree.each { yamsql ->
                        def original = yamsql.text
                        def updated = original.replaceAll("(?<!\")!current_version(?!\")", projectVersion)
                        if (original != updated) {
                            println("Replacing !current_version in " + yamsql)
                            // Replace !current_version in all yamsql, unless it is surrounded by ", allowing it to be used in
                            // comments, without issue, e.g. in showcasing-tests
                            yamsql.write(updated)
                            execOps.exec {
                                workingDir '.'
                                commandLine 'git', 'add', yamsql
                            }
                        }
                    }
                }
            }
        }
    }
}

// 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 {
    // Capture the distribution destination directories at configuration time so the configuration cache does not
    // need to reach into `allprojects` from the `doLast` closure at execution time.
    def distributionDirs = allprojects.collect { it.tasks.createDistribution.destinationDir }
    doLast {
        delete ".idea_build"
        delete distributionDirs
    }
}

apply from: 'gradle/sphinx.gradle'

// fdb-environment.properties is the old way we configured the library path and cluster file, it does not scale well
// to multiple cluster files, so is being replaced with a yaml file.
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))
        }
        return
    }
}
if (!ext.fdbEnvironment.isEmpty()) {
    def fdbenv = ext.fdbEnvironment
    allprojects {
        tasks.withType(Test).configureEach { task ->
            task.environment(fdbenv)
        }
    }
}

def fdbEnvironmentYamlFile = new File("${rootProject.projectDir}/fdb-environment.yaml")
if (fdbEnvironmentYamlFile.exists()) {
    def libraryPath = new Yaml().loadAll(fdbEnvironmentYamlFile.newInputStream()).first().libraryPath
    def libraryPathVariable = Os.isFamily(Os.FAMILY_MAC) ? "DYLD_LIBRARY_PATH" : "LD_LIBRARY_PATH"
    allprojects {
        tasks.withType(Test).configureEach { task ->
            task.environment([(libraryPathVariable): libraryPath])
            task.environment(FDB_ENVIRONMENT_YAML: fdbEnvironmentYamlFile.absolutePath)
        }
    }
}