add spring boot grpc with tests

Author: xcodeassociated

build.gradle

@@ -5,6 +5,7 @@ plugins {
 	id 'org.jetbrains.kotlin.plugin.spring' version '2.2.21'
 	id 'org.jetbrains.kotlin.kapt' version '2.2.21'
 	id 'com.google.osdetector' version '1.7.3'
+	id 'com.google.protobuf' version '0.9.5'
 	id 'groovy'
 	id 'application'
 }
@@ -28,6 +29,9 @@ ext {
 	set('micrometerTracingBridgeOtelVersion', '1.6.3')
 	set('micrometerContextPropagationVersion', '1.2.1')
 	set('nettyResolverDnsNativeMacosVersion', '4.2.3.Final')
+	set('springGrpcVersion', "1.0.2")
+	set('grpcServicesVersion', '1.79.0')
+	set('grpcKotlinVersion', '1.5.0')
 }
 
 group = 'com.softeno'
@@ -129,12 +133,20 @@ dependencies {
 	implementation "io.opentelemetry.instrumentation:opentelemetry-logback-appender-1.0:${logbackAppenderVersion}"
 	implementation "io.micrometer:micrometer-tracing-bridge-otel:${micrometerTracingBridgeOtelVersion}"
 	implementation "io.micrometer:context-propagation:${micrometerContextPropagationVersion}"
+
+	// grpc
+	implementation "io.grpc:grpc-services:${grpcServicesVersion}"
+	implementation "io.grpc:protoc-gen-grpc-kotlin:${grpcKotlinVersion}"
+	implementation "io.grpc:grpc-kotlin-stub:${grpcKotlinVersion}"
+	implementation "org.springframework.grpc:spring-grpc-spring-boot-starter:${springGrpcVersion}"
+	testImplementation "org.springframework.grpc:spring-grpc-test:${springGrpcVersion}"
 }
 
 dependencyManagement {
 	imports {
 		mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
 		mavenBom "org.testcontainers:testcontainers-bom:${testcontainersVersion}"
+		mavenBom "org.springframework.grpc:spring-grpc-dependencies:${springGrpcVersion}"
 	}
 }
 
