conscrypt/openjdk/build.gradle

plugins {
    id 'com.github.johnrengelman.shadow' version '6.0.0'
}

import aQute.bnd.gradle.BundleTaskConvention
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import org.codehaus.groovy.runtime.InvokerHelper

apply plugin: 'biz.aQute.bnd.builder'

description = 'Conscrypt: OpenJdk'

ext {
    jniSourceDir = "$rootDir/common/src/jni"
    assert file("$jniSourceDir").exists()

    // Build the list of classifiers that will be used in the build.
    arch32Name = 'x86'
    arch64Name = 'x86_64'
    nativeClassifiers = []
    nativeClassifier64Bit = null
    nativeClassifier32Bit = null
    preferredClassifier = null
    preferredSourceSet = null
    preferredNativeFileDir = null
    if (build64Bit) {
        // Add the 64-Bit classifier first, as the preferred classifier.
        nativeClassifier64Bit = classifierFor(osName, arch64Name)
        nativeClassifiers += nativeClassifier64Bit
        preferredClassifier = nativeClassifier64Bit
        preferredSourceSet = sourceSetName(preferredClassifier)
        preferredNativeFileDir = nativeResourcesDir(preferredClassifier)
    }
    if (build32Bit) {
        nativeClassifier32Bit = classifierFor(osName, arch32Name)
        nativeClassifiers += nativeClassifier32Bit
        if (preferredClassifier == null) {
            preferredClassifier = nativeClassifier32Bit
            preferredSourceSet = sourceSetName(preferredClassifier)
            preferredNativeFileDir = nativeResourcesDir(preferredClassifier)
        }
    }
}

sourceSets {

    main {
        java {
            srcDirs += "${rootDir}/common/src/main/java"
            srcDirs += project(':conscrypt-constants').sourceSets.main.java.srcDirs
        }
        resources {
            srcDirs += "build/generated/resources"
        }
    }

    platform {
        java {
            srcDirs = [ "src/main/java" ]
            includes = [ "org/conscrypt/Platform.java" ]
        }
    }

    test {
        java {
            srcDirs += "${rootDir}/common/src/test/java"
        }
        resources {
            srcDirs += "${rootDir}/common/src/test/resources"
            // This shouldn't be needed but seems to help IntelliJ locate the native artifact.
            srcDirs += preferredNativeFileDir
        }
    }

    // Add the source sets for each of the native build
    nativeClassifiers.each { nativeClassifier ->
        def sourceSetName = sourceSetName(nativeClassifier)

        // Main sources for the native build
        "$sourceSetName" {
            output.dir(nativeResourcesDir(nativeClassifier), builtBy: "copyNativeLib${sourceSetName}")
        }
    }
}

compileJava {
    dependsOn generateProperties
}

tasks.register("platformJar", Jar) {
    from sourceSets.platform.output
}

tasks.register("testJar", ShadowJar) {
    classifier = 'tests'
    configurations = [project.configurations.testRuntime]
    from sourceSets.test.output
}

if (isExecutableOnPath('cpplint')) {
    def cpplint = tasks.register("cpplint", Exec) {
        executable = 'cpplint'

        // TODO(nmittler): Is there a better way of getting the JNI sources?
        def pattern = ['**/*.cc', '**/*.h']
        def sourceFiles = fileTree(dir: jniSourceDir, includes: pattern).asPath.tokenize(':')
        // Adding roots so that class #ifdefs don't require full path from the project root.
        args = sourceFiles

        // Capture stderr from the process
        errorOutput = new ByteArrayOutputStream();

        // Need to ignore exit value so that doLast will execute.
        ignoreExitValue = true

        doLast {
            // Create the report file.
            def reportDir = file("${buildDir}/cpplint")
            reportDir.mkdirs();
            def reportFile = new File(reportDir, "report.txt")
            def reportStream = new FileOutputStream(reportFile)

            try {
                // Check for failure
                if (execResult != null) {
                    execResult.assertNormalExitValue()
                }
            } catch (Exception e) {
                // The process failed - get the error report from the stderr.
                String report = errorOutput.toString();

                // Write the report to the console.
                System.err.println(report)

                // Also write the report file.
                reportStream.write(report.bytes);

                // Extension method cpplint.output() can be used to obtain the report
                ext.output = {
                    return report
                }

                // Rethrow the exception to terminate the build.
                throw e;
            } finally {
                reportStream.close();
            }
        }
    }
    check.dependsOn cpplint
}

configurations {
    publicApiDocs
    platform
}

artifacts {
    platform platformJar
}

apply from: "$rootDir/gradle/publishing.gradle"
publishing.publications.maven {
    artifact sourcesJar
    artifact javadocJar
}

jar.manifest {
    attributes ('BoringSSL-Version' : boringSslVersion,
                'Automatic-Module-Name' : 'org.conscrypt',
                'Bundle-SymbolicName': 'org.conscrypt',
                '-exportcontents': 'org.conscrypt.*')
}

