build.gradle

/*
 * Copyright 2008-present MongoDB, Inc.
 *
 * 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.
 */

apply plugin: 'eclipse'
apply plugin: 'idea'

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
        jcenter()
        maven { url "https://plugins.gradle.org/m2/" }
    }
    dependencies {
        classpath 'org.kordamp.gradle:clirr-gradle-plugin:0.2.5'
        classpath 'com.netflix.nebula:gradle-extra-configurations-plugin:3.0.3'
        classpath 'gradle.plugin.com.github.spotbugs:spotbugs-gradle-plugin:1.6.4'
    }
}

//////////////////////////////////////////
// Common behavior                      //
//////////////////////////////////////////

ext {
    configDir = new File(rootDir, 'config')
    jnrUnixsocketVersion = '0.18'
    nettyVersion = '4.1.17.Final'
    snappyVersion = '1.1.4'
    zstdVersion = '1.3.8-3'
    mongoCryptVersion = '1.0.0-beta5'
    gitVersion = getGitVersion()
}

def configDir = ext.configDir
def coreProjects = subprojects.findAll { !['util'].contains(it.name) }
def javaProjects = subprojects
def javaMainProjects = subprojects.findAll { !['util'].contains(it.name) }
def javaCodeCheckedProjects = subprojects.findAll { !['util', 'mongo-java-driver', 'driver-benchmarks'].contains(it.name) }

configure(coreProjects) {
    evaluationDependsOn(':util')
    group = 'org.mongodb'
    version = '3.12.0-SNAPSHOT'

    repositories {
        mavenLocal()
        google()
        mavenCentral()
        jcenter()
    }
}

configure(javaProjects) {
    apply plugin: 'java-library'

    sourceCompatibility = JavaVersion.VERSION_1_6
    targetCompatibility = JavaVersion.VERSION_1_6

    sourceSets {
        main {
            java.srcDirs = ['src/main']
        }
    }
}

configure(javaMainProjects) {
    apply plugin: 'idea'
    apply plugin: 'osgi'
    apply plugin: 'nebula.optional-base'

    dependencies {
        compileOnly 'com.google.code.findbugs:jsr305:1.3.9'
        compile 'org.slf4j:slf4j-api:1.7.6', optional
        testCompile 'com.google.code.findbugs:jsr305:1.3.9'
    }

    /* Compiling */
    tasks.withType(AbstractCompile) {
        options.encoding = 'ISO-8859-1'
        options.fork = true
        options.debug = true
        options.compilerArgs = ['-Xlint:all', '-Xlint:-options', '-Xlint:-deprecation']
    }
}

configure(javaCodeCheckedProjects) {
    apply plugin: 'checkstyle'
    apply plugin: "com.github.spotbugs"
    apply plugin: 'org.kordamp.gradle.clirr'
    apply plugin: 'jacoco'
    apply plugin: 'groovy'
    apply plugin: 'codenarc'

    dependencies {
        testCompile 'org.codehaus.groovy:groovy-all:2.4.15'
        testCompile 'org.spockframework:spock-core:1.1-groovy-2.4'
        testCompile 'cglib:cglib-nodep:2.2.2'
        testCompile 'org.objenesis:objenesis:1.3'
        testCompile 'org.hamcrest:hamcrest-all:1.3'
        testCompile 'ch.qos.logback:logback-classic:1.1.1'
        testCompile project(':util') //Adding categories to classpath
    }

    sourceSets {
        test {
            groovy.srcDirs = ['src/test/functional', 'src/test/unit']
        }
    }

    /* Testing */
    tasks.withType(Test) {
        maxHeapSize = "3g"
        maxParallelForks = 1

        systemProperties(
                'org.mongodb.test.uri': System.getProperty('org.mongodb.test.uri'),
                'org.mongodb.test.transaction.uri': System.getProperty('org.mongodb.test.transaction.uri'),
                'org.mongodb.test.embedded.path': System.getProperty('org.mongodb.test.embedded.path'),
                'org.mongodb.useSocket': System.getProperty('org.mongodb.useSocket', 'false'),
                'org.mongodb.disableAsync': System.getProperty('org.mongodb.disableAsync', 'false'),
                'org.mongodb.async.type': System.getProperty('org.mongodb.async.type', 'nio2'),
                'org.mongodb.test.awsAccessKeyId': System.getProperty('org.mongodb.test.awsAccessKeyId'),
                'org.mongodb.test.awsSecretAccessKey': System.getProperty('org.mongodb.test.awsSecretAccessKey'),
                'jna.library.path': System.getProperty('jna.library.path')
        )

        project.ext.buildingWith = { propertyName ->
            project.hasProperty(propertyName) && project.property(propertyName).toBoolean()
        }

        if (project.buildingWith('ssl.enabled')) {
            if (project.hasProperty('ssl.keyStoreType')) {
                systemProperties(
                        'javax.net.ssl.keyStoreType': project.property('ssl.keyStoreType'),
                        'javax.net.ssl.keyStore': project.property('ssl.keyStore'),
                        'javax.net.ssl.keyStorePassword': project.property('ssl.keyStorePassword'),
                )
            }
            if (project.hasProperty('ssl.trustStoreType')) {
                systemProperties(
                        'javax.net.ssl.trustStoreType': project.property('ssl.trustStoreType'),
                        'javax.net.ssl.trustStore': project.property('ssl.trustStore'),
                        'javax.net.ssl.trustStorePassword': project.property('ssl.trustStorePassword')
                )
            }
        }

        if (project.buildingWith('gssapi.enabled')) {
            systemProperties(
                    'sun.security.krb5.debug': project.getProperty('sun.security.krb5.debug'),
                    'javax.security.auth.useSubjectCredsOnly': "false",
                    'java.security.krb5.kdc': project.getProperty('krb5.kdc'),
                    'java.security.krb5.realm': project.getProperty('krb5.realm'),
                    'java.security.auth.login.config': project.getProperty('auth.login.config'),
                    )
        }

        useJUnit {
            excludeCategories 'category.Slow'
        }

        jacoco { enabled = false }

        testLogging { exceptionFormat = 'full' }
    }

    task testSlowOnly(type: Test) {
        useJUnit {
            includeCategories 'category.Slow'
        }
    }

    gradle.taskGraph.whenReady { taskGraph ->
        if (taskGraph.hasTask(testCoverage)) {
            tasks.withType(Test) { jacoco { enabled = true } }
        }
    }

    task testCoverage(dependsOn: test)

    /* Code quality */
    tasks.withType(Checkstyle) {
        reports {
            xml.enabled true
            html.enabled true
        }
    }

    checkstyle {
        toolVersion = "7.4"
        configFile = new File(configDir, 'checkstyle.xml')
        configProperties.checkstyleConfigDir = configDir
    }

    spotbugs {
        excludeFilter = new File(configDir, 'findbugs-exclude.xml')
        sourceSets = [sourceSets.main]
        toolVersion = '3.1.7'
    }

    codenarc {
        toolVersion = '1.1'
        reportFormat = project.buildingWith('xmlReports.enabled') ? 'xml' : 'html'
    }

    tasks.withType(com.github.spotbugs.SpotBugsTask) {
        reports {
            xml.enabled = project.buildingWith('xmlReports.enabled')
            html.enabled = !project.buildingWith('xmlReports.enabled')
        }
    }

    tasks.withType(Test) {
        def jdkHome = findProperty("jdkHome")
        if (jdkHome) {
            def javaExecutablesPath = new File(jdkHome, 'bin')
            def javaExecutables = [:].withDefault { execName ->
                def executable = new File(javaExecutablesPath, execName)
                assert executable.exists() : "There is no ${execName} executable in ${javaExecutablesPath}"
                executable
            }
            executable = javaExecutables.java
        }
    }
}

def getGitVersion() {
    def describeStdOut = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'describe', '--tags', '--always', '--dirty'
        standardOutput = describeStdOut
    }
    describeStdOut.toString().substring(1).trim()
}

apply from: 'gradle/publish.gradle'
apply from: 'gradle/deploy.gradle'
apply from: 'gradle/javadoc.gradle'
apply from: 'gradle/testColorOutput.gradle'


//////////////////////////////////////////
// Root project configuration           //
//////////////////////////////////////////
task wrapper(type: Wrapper) {
    gradleVersion = '4.10.2'
}

if (!JavaVersion.current().isJava9Compatible()) {
    throw new GradleException("""
        | ERROR:
        | JDK ${JavaVersion.VERSION_1_9.getMajorVersion()} is required to build the driver: You are using JDK ${JavaVersion.current().getMajorVersion()}.
        |""".stripMargin()
    )
}