build.gradle

import org.ajoberstar.grgit.Grgit
import org.gradle.util.VersionNumber

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

plugins {
    // Add dependency for build script so we can access Git from our
    // build script.
    id 'org.ajoberstar.grgit' version '5.0.0'
    id 'net.ltgt.errorprone' version '1.3.0'
    id "com.google.osdetector" version "1.7.3"
    id "biz.aQute.bnd.builder" version "6.4.0" apply false
}

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) {
                    // Gradle 7.x still seems to get confused about toolchains on Mac
                    // so explicitly add -arch args.
                    target("osx_aarch64") {
                        cppCompiler.withArguments { args ->
                            args << "-arch" << "arm64"
                        }
                        linker.withArguments { args ->
                            args << "-arch" << "arm64"
                        }
                    }
                    target("osx_x86-64") {
                        cppCompiler.withArguments { args ->
                            args << "-arch" << "x86_64"
                        }
                        linker.withArguments { args ->
                            args << "-arch" << "x86_64"
                        }
                    }
                }
                gcc(Gcc)
            }
        }
    }
    apply plugin: "idea"
    apply plugin: "jacoco"
    apply plugin: "net.ltgt.errorprone"

    group = "net.tongsuo"
    description = 'Tongsuo Provider is an alternate Java Security Provider that uses Tongsuo'
    version = "1.0.1"

    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("tongsuoHome")) {
            tongsuoHome = project.property("tongsuoHome")
        } else {
            tongsuoHome = "$System.env.TONGSUO_HOME"
        }

        tongsuoIncludeDir = normalizePath("$tongsuoHome/include")
        tongsuoLibDir = normalizePath("$tongsuoHome/lib")

        // Needs to be binary compatible with androidMinSdkVersion
        androidMinJavaVersion = JavaVersion.VERSION_1_8

        // Ensure the environment is configured properly.
        assert file("$tongsuoHome").exists()
        assert file("$tongsuoIncludeDir").exists()
        assert file("$tongsuoLibDir").exists()

        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.13.2',
                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 RuntimeException('Jar signing failed for ' + jarPath + ': ' + process.text)
                }
            }
        }
    }

    repositories {
        mavenCentral()
        mavenLocal()
    }

    jacoco {
        toolVersion = "0.8.4"
    }

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

    tasks.register("generateProperties", 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) {
        java {
            toolchain {
                // Compile with a real JDK 8 so we don't end up with accidental dependencies
                // on Java 11 bootclasspath, e.g. ByteBuffer.flip().
                languageVersion = JavaLanguageVersion.of(11)
            }
        }

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

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

        tasks.named("jar").configure {
            manifest {
                attributes('Implementation-Title': name,
                        'Implementation-Version': archiveVersion,
                        '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/'
        }

        // All non-Android projects build with Java 8, so disable doclint as it's noisy.
        allprojects {
            tasks.withType(Javadoc) {
                options.addStringOption('Xdoclint:none', '-quiet')
            }
        }

        tasks.register("javadocJar", Jar) {
            classifier = 'javadoc'
            from javadoc
        }

        tasks.register("sourcesJar", 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'
        }
    }
}

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