build.gradle

import org.gradle.util.VersionNumber

buildscript {
    ext.android_tools = 'com.android.tools.build:gradle:3.5.0'
    ext.errorproneVersion = '2.3.3'
    ext.errorproneJavacVersion = '9+181-r4173-1'
    repositories {
        google()
        jcenter()
    }
    dependencies {
        // This must be applied in the root project otherwise each subproject will
        // have it in a different ClassLoader.
        classpath android_tools
        classpath 'biz.aQute.bnd:biz.aQute.bnd.gradle:4.3.0'
    }
}

plugins {
    // Add dependency for build script so we can access Git from our
    // build script.
    id 'org.ajoberstar.grgit' version '3.1.1'
    id 'net.ltgt.errorprone' version '1.1.1'
}

subprojects {
    def androidProject = ((project.name == 'conscrypt-android')
            || (project.name == 'conscrypt-android-platform')
            || (project.name == 'conscrypt-benchmark-android')
            || (project.name == 'conscrypt-benchmark-caliper'))
    if (androidProject) {
        repositories {
            google()
        }
    } else {
        apply plugin: 'java-library'
        apply plugin: 'cpp'

        model {
            toolChains {
                visualCpp(VisualCpp)
                // Prefer Clang over Gcc (order here matters!)
                clang(Clang)
                gcc(Gcc)
            }
        }
    }
    apply plugin: "idea"
    apply plugin: "jacoco"
    apply plugin: "net.ltgt.errorprone"

    group = "org.conscrypt"
    description = 'Conscrypt is an alternate Java Security Provider that uses BoringSSL'
    version = "2.5.0-SNAPSHOT"

    ext {
        os = org.gradle.internal.os.OperatingSystem.current();
        if (os.isLinux()) {
            osName = "linux"
        } else if (os.isMacOsX()) {
            osName = "osx"
        } else if (os.isWindows()) {
            osName = "windows"
        } else {
            throw new GradleException("Unsupported os: " + os.name)
        }

        if (project.hasProperty("boringsslHome")) {
            boringsslHome = project.property("boringsslHome")
        } else {
            boringsslHome = "$System.env.BORINGSSL_HOME"
        }

        boringsslIncludeDir = normalizePath("$boringsslHome/include")
        boringssl32BuildDir = normalizePath("$boringsslHome/build32")
        boringssl64BuildDir = normalizePath("$boringsslHome/build64")

        if (project.hasProperty("jdkHome")) {
            jdkHome = project.property("jdkHome")
        } else {
            jdkHome = "$System.env.JAVA_HOME"
        }
        jdkIncludeDir = normalizePath("$jdkHome/include")
        // Needs to be binary compatible with androidMinSdkVersion
        androidMinJavaVersion = JavaVersion.VERSION_1_7

        build32Bit = file("$boringssl32BuildDir").exists()
        build64Bit = file("$boringssl64BuildDir").exists()

        // Ensure the environment is configured properly.
        assert file("$boringsslHome").exists()
        assert file("$boringsslIncludeDir").exists()
        assert build32Bit || build64Bit
        assert file("$jdkHome").exists()
        assert file("$jdkIncludeDir").exists()

        // Get the commit hash for BoringSSL.
        boringSslGit = org.ajoberstar.grgit.Grgit.open(dir: boringsslHome)
        boringSslVersion = boringSslGit.head().id

        // Allow the java executable to be specified via env/property for each architecture.
        javaExecutable32 = System.getProperty('javaExecutable32', System.env.CONSCRYPT_JAVA_EXECUTABLE_32)
        javaExecutable64 = System.getProperty('javaExecutable64', System.env.CONSCRYPT_JAVA_EXECUTABLE_64)

        jmhVersion = '1.21'
        libraries = [
                android_tools: android_tools,
                roboelectric: 'org.robolectric:android-all:7.1.0_r7-robolectric-0',

                // Test dependencies.
                bouncycastle_apis: 'org.bouncycastle:bcpkix-jdk15on:1.63',
                bouncycastle_provider: 'org.bouncycastle:bcprov-jdk15on:1.63',
                junit  : 'junit:junit:4.12',
                mockito: 'org.mockito:mockito-core:2.28.2',
                truth  : 'com.google.truth:truth:1.0',

                // Benchmark dependencies
                jmh_core: "org.openjdk.jmh:jmh-core:${jmhVersion}",
                jmh_generator_annprocess: "org.openjdk.jmh:jmh-generator-annprocess:${jmhVersion}",
                jmh_generator_asm: "org.openjdk.jmh:jmh-generator-asm:${jmhVersion}",
                jmh_generator_bytecode: "org.openjdk.jmh:jmh-generator-bytecode:${jmhVersion}",
                jmh_generator_reflection: "org.openjdk.jmh:jmh-generator-reflection:${jmhVersion}",
                netty_handler: 'io.netty:netty-handler:4.1.24.Final',
                netty_tcnative: 'io.netty:netty-tcnative-boringssl-static:2.0.26.Final',
        ]

        signJar = { jarPath ->
            if (rootProject.hasProperty('signingKeystore') && rootProject.hasProperty('signingPassword')) {
                def command = 'jarsigner -keystore ' + rootProject.signingKeystore +
                        ' -storepass ' + rootProject.signingPassword +
                        ' ' + jarPath + ' signingcert'
                def process = command.execute()
                process.waitFor()
                if (process.exitValue()) {
                    throw new GradleException('Jar signing failed for ' + jarPath + ': ' + process.text)
                }
            }
        }
    }

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

    jacoco {
        toolVersion = "0.8.4"
    }

    dependencies {
        errorprone("com.google.errorprone:error_prone_core:$errorproneVersion")
        errorproneJavac("com.google.errorprone:javac:$errorproneJavacVersion")
    }

    task generateProperties(type: WriteProperties) {
        ext {
            parsedVersion = VersionNumber.parse(version)
        }
        property("org.conscrypt.version.major", parsedVersion.getMajor())
        property("org.conscrypt.version.minor", parsedVersion.getMinor())
        property("org.conscrypt.version.patch", parsedVersion.getMicro())
        property("org.conscrypt.boringssl.version", boringSslVersion)
        outputFile "build/generated/resources/org/conscrypt/conscrypt.properties"
    }

    if (!androidProject) {
        sourceCompatibility = JavaVersion.VERSION_1_7
        targetCompatibility = JavaVersion.VERSION_1_7

        [compileJava, compileTestJava].each() {
            it.options.compilerArgs += ["-Xlint:all", "-Xlint:-options", '-Xmaxwarns', '9999999']
            it.options.encoding = "UTF-8"
            if (rootProject.hasProperty('failOnWarnings') && rootProject.failOnWarnings.toBoolean()) {
                it.options.compilerArgs += ["-Werror"]
            }
        }

        compileTestJava {
            // serialVersionUID is basically guaranteed to be useless in our tests
            options.compilerArgs += ["-Xlint:-serial"]
        }

        jar.manifest {
            attributes('Implementation-Title': name,
                    'Implementation-Version': version,
                    'Built-By': System.getProperty('user.name'),
                    'Built-JDK': System.getProperty('java.version'),
                    'Source-Compatibility': sourceCompatibility,
                    'Target-Compatibility': targetCompatibility)
        }

        javadoc.options {
            encoding = 'UTF-8'
            links 'https://docs.oracle.com/javase/8/docs/api/'
        }

        // Disable JavaDoc doclint on Java 8. It's annoying.
        if (JavaVersion.current().isJava8Compatible()) {
            allprojects {
                tasks.withType(Javadoc) {
                    options.addStringOption('Xdoclint:none', '-quiet')
                }
            }
        }

        task javadocJar(type: Jar) {
            classifier = 'javadoc'
            from javadoc
        }

        task sourcesJar(type: Jar) {
            classifier = 'sources'
            from sourceSets.main.allSource
        }

        // At a test failure, log the stack trace to the console so that we don't
        // have to open the HTML in a browser.
        test {
            testLogging {
                exceptionFormat = 'full'
                showExceptions true
                showCauses true
                showStackTraces true
                showStandardStreams = true
            }
            // Enable logging for all conscrypt classes while running tests.
            systemProperty 'java.util.logging.config.file', "${rootDir}/test_logging.properties"
            maxHeapSize = '1500m'

            // Override the default executable if manually specified
            if (build64Bit && javaExecutable64 != null) {
                executable javaExecutable64
            } else if (build32Bit && javaExecutable32 != null) {
                executable javaExecutable32
            }
        }
    }
}

static String normalizePath(path) {
    new File(path.toString()).absolutePath
}