java-rpc-proto.gradle

import org.gradle.internal.os.OperatingSystem

buildscript {
    repositories {
        def mavenCentralMirror = System.getProperty('mavenCentralMirror')
        if (mavenCentralMirror) {
            maven { url = mavenCentralMirror }
        }
        gradlePluginPortal()
    }
    dependencies {
        classpath "com.google.protobuf:protobuf-gradle-plugin:${managedVersions['com.google.protobuf:protobuf-gradle-plugin']}"
    }
}

configure(projectsWithFlags('java')) {
    // Add protobuf/gRPC support if there is src/*/proto
    if (project.ext.hasSourceDirectory('proto')) {
        apply plugin: com.google.protobuf.gradle.ProtobufPlugin

        configurations {
            // A workaround for "Could not resolve all files for configuration ':grpc:compileProtoPath'"
            // - https://github.com/gradle/gradle/issues/12126
            // - https://github.com/google/protobuf-gradle-plugin/issues/391
            compileProtoPath {
                attributes {
                    attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, Usage.JAVA_API))
                }
                extendsFrom(configurations.compileClasspath)
            }
            optionalCompileProtoPath {
                attributes {
                    attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, Usage.JAVA_API))
                }
                extendsFrom(configurations.compileClasspath)
            }
            testCompileProtoPath {
                attributes {
                    attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, Usage.JAVA_API))
                }
                extendsFrom(configurations.compileClasspath)
            }
        }

        protobuf {
            def versionParts = managedVersions['com.google.protobuf:protobuf-gradle-plugin'].tokenize('.').collect { it as int }
            int versionCmp= (versionParts[0] <=> 0) ?: (versionParts[1] <=> 9) ?: (versionParts[2] <=> 2)
            if (versionCmp < 0) {
                // generatedFilesBaseDir is unsupported since protobuf-gradle-plugin 0.9.2
                generatedFilesBaseDir = project.ext.genSrcDir
            }
            if (managedVersions.containsKey('com.google.protobuf:protoc')) {
                protoc {
                    artifact = "com.google.protobuf:protoc:${managedVersions['com.google.protobuf:protoc']}"
                }
            }

            def grpcVersion = managedVersions['io.grpc:grpc-bom'] ?: managedVersions['io.grpc:grpc-core']
            if (grpcVersion != null) {
                plugins {
                    grpc {
                        artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
                    }
                    if (project.ext.hasFlag('reactor-grpc') && managedVersions.containsKey('com.salesforce.servicelibs:reactor-grpc')) {
                        reactorGrpc {
                            artifact = "com.salesforce.servicelibs:reactor-grpc:${managedVersions['com.salesforce.servicelibs:reactor-grpc']}"
                        }
                    }
                    if (project.ext.hasFlag('rxgrpc') && managedVersions.containsKey('com.salesforce.servicelibs:rxgrpc')) {
                        rxgrpc {
                            artifact = "com.salesforce.servicelibs:rxgrpc:${managedVersions['com.salesforce.servicelibs:reactor-grpc']}"
                        }
                    }
                    if (project.ext.hasFlag('kotlin-grpc')) {
                        kotlinGrpc {
                            artifact = "io.grpc:protoc-gen-grpc-kotlin:${managedVersions['io.grpc:protoc-gen-grpc-kotlin']}:jdk8@jar"
                        }
                    }

                    if (project.ext.hasFlag('krotodc-grpc')) {
                        krotodcGrpc {
                            artifact = "io.github.mscheong01:protoc-gen-krotoDC:${managedVersions['io.github.mscheong01:protoc-gen-krotoDC']}:jdk8@jar"
                        }
                    }

                    def isWindows = OperatingSystem.current() == OperatingSystem.WINDOWS
                    if (project.ext.hasFlag('scala-grpc_2.13')) {
                        def artifactName = "com.thesamet.scalapb:protoc-gen-scala:${managedVersions['com.thesamet.scalapb:scalapb-runtime_2.13']}:"
                        artifactName += isWindows ? "windows@bat" : "unix@sh"
                        scalapb {
                            artifact = artifactName
                        }
                    }

                    if (project.ext.hasFlag('akka-grpc_2.13')) {
                        def artifactName = "com.lightbend.akka.grpc:akka-grpc-codegen_2.13:${managedVersions['com.lightbend.akka.grpc:akka-grpc-runtime_2.13']}:"
                        artifactName += isWindows ? "bat@bat" : "assembly@jar"
                        akkaGrpc {
                            artifact = artifactName
                        }
                    }
                }

                def validateVersion = managedVersions['build.buf.protoc-gen-validate:protoc-gen-validate']
                if (validateVersion != null) {
                    plugins {
                        javapgv {
                            artifact = "build.buf.protoc-gen-validate:protoc-gen-validate:${validateVersion}"
                        }
                    }
                }

                generateProtoTasks {
                    all().configureEach { t ->
                        t.plugins {
                            if (project.ext.hasFlag('scala-grpc_2.13') && managedVersions.containsKey('com.thesamet.scalapb:scalapb-runtime_2.13')) {
                                scalapb {
                                    option 'grpc'
                                }
                            } else {
                                grpc {
                                    option 'enable_deprecated=false'
                                }
                                if (project.ext.hasFlag('reactor-grpc') && managedVersions.containsKey('com.salesforce.servicelibs:reactor-grpc')) {
                                    reactorGrpc {}
                                }
                                if (project.ext.hasFlag('rxgrpc') && managedVersions.containsKey('com.salesforce.servicelibs:rxgrpc')) {
                                    rxgrpc {}
                                }
                                if (project.ext.hasFlag('kotlin-grpc') && managedVersions.containsKey('io.grpc:grpc-kotlin-stub')) {
                                    kotlinGrpc {}
                                }
                                if (project.ext.hasFlag('krotodc-grpc') && managedVersions.containsKey('io.github.mscheong01:protoc-gen-krotoDC')) {
                                    krotodcGrpc {}
                                }
                                if (project.ext.hasFlag('akka-grpc_2.13') && managedVersions.containsKey('com.lightbend.akka.grpc:akka-grpc-runtime_2.13')) {
                                    akkaGrpc {}
                                }
                            }
                            if (project.ext.hasFlag('javapgv')) {
                                javapgv {
                                    option "lang=java"
                                }
                            }
                        }
                    }

                    all().each { task ->
                        task.generateDescriptorSet = true
                        task.descriptorSetOptions.includeSourceInfo = true
                        task.descriptorSetOptions.includeImports = true
                        task.descriptorSetOptions.path =
                                "${project.ext.genSrcDir}/${task.sourceSet.name}/resources/" +
                                        "META-INF/armeria/grpc/armeria-${task.sourceSet.name}.dsc"
                    }
                }
            }
        }

        // Make sure protoc runs before the resources are copied so that .dsc files are included.
        project.afterEvaluate {
            project.sourceSets.each { sourceSet ->
                def task = tasks.findByName(sourceSet.getTaskName('generate', 'proto'))
                def processResourcesTask = tasks.findByName(sourceSet.getTaskName('process', 'resources'))
                if (processResourcesTask != null) {
                    processResourcesTask.dependsOn(task)
                }

                def sourcesJarTask = tasks.findByName(sourceSet.getTaskName('sources', 'jar'))
                if (sourcesJarTask) {
                    // A workaround for 'sourcesJar' uses this output of task ':generateProto' without
                    // declaring an explicit or implicit dependency.
                    sourcesJarTask.dependsOn(task)
                }

                def kotlinSourcesJar = tasks.findByName('kotlinSourcesJar')
                if (kotlinSourcesJar) {
                    // A workaround for  ':grpc-kotlin:kotlinSourcesJar' uses this output of task
                    // ':grpc-kotlin:generateProto' without declaring an explicit or implicit dependency.
                    kotlinSourcesJar.dependsOn(task)
                }

                project.ext.getGenerateSourcesTask().dependsOn(task)
            }
        }
    }
}