dependencies {
    // This is used for the @Internal annotation processing in JavaDoc
    publicApiDocs project(':conscrypt-api-doclet')

    // This is listed as compile-only, but we absorb its contents.
    compileOnly project(':conscrypt-constants')

    testCompile project(':conscrypt-constants'),
            project(path: ':conscrypt-testing', configuration: 'runtime'),
            libraries.junit,
            libraries.mockito

    testRuntimeClasspath sourceSets["$preferredSourceSet"].output

    platformCompileOnly sourceSets.main.output
}

nativeClassifiers.each { nativeClassifier ->
    // Create the JAR task and add it's output to the published archives for this project
    addNativeJar(nativeClassifier)

    // Build the classes as part of the standard build.
    classes.dependsOn sourceSet(nativeClassifier).classesTaskName
}

// Adds a JAR task for the native library.
def addNativeJar(nativeClassifier) {
    // Create a JAR for this configuration and add it to the output archives.
    SourceSet sourceSet = sourceSet(nativeClassifier)
    def jarTask = tasks.register(sourceSet.jarTaskName, Jar) { Jar t ->
        // Depend on the regular classes task
        dependsOn classes
        manifest = jar.manifest
        classifier = nativeClassifier

        from sourceSet.output + sourceSets.main.output

        // add OSGI headers
        t.convention.plugins.bundle = new BundleTaskConvention(t)
        t.doLast {
            t.buildBundle()
        }
    }

    // Add the jar task to the standard build.
    jar.dependsOn jarTask

    // Add it to the publishing archives list.
    publishing.publications.maven.artifact jarTask.get()
}


// Check which version
def javaError = new ByteArrayOutputStream()
exec {
    executable test.executable
    System.out.println("Running tests with java executable: " + test.executable + ".")
    args = ['-version']
    ignoreExitValue true
    errorOutput = javaError
}

def suiteClass = (javaError.toString() =~ /"1[.]7[.].*"/) ?
        "org/conscrypt/ConscryptJava7Suite.class" : "org/conscrypt/ConscryptSuite.class";

test {
    include suiteClass, "org/conscrypt/ConscryptOpenJdkSuite.class"
}

def testFdSocket = tasks.register("testFdSocket", Test) {
    include suiteClass, "org/conscrypt/ConscryptOpenJdkSuite.class"
    InvokerHelper.setProperties(testLogging, test.testLogging.properties)
    systemProperties = test.systemProperties
    systemProperty "org.conscrypt.useEngineSocketByDefault", false
}
check.dependsOn testFdSocket

// Tests that involve interoperation with the OpenJDK TLS provider (generally to
// test renegotiation, since we don't support initiating renegotiation but do
// support peer-initiated renegotiation).  The JDK TLS provider doesn't work
// if Conscrypt is installed as the default provider, so these need to live in
// a different task than the other tests, most of which need Conscrypt to be
// installed to function.
def testInterop = tasks.register("testInterop", Test) {
    include "org/conscrypt/ConscryptEngineTest.class"
    include "org/conscrypt/RenegotiationTest.class"
}
check.dependsOn testInterop

jacocoTestReport {
    additionalSourceDirs.from files("$rootDir/openjdk/src/test/java", "$rootDir/common/src/main/java")
    executionData tasks.withType(Test)
}

javadoc {
    dependsOn(configurations.publicApiDocs)
    options.doclet = "org.conscrypt.doclet.FilterDoclet"
    options.docletpath = configurations.publicApiDocs.files as List
}