@@ -144,4 +156,28 @@ tasks.named('test') {
 
 kapt {
 	annotationProcessor("org.springframework.data.mongodb.repository.support.MongoAnnotationProcessor")
+}
+
+protobuf {
+	protoc {
+		artifact = 'com.google.protobuf:protoc'
+	}
+	plugins {
+		grpc {
+			artifact = 'io.grpc:protoc-gen-grpc-java'
+		}
+		grpckt {
+			artifact = "io.grpc:protoc-gen-grpc-kotlin:${grpcKotlinVersion}:jdk8@jar"
+		}
+	}
+	generateProtoTasks {
+		all()*.plugins {
+			grpc {
+				option '@generated=omit'
+			}
+			grpckt {
+				option '@generated=omit'
+			}
+		}
+	}
 }

http/external.http

@@ -24,4 +24,24 @@ Authorization: Bearer {{oauthToken}}
 
 ### NO FALLBACK
 GET {{host}}/external/throw-on-fallback/{{$random.integer(0, 1000)}}
-Authorization: Bearer {{oauthToken}}
+Authorization: Bearer {{oauthToken}}
+
+### HTTP -> GRPC
+GET {{host}}/external/grpc/{{$random.integer(0, 1000)}}
+Authorization: Bearer {{oauthToken}}
+
+### GRPC Unary call
+GRPC localhost:9080/com.softeno.template.grpc.SampleGrpcService/Echo
+
+{
+  "data": "123"
+}
+
+### GRPC Server streaming
+GRPC localhost:9080/com.softeno.template.grpc.SampleGrpcService/EchoServerStream
+
+{
+  "data": "hello"
+}
+
+### GRPC Client streaming & Bidirectional streaming - not supported in IDEA

http/grpc.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# Unary
+grpcurl -d '{ "data":"123" }' -plaintext localhost:9080 com.softeno.template.grpc.SampleGrpcService.Echo
+
+# Server Streaming
+grpcurl -plaintext \
+  -d '{ "data":"hello" }' \
+  localhost:9080 \
+  com.softeno.template.grpc.SampleGrpcService.EchoServerStream
+
+# Client Streaming: { "data": "one" } <enter> (...) ctrl-d
+grpcurl -plaintext \
+  -d @ \
+  localhost:9080 \
+  com.softeno.template.grpc.SampleGrpcService.EchoClientStream
+
+#Bidirectional Streaming
+grpcurl -plaintext \
+  -d @ \
+  localhost:9080 \
+  com.softeno.template.grpc.SampleGrpcService.EchoBidirectional

http/rsc/rsc-0.9.1.jar

@@ -1,5 +1,7 @@
 package com.softeno.template.sample.http.external.coroutine
 
+import com.softeno.template.grpc.SampleGrpcServiceGrpcKt
+import com.softeno.template.grpc.SampleRequest
 import com.softeno.template.sample.http.external.config.ExternalClientConfig
 import com.softeno.template.sample.http.internal.reactive.SampleResponseDto
 import kotlinx.coroutines.reactor.awaitSingle
@@ -20,7 +22,8 @@ class ExternalServiceException(message: String) : RuntimeException(message)
 class ExternalController(
     @param:Qualifier(value = "external") private val webClient: WebClient,
     private val reactiveCircuitBreakerFactory: ReactiveCircuitBreakerFactory<*, *>,
-    private val config: ExternalClientConfig
+    private val config: ExternalClientConfig,
+    private val stub: SampleGrpcServiceGrpcKt.SampleGrpcServiceCoroutineStub
 ) {
     private val log = LogFactory.getLog(javaClass)
 
@@ -119,4 +122,19 @@ class ExternalController(
         return response
     }
 
+    @GetMapping("/grpc/{data}")
+    suspend fun getGrpcHandler(@PathVariable data: String): SampleResponseDto {
+        log.info("[external]: GET grpc request: $data")
+
+        val response = stub.echo(
+            SampleRequest.newBuilder()
+                .setData(data)
+                .build()
+        ).data
+
+        log.info("[external]: received: $response")
+
+        return SampleResponseDto(data = response)
+    }
+
 }

src/main/kotlin/com/softeno/template/sample/http/external/coroutine/ExternalController.kt

@@ -0,0 +1,80 @@
+package com.softeno.template.sample.proto.api
+
+import com.softeno.template.grpc.SampleGrpcServiceGrpcKt
+import com.softeno.template.grpc.SampleRequest
+import com.softeno.template.grpc.SampleResponse
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.toList
+import org.apache.commons.logging.LogFactory
+import org.springframework.grpc.server.service.GrpcService
+
+@GrpcService
+class SampleGrpcServiceImpl :
+    SampleGrpcServiceGrpcKt.SampleGrpcServiceCoroutineImplBase() {
+    private val log = LogFactory.getLog(javaClass)
+
+    // Unary
+    override suspend fun echo(request: SampleRequest): SampleResponse {
+        log.info("[grpc]: echo: $request")
+
+        return SampleResponse.newBuilder()
+            .setData("Echo: ${request.data}")
+            .build()
+    }
+
+    // Server Streaming
+    override fun echoServerStream(request: SampleRequest): Flow<SampleResponse> = flow {
+        log.info("[grpc]: echoServerStream [request]: $request")
+
+        repeat(5) { index ->
+            val response = "Stream[$index]: ${request.data}"
+
+            log.info("[grpc]: echoServerStream [response]: $response")
+            emit(
+                SampleResponse.newBuilder()
+                    .setData(response)
+                    .build()
+            )
+            delay(500) // simulate async work
+        }
+    }
+
+    // Client Streaming
+    override suspend fun echoClientStream(
+        requests: Flow<SampleRequest>
+    ): SampleResponse {
+
+        val collected = requests
+            .toList()
+            .joinToString(", ") { it.data }
+
+        log.info("[grpc]: echoClientStream [request]: $collected")
+
+        return SampleResponse.newBuilder()
+            .setData("Collected: $collected")
+            .build()
+    }
+
+    // Bidirectional Streaming
+    override fun echoBidirectional(
+        requests: Flow<SampleRequest>
+    ): Flow<SampleResponse> = flow {
+
+        requests.collect { incoming ->
+            log.info("[grpc]: echoBidirectional [request]: $incoming")
+
+            val requestData = "Reply: ${incoming.data}"
+
+            log.info("[grpc]: echoBidirectional [response]: $requestData")
+
+            emit(
+                SampleResponse.newBuilder()
+                    .setData(requestData)
+                    .build()
+            )
+        }
+    }
+}
+

src/main/kotlin/com/softeno/template/sample/proto/api/SampleProto.kt

@@ -0,0 +1,20 @@
+package com.softeno.template.sample.proto.config
+
+import com.softeno.template.grpc.SampleGrpcServiceGrpcKt
+import io.grpc.Channel
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.grpc.client.GrpcChannelFactory
+
+
+@Configuration
+class GrpcClientConfig(
+    private val channelFactory: GrpcChannelFactory,
+) {
+
+    @Bean
+    fun externalStub(): SampleGrpcServiceGrpcKt.SampleGrpcServiceCoroutineStub {
+        val channel: Channel = channelFactory.createChannel("external")
+        return SampleGrpcServiceGrpcKt.SampleGrpcServiceCoroutineStub(channel)
+    }
+}

src/main/kotlin/com/softeno/template/sample/proto/config/GrpcConfig.kt

@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package com.softeno.template.grpc;
+
+option java_multiple_files = true;
+option java_package = "com.softeno.template.grpc";
+option java_outer_classname = "SampleGrpc";
+
+message SampleRequest {
+  string data = 1;
+}
+
+message SampleResponse {
+  string data = 1;
+}
+
+service SampleGrpcService {
+  // Unary
+  rpc Echo (SampleRequest) returns (SampleResponse) {}
+
+  // Server streaming
+  rpc EchoServerStream (SampleRequest) returns (stream SampleResponse) {}
+
+  // Client streaming
+  rpc EchoClientStream (stream SampleRequest) returns (SampleResponse) {}
+
+  // Bidirectional streaming
+  rpc EchoBidirectional (stream SampleRequest) returns (stream SampleResponse) {}
+}

src/main/proto/schema.proto

@@ -2,6 +2,10 @@ spring.config.import=optional:classpath:config/env.properties
 spring.main.allow-bean-definition-overriding=false
 
 server.port=8080
+
+spring.grpc.server.port=9080
+spring.grpc.client.channels.external.address=localhost:9082
+
 spring.application.name=SoftenoReactiveMongoApp
 
 spring.mongodb.host=${MONGO_HOST}