mirror of https://github.com/grpc/grpc-java.git
323 lines
11 KiB
Groovy
323 lines
11 KiB
Groovy
plugins {
|
|
id "cpp"
|
|
id "java"
|
|
id "maven-publish"
|
|
|
|
id "com.google.protobuf"
|
|
}
|
|
|
|
description = 'The protoc plugin for gRPC Java'
|
|
|
|
def artifactStagingPath = "$buildDir/artifacts" as File
|
|
// Adds space-delimited arguments from the environment variable env to the
|
|
// argList.
|
|
def addEnvArgs = { env, argList ->
|
|
def value = System.getenv(env)
|
|
if (value != null) {
|
|
value.split(' +').each() { it -> argList.add(it) }
|
|
}
|
|
}
|
|
|
|
// Adds corresponding "-l" option to the argList if libName is not found in
|
|
// LDFLAGS. This is only used for Mac because when building for uploadArchives
|
|
// artifacts, we add the ".a" files directly to LDFLAGS and without "-l" in
|
|
// order to get statically linked, otherwise we add the libraries through "-l"
|
|
// so that they can be searched for in default search paths.
|
|
def addLibraryIfNotLinked = { libName, argList ->
|
|
def ldflags = System.env.LDFLAGS
|
|
if (ldflags == null || !ldflags.contains('lib' + libName + '.a')) {
|
|
argList.add('-l' + libName)
|
|
}
|
|
}
|
|
|
|
def String arch = rootProject.hasProperty('targetArch') ? rootProject.targetArch : osdetector.arch
|
|
def boolean vcDisable = rootProject.hasProperty('vcDisable') ? rootProject.vcDisable : false
|
|
def boolean usingVisualCpp // Whether VisualCpp is actually available and selected
|
|
|
|
model {
|
|
toolChains {
|
|
// If you have both VC and Gcc installed, VC will be selected, unless you
|
|
// set 'vcDisable=true'
|
|
if (!vcDisable) {
|
|
visualCpp(VisualCpp) {
|
|
// Prefer vcvars-provided environment over registry-discovered environment
|
|
def String vsDir = System.getenv("VSINSTALLDIR")
|
|
def String winDir = System.getenv("WindowsSdkDir")
|
|
if (vsDir != null && winDir != null) {
|
|
installDir = vsDir
|
|
windowsSdkDir = winDir
|
|
}
|
|
}
|
|
}
|
|
gcc(Gcc) {
|
|
target("ppcle_64") {
|
|
cppCompiler.executable = 'powerpc64le-linux-gnu-g++'
|
|
linker.executable = 'powerpc64le-linux-gnu-g++'
|
|
}
|
|
target("aarch_64") {
|
|
cppCompiler.executable = 'aarch64-linux-gnu-g++'
|
|
linker.executable = 'aarch64-linux-gnu-g++'
|
|
}
|
|
target("s390_64") {
|
|
cppCompiler.executable = 's390x-linux-gnu-g++'
|
|
linker.executable = 's390x-linux-gnu-g++'
|
|
}
|
|
target("loongarch_64")
|
|
}
|
|
clang(Clang) {
|
|
target("aarch_64") {}
|
|
}
|
|
}
|
|
|
|
platforms {
|
|
x86_32 { architecture "x86" }
|
|
x86_64 { architecture "x86_64" }
|
|
ppcle_64 { architecture "ppcle_64" }
|
|
aarch_64 { architecture "aarch_64" }
|
|
s390_64 { architecture "s390_64" }
|
|
loongarch_64 { architecture "loongarch_64" }
|
|
}
|
|
|
|
components {
|
|
java_plugin(NativeExecutableSpec) {
|
|
if (arch in [
|
|
'x86_32',
|
|
'x86_64',
|
|
'ppcle_64',
|
|
'aarch_64',
|
|
's390_64',
|
|
'loongarch_64'
|
|
]) {
|
|
// If arch is not within the defined platforms, we do not specify the
|
|
// targetPlatform so that Gradle will choose what is appropriate.
|
|
targetPlatform arch
|
|
}
|
|
baseName "$protocPluginBaseName"
|
|
}
|
|
}
|
|
|
|
binaries {
|
|
all {
|
|
if (toolChain in Gcc || toolChain in Clang) {
|
|
cppCompiler.define("GRPC_VERSION", version)
|
|
cppCompiler.args "--std=c++0x"
|
|
addEnvArgs("CXXFLAGS", cppCompiler.args)
|
|
addEnvArgs("CPPFLAGS", cppCompiler.args)
|
|
if (osdetector.os == "osx") {
|
|
cppCompiler.args "-mmacosx-version-min=10.7", "-stdlib=libc++"
|
|
addLibraryIfNotLinked('protoc', linker.args)
|
|
addLibraryIfNotLinked('protobuf', linker.args)
|
|
} else if (osdetector.os == "windows") {
|
|
linker.args "-static", "-lprotoc", "-lprotobuf", "-static-libgcc", "-static-libstdc++",
|
|
"-s"
|
|
} else if (osdetector.arch == "ppcle_64") {
|
|
linker.args "-Wl,-Bstatic", "-lprotoc", "-lprotobuf", "-Wl,-Bdynamic", "-lpthread", "-s"
|
|
} else {
|
|
// Link protoc, protobuf, libgcc and libstdc++ statically.
|
|
// Link other (system) libraries dynamically.
|
|
// Clang under OSX doesn't support these options.
|
|
linker.args "-Wl,-Bstatic", "-lprotoc", "-lprotobuf", "-static-libgcc",
|
|
"-Wl,-Bdynamic", "-lpthread", "-s"
|
|
}
|
|
addEnvArgs("LDFLAGS", linker.args)
|
|
} else if (toolChain in VisualCpp) {
|
|
usingVisualCpp = true
|
|
cppCompiler.define("GRPC_VERSION", version)
|
|
cppCompiler.args "/EHsc", "/MT"
|
|
if (rootProject.hasProperty('vcProtobufInclude')) {
|
|
cppCompiler.args "/I${rootProject.vcProtobufInclude}"
|
|
}
|
|
linker.args "libprotobuf.lib", "libprotoc.lib"
|
|
if (rootProject.hasProperty('vcProtobufLibs')) {
|
|
linker.args "/LIBPATH:${rootProject.vcProtobufLibs}"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sourceSets {
|
|
testLite {
|
|
proto { setSrcDirs(['src/test/proto']) }
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
testImplementation project(':grpc-protobuf'),
|
|
project(':grpc-stub'),
|
|
libraries.javax.annotation
|
|
testLiteImplementation project(':grpc-protobuf-lite'),
|
|
project(':grpc-stub'),
|
|
libraries.javax.annotation
|
|
}
|
|
|
|
tasks.named("compileTestJava").configure {
|
|
options.errorprone.excludedPaths = ".*/build/generated/source/proto/.*"
|
|
}
|
|
|
|
tasks.named("compileTestLiteJava").configure {
|
|
options.compilerArgs = compileTestJava.options.compilerArgs
|
|
options.compilerArgs += [
|
|
"-Xlint:-cast"
|
|
]
|
|
options.errorprone.excludedPaths = ".*/build/generated/source/proto/.*"
|
|
}
|
|
|
|
tasks.named("checkstyleTestLite").configure {
|
|
enabled = false
|
|
}
|
|
|
|
protobuf {
|
|
protoc {
|
|
if (project.hasProperty('protoc')) {
|
|
path = project.protoc
|
|
} else {
|
|
artifact = libs.protobuf.protoc.get()
|
|
}
|
|
}
|
|
plugins {
|
|
grpc { path = javaPluginPath }
|
|
}
|
|
generateProtoTasks {
|
|
all().configureEach {
|
|
dependsOn 'java_pluginExecutable'
|
|
inputs.file javaPluginPath
|
|
}
|
|
ofSourceSet('test').configureEach {
|
|
plugins { grpc {} }
|
|
}
|
|
ofSourceSet('testLite').configureEach {
|
|
builtins {
|
|
java { option 'lite' }
|
|
}
|
|
plugins {
|
|
grpc {
|
|
option 'lite'
|
|
option '@generated=omit'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
println "*** Building codegen requires Protobuf"
|
|
println "*** Please refer to https://github.com/grpc/grpc-java/blob/master/COMPILING.md#how-to-build-code-generation-plugin"
|
|
|
|
tasks.register("buildArtifacts", Copy) {
|
|
dependsOn 'java_pluginExecutable'
|
|
from("$buildDir/exe") {
|
|
if (osdetector.os != 'windows') {
|
|
rename 'protoc-gen-grpc-java', '$0.exe'
|
|
}
|
|
}
|
|
into artifactStagingPath
|
|
}
|
|
|
|
base {
|
|
archivesName = "$protocPluginBaseName"
|
|
}
|
|
|
|
def checkArtifacts = tasks.register("checkArtifacts") {
|
|
dependsOn buildArtifacts
|
|
doLast {
|
|
if (!usingVisualCpp) {
|
|
def ret = exec {
|
|
executable 'bash'
|
|
args 'check-artifact.sh', osdetector.os, arch
|
|
}
|
|
if (ret.exitValue != 0) {
|
|
throw new GradleException("check-artifact.sh exited with " + ret.exitValue)
|
|
}
|
|
} else {
|
|
def exeName = "$artifactStagingPath/java_plugin/${protocPluginBaseName}.exe"
|
|
def os = new ByteArrayOutputStream()
|
|
def ret = exec {
|
|
executable 'dumpbin'
|
|
args '/nologo', '/dependents', exeName
|
|
standardOutput = os
|
|
}
|
|
if (ret.exitValue != 0) {
|
|
throw new GradleException("dumpbin exited with " + ret.exitValue)
|
|
}
|
|
def dlls = os.toString() =~ /Image has the following dependencies:\s+(.*)\s+Summary/
|
|
if (dlls[0][1] != "KERNEL32.dll") {
|
|
throw new Exception("unexpected dll deps: " + dlls[0][1]);
|
|
}
|
|
os.reset()
|
|
ret = exec {
|
|
executable 'dumpbin'
|
|
args '/nologo', '/headers', exeName
|
|
standardOutput = os
|
|
}
|
|
if (ret.exitValue != 0) {
|
|
throw new GradleException("dumpbin exited with " + ret.exitValue)
|
|
}
|
|
def machine = os.toString() =~ / machine \(([^)]+)\)/
|
|
def expectedArch = [x86_32: "x86", x86_64: "x64"][arch]
|
|
if (machine[0][1] != expectedArch) {
|
|
throw new Exception("unexpected architecture: " + machine[0][1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Exe files are skipped by Maven by default. Override it.
|
|
// Also skip jar files that is generated by the java plugin.
|
|
publishing {
|
|
publications {
|
|
maven(MavenPublication) {
|
|
// Removes all artifacts since grpc-compiler doesn't generates any Jar
|
|
artifacts = []
|
|
artifactId 'protoc-gen-grpc-java'
|
|
artifact("$artifactStagingPath/java_plugin/${protocPluginBaseName}.exe" as File) {
|
|
classifier osdetector.os + "-" + arch
|
|
extension "exe"
|
|
builtBy checkArtifacts
|
|
}
|
|
pom.withXml {
|
|
// This isn't any sort of Java archive artifact, and OSSRH doesn't enforce
|
|
// javadoc for 'pom' packages. 'exe' would be a more appropriate packaging
|
|
// value, but it isn't clear how that will be interpreted. In addition,
|
|
// 'pom' is typically the value used when building an exe with Maven.
|
|
asNode().project.packaging*.value = 'pom'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
def configureTestTask(Task task, String dep, String serviceName) {
|
|
def genDir = files(tasks.named("generateTest${dep}Proto")).singleFile
|
|
def genFile = "${genDir}/grpc/io/grpc/testing/compiler/${serviceName}Grpc.java"
|
|
task.dependsOn "generateTest${dep}Proto"
|
|
task.inputs.file genFile
|
|
if (osdetector.os != 'windows') {
|
|
task.executable "diff"
|
|
task.args "-u"
|
|
} else {
|
|
task.executable "fc"
|
|
}
|
|
task.args layout.projectDirectory.file("src/test${dep}/golden/${serviceName}.java.txt")
|
|
task.args genFile
|
|
// Register an output to allow up-to-date checking
|
|
task.outputs.file(layout.buildDirectory.file(task.name))
|
|
}
|
|
|
|
def testGolden = tasks.register("testGolden", Exec) {
|
|
configureTestTask(it, '', 'TestService')
|
|
}
|
|
def testLiteGolden = tasks.register("testLiteGolden", Exec) {
|
|
configureTestTask(it, 'Lite', 'TestService')
|
|
}
|
|
def testDeprecatedGolden = tasks.register("testDeprecatedGolden", Exec) {
|
|
configureTestTask(it, '', 'TestDeprecatedService')
|
|
}
|
|
def testDeprecatedLiteGolden = tasks.register("testDeprecatedLiteGolden", Exec) {
|
|
configureTestTask(it, 'Lite', 'TestDeprecatedService')
|
|
}
|
|
tasks.named("test").configure {
|
|
dependsOn testGolden
|
|
dependsOn testLiteGolden
|
|
dependsOn testDeprecatedGolden
|
|
dependsOn testDeprecatedLiteGolden
|
|
}
|