model {
    platforms {
        x86 {
            architecture arch32Name
        }
        x86_64 {
            architecture arch64Name
        }
    }

    buildTypes {
        release
    }

    components {
        // Builds the JNI library.
        conscrypt_openjdk_jni(NativeLibrarySpec) {
            if (build32Bit) { targetPlatform arch32Name }
            if (build64Bit) { targetPlatform arch64Name }

            sources {
                cpp {
                    source {
                        srcDirs "$jniSourceDir/main/cpp"
                        include "**/*.cc"
                    }
                }
            }

            binaries {
                // Build the JNI lib as a shared library.
                withType (SharedLibraryBinarySpec) {
                    cppCompiler.define "CONSCRYPT_OPENJDK"

                    // Set up 32-bit vs 64-bit build
                    def building64Bit = false
                    def libPath
                    if (targetPlatform.getArchitecture().getName() == "x86") {
                        libPath = "$boringssl32BuildDir"
                    } else if (targetPlatform.getArchitecture().getName() == "x86-64") {
                        libPath = "$boringssl64BuildDir"
                        building64Bit = true
                    } else {
                        throw new GradleException("Unknown architecture: " +
                                targetPlatform.getArchitecture().name)
                    }

                    if (toolChain in Clang || toolChain in Gcc) {
                        cppCompiler.args "-Wall",
                                "-fPIC",
                                "-O3",
                                "-std=c++11",
                                "-I$jniSourceDir/main/include",
                                "-I$jniSourceDir/unbundled/include",
                                "-I$boringsslIncludeDir",
                                "-I$jdkIncludeDir",
                                "-I$jdkIncludeDir/linux",
                                "-I$jdkIncludeDir/darwin",
                                "-I$jdkIncludeDir/win32"
                        if (rootProject.hasProperty('checkErrorQueue')) {
                            System.out.println("Compiling with error queue checking enabled")
                            cppCompiler.define "CONSCRYPT_CHECK_ERROR_QUEUE"
                        }

                        // Static link to BoringSSL
                        linker.args "-O3",
                                "-fvisibility=hidden",
                                "-lpthread",
                                libPath + "/ssl/libssl.a",
                                libPath + "/crypto/libcrypto.a"
                        if (targetPlatform.operatingSystem.isLinux()) {
                            // Static link libstdc++ and libgcc because
                            // they are not available in some restrictive Linux
                            // environments.
                            linker.args "-static-libstdc++",
                                    "-static-libgcc"
                        } else {
                            linker.args "-lstdc++"
                        }
                    } else if (toolChain in VisualCpp) {
                        cppCompiler.define "DLL_EXPORT"
                        cppCompiler.define "WIN32_LEAN_AND_MEAN"
                        cppCompiler.define "NOMINMAX"
                        if (building64Bit) {
                            cppCompiler.define "WIN64"
                        }
                        cppCompiler.define "_WINDOWS"
                        cppCompiler.define "UNICODE"
                        cppCompiler.define "_UNICODE"
                        cppCompiler.define "NDEBUG"

                        cppCompiler.args "/nologo",
                                "/MT",
                                "/WX-",
                                "/Wall",
                                "/O2",
                                "/Oi",
                                "/Ot",
                                "/GL",
                                "/GS",
                                "/Gy",
                                "/fp:precise",
                                "-wd4514", // Unreferenced inline function removed
                                "-wd4548", // Expression before comma has no effect
                                "-wd4625", // Copy constructor was implicitly defined as deleted
                                "-wd4626", // Assignment operator was implicitly defined as deleted
                                "-wd4710", // function not inlined
                                "-wd4711", // function inlined
                                "-wd4820", // Extra padding added to struct
                                "-wd4946", // reinterpret_cast used between related classes:
                                "-wd4996", // Thread safety for strerror
                                "-wd5027", // Move assignment operator was implicitly defined as deleted
                                "-I$jniSourceDir/main/include",
                                "-I$jniSourceDir/unbundled/include",
                                "-I$boringsslIncludeDir",
                                "-I$jdkIncludeDir",
                                "-I$jdkIncludeDir/win32"

                        // Static link to BoringSSL
                        linker.args "-WX",
                                "ws2_32.lib",
                                "advapi32.lib",
                                "${libPath}\\ssl\\ssl.lib",
                                "${libPath}\\crypto\\crypto.lib"
                    }
                }

                // Never build a static library.
                withType(StaticLibraryBinarySpec) {
                    buildable = false
                }
            }
        }
    }

    tasks { t ->
        $.binaries.withType(SharedLibraryBinarySpec).each { binary ->
            // Build the native artifact classifier from the OS and architecture.
            def archName = binary.targetPlatform.architecture.name.replaceAll('-', '_')
            def classifier = classifierFor(osName, archName)
            def sourceSetName = sourceSetName("$classifier")
            def source = binary.sharedLibraryFile

            // Copies the native library to a resource location that will be included in the jar.
            def copyTask = project.tasks.register("copyNativeLib${sourceSetName}", Copy) {
                dependsOn binary.tasks.link
                from source
                // Rename the artifact to include the generated classifier
                rename '(.+)(\\.[^\\.]+)', "\$1-$classifier\$2"
                // Everything under will be included in the native jar.
                into nativeResourcesDir(classifier) + '/META-INF/native'
            }

            // Now define a task to strip the release binary (linux only)
            if (osName == 'linux' && (!rootProject.hasProperty('nostrip') ||
                    !rootProject.nostrip.toBoolean())) {
                def stripTask = binary.tasks.taskName("strip")
                project.tasks.register(stripTask as String, Exec) {
                    dependsOn binary.tasks.link
                    executable "strip"
                    args binary.tasks.link.linkedFile.asFile.get()
                }
                copyTask.configure {
                    dependsOn stripTask
                }
            }
        }
    }
}

boolean isExecutableOnPath(executable) {
    FilenameFilter filter = new FilenameFilter() {
        @Override
        boolean accept(File dir, String name) {
            return executable.equals(name);
        }
    }
    for(String folder : System.getenv('PATH').split("" + File.pathSeparatorChar)) {
        File[] files = file(folder).listFiles(filter)
        if (files != null && files.size() > 0) {
            return true;
        }
    }
    return false;
}

String nativeResourcesDir(nativeClassifier) {
    def sourceSetName = sourceSetName(nativeClassifier)
    "${buildDir}/${sourceSetName}/native-resources"
}

SourceSet sourceSet(classifier) {
    sourceSets[sourceSetName(classifier)]
}

static String classifierFor(osName, archName) {
    "${osName}-${archName}"
}

static String sourceSetName(classifier) {
    classifier.replaceAll("-", "_")
}