478 lines
17 KiB
Groovy
478 lines
17 KiB
Groovy
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("-", "_")
|
|
}
|
|
|