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()
        maven { url "https://plugins.gradle.org/m2/" }
    }
    dependencies {
        classpath 'com.netflix.nebula:gradle-extra-configurations-plugin:3.0.3'
        classpath "gradle.plugin.com.github.spotbugs.snom:spotbugs-gradle-plugin:4.5.0"
        classpath 'biz.aQute.bnd:biz.aQute.bnd.gradle:5.1.2'
        
        // Scala plugins
        classpath "com.adtran:scala-multiversion-plugin:1.0.36"
        classpath "com.diffplug.spotless:spotless-plugin-gradle:3.27.1"

        // Test logging plugin
        classpath 'com.adarshr:gradle-test-logger-plugin:2.1.0'
    }
}

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

ext {
    configDir = new File(rootDir, 'config')
    jnrUnixsocketVersion = '0.18'
    nettyVersion = '4.1.43.Final'
    snappyVersion = '1.1.4'
    zstdVersion = '1.3.8-3'
    mongoCryptVersion = '1.2.0'
    projectReactorVersion = 'Californium-SR23'
    junitBomVersion = '5.6.2'
    gitVersion = getGitVersion()
}

def configDir = ext.configDir
def coreProjects = subprojects.findAll { !['util'].contains(it.name) }
def javaProjects = subprojects.findAll { !it.name.contains('scala') }
def scalaProjects = subprojects.findAll { it.name.contains('scala') }
def javaMainProjects = javaProjects.findAll { !['util'].contains(it.name) }
def javaCodeCheckedProjects = javaMainProjects.findAll { !['driver-benchmarks', 'driver-workload-executor'].contains(it.name) }
def javaAndScalaTestedProjects = javaCodeCheckedProjects + scalaProjects

configure(coreProjects) {
    apply plugin: 'idea'

    evaluationDependsOn(':util')
    group = 'org.mongodb'
    version = '4.3.0-SNAPSHOT'

    repositories {
        mavenLocal()
        google()
        mavenCentral()
        maven {
            url 'http://oss.sonatype.org/content/repositories/snapshots'
        }

    }
}

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

    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8

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

    tasks.withType(GenerateModuleMetadata) {
        enabled = false
    }
}

configure(scalaProjects) {
    apply plugin: 'scala'
    apply plugin: 'idea'
    apply plugin: "com.adtran.scala-multiversion-plugin"
    apply plugin: "com.diffplug.gradle.spotless"

    group = 'org.mongodb.scala'

    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8

    dependencies {
        compile ('org.scala-lang:scala-library:%scala-version%')
        compile ('org.scala-lang:scala-reflect:%scala-version%')

        testImplementation(platform("org.junit:junit-bom:$junitBomVersion"))
        testImplementation("org.junit.vintage:junit-vintage-engine")

        testImplementation('org.scalatest:scalatest_%%:3.0.8')
        testImplementation('org.scalamock:scalamock_%%:4.4.0')
        testImplementation('ch.qos.logback:logback-classic:1.1.3')
        testImplementation('org.reflections:reflections:0.9.10')
    }


    test{
        useJUnitPlatform {
            includeEngines('junit-jupiter', 'junit-vintage')
        }
    }

    spotless {
        scala {
            scalafmt('2.0.0').configFile("$configDir/scalafmt.conf")
        }
    }
    compileScala.dependsOn('spotlessApply')
    compileTestScala.dependsOn('spotlessApply')

    tasks.withType(ScalaCompile) {
        scalaCompileOptions.deprecation = false
    }

    if (project.scalaVersion.startsWith("2.13")) {
        scaladoc {
            scalaClasspath += files("$rootDir/gradle/scala/lib/scala-ant-2.13.1.jar")
        }
    }

    tasks.withType(GenerateModuleMetadata) {
        enabled = false
    }
}

configure(javaMainProjects) {
    apply plugin: 'nebula.optional-base'
    apply plugin: 'java-library'
    
    dependencies {
        compileOnly 'com.google.code.findbugs:jsr305:1.3.9'
        api 'org.slf4j:slf4j-api:1.7.6', optional
        testImplementation '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']
    }
}

configure(javaAndScalaTestedProjects) {
    /* Testing */
    tasks.withType(Test) {
        systemProperties(System.getProperties().findAll { it.key.toString().startsWith("org.mongodb.") })
        systemProperty('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.hasProperty('ocsp.property')) {
                systemProperties(
                        'org.mongodb.test.ocsp.tls.should.succeed': project.property('ocsp.tls.should.succeed'),
                        'java.security.properties': file(project.property('ocsp.property')),
                        'com.sun.net.ssl.checkRevocation': project.property('ssl.checkRevocation'),
                        'jdk.tls.client.enableStatusRequestExtension': project.property('client.enableStatusRequestExtension'),
                        'jdk.tls.client.protocols': project.property('client.protocols')
                )
            }
        }

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

configure(javaCodeCheckedProjects) {
    apply plugin: 'checkstyle'
    apply plugin: "com.github.spotbugs"
    apply plugin: 'jacoco'
    apply plugin: 'groovy'
    apply plugin: 'codenarc'
    apply plugin: 'com.adarshr.test-logger'

    dependencies {
        testImplementation(platform("org.junit:junit-bom:$junitBomVersion"))
        testImplementation('org.junit.jupiter:junit-jupiter')
        testImplementation('org.junit.vintage:junit-vintage-engine')

        testImplementation platform('org.spockframework:spock-bom:2.0-M3-groovy-2.5')
        testImplementation 'org.spockframework:spock-core'
        testImplementation 'org.spockframework:spock-junit4'
        testImplementation("org.mockito:mockito-core:3.8.0")
        testImplementation 'cglib:cglib-nodep:2.2.2'
        testImplementation 'org.objenesis:objenesis:1.3'
        testImplementation 'org.hamcrest:hamcrest-all:1.3'
        testImplementation 'ch.qos.logback:logback-classic:1.1.1'
        testImplementation project(':util') //Adding categories to classpath
    }

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

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

        useJUnitPlatform {
            includeEngines('junit-jupiter', 'junit-vintage', 'spock')
            excludeTags('Slow')
        }
        systemProperty('spock.configuration', "${configDir}/spock/ExcludeSlow.groovy")

        jacoco { enabled = false }

        testLogging {
            exceptionFormat = 'full'
            events("passed", "skipped", "failed")
        }

        testlogger {
            theme 'standard'
            showExceptions false
            showStackTraces false
            showFullStackTraces false
        }
    }

    task testSlowOnly(type: Test) {
        useJUnitPlatform {
            includeEngines('junit-jupiter', 'junit-vintage', 'spock')
            includeTags('Slow')
        }
        systemProperty('spock.configuration', "${configDir}/spock/OnlySlow.groovy")
    }

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

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

    spotbugsMain {
        reports {
            xml.enabled = project.buildingWith('xmlReports.enabled')
            html.enabled = !project.buildingWith('xmlReports.enabled')
        }
    }

    spotbugsTest {
        enabled = false
    }

    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'

//////////////////////////////////////////
// Root project configuration           //
//////////////////////////////////////////
wrapper {
    gradleVersion = '6.0.1'
}

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