grpc: Fix the service name to be full-qualified

Signed-off-by: Johannes Zottele <[email protected]>

Author: Jozott00

compiler-plugin/compiler-plugin-backend/src/main/kotlin/kotlinx/rpc/codegen/extension/RpcStubGenerator.kt

@@ -18,11 +18,7 @@ import org.jetbrains.kotlin.ir.builders.declarations.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
+import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.Name
@@ -915,7 +911,8 @@ internal class RpcStubGenerator(
         }.apply {
             overriddenSymbols = listOf(ctx.properties.rpcServiceDescriptorCallables)
 
-            val collectionType = ctx.irBuiltIns.collectionClass.typeWith(ctx.rpcCallable.typeWith(declaration.serviceType))
+            val collectionType =
+                ctx.irBuiltIns.collectionClass.typeWith(ctx.rpcCallable.typeWith(declaration.serviceType))
 
             addGetter {
                 returnType = collectionType
@@ -1105,7 +1102,7 @@ internal class RpcStubGenerator(
         }.apply {
             arguments {
                 values {
-                    +stringConst(declaration.simpleName)
+                    +stringConst(declaration.fqName)
 
                     +irCallProperty(
                         receiver = IrGetValueImpl(
@@ -1130,7 +1127,7 @@ internal class RpcStubGenerator(
      * // In scope: resolver: MessageCodecResolver
      *
      * methodDescriptor<<request-type>, <response-type>>(
-     *     fullMethodName = "${descriptor.simpleName}/${callable.name}",
+     *     fullMethodName = "${descriptor.fqName}/${callable.name}",
      *     requestCodec = <request-codec>,
      *     responseCodec = <response-codec>,
      *     type = MethodType.<method-type>,
@@ -1185,7 +1182,7 @@ internal class RpcStubGenerator(
 
                 values {
                     // fullMethodName
-                    +stringConst("${declaration.simpleName}/${callable.name}")
+                    +stringConst("${declaration.fqName}/${callable.name}")
 
                     // requestCodec
                     +irCodec(requestType, resolver)
@@ -1245,7 +1242,7 @@ internal class RpcStubGenerator(
         val protobufMessage = owner.getAnnotation(ctx.withCodecAnnotation.owner.kotlinFqName)
 
         return if (protobufMessage != null) {
-            val classReference = vsApi{ protobufMessage.argumentsVS }.single() as? IrClassReference
+            val classReference = vsApi { protobufMessage.argumentsVS }.single() as? IrClassReference
                 ?: error("Expected IrClassReference for ${ctx.withCodecAnnotation.owner.kotlinFqName} parameter")
 
             val codec = classReference.classType

grpc/grpc-core/src/commonTest/kotlin/kotlinx/rpc/grpc/test/RawClientTest.kt

@@ -5,18 +5,26 @@
 package kotlinx.rpc.grpc.test
 
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.test.runTest
+import kotlinx.rpc.grpc.GrpcServer
 import kotlinx.rpc.grpc.ManagedChannelBuilder
 import kotlinx.rpc.grpc.buildChannel
 import kotlinx.rpc.grpc.internal.*
+import kotlinx.rpc.registerService
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
+private const val PORT = 50051
+
 /**
  * Tests for JVM and Native clients.
+ *
+ * To run the tests you must first start the server with the [EchoServiceImpl.runServer] method on JVM.
  */
-// TODO: Start echo service server automatically
+// TODO: Start external service server automatically (KRPC-208)
 class RawClientTest {
 
     @Test
@@ -86,7 +94,7 @@ class RawClientTest {
             .buildChannel()
 
         val methodDescriptor = methodDescriptor(
-            fullMethodName = "grpc.examples.echo.Echo/$methodName",
+            fullMethodName = "kotlinx.rpc.grpc.test.EchoService/$methodName",
             requestCodec = EchoRequestInternal.CODEC,
             responseCodec = EchoResponseInternal.CODEC,
             type = type,
@@ -103,4 +111,56 @@ class RawClientTest {
             channel.awaitTermination()
         }
     }
-}
+}
+
+
+class EchoServiceImpl : EchoService {
+
+    override suspend fun UnaryEcho(message: EchoRequest): EchoResponse {
+        delay(message.timeout.toLong())
+        return EchoResponse { this.message = message.message }
+    }
+
+    override fun ServerStreamingEcho(message: EchoRequest): Flow<EchoResponse> {
+        val count = message.serverStreamReps ?: 5u
+        return flow {
+            repeat(count.toInt()) {
+                emit(EchoResponse { this.message = message.message })
+            }
+        }
+    }
+
+    override suspend fun ClientStreamingEcho(message: Flow<EchoRequest>): EchoResponse {
+        val result = message.toList().joinToString(", ") { it.message }
+        return EchoResponse { this.message = result }
+    }
+
+    override fun BidirectionalStreamingEcho(message: Flow<EchoRequest>): Flow<EchoResponse> {
+        return flow {
+            message.collect {
+                emit(EchoResponse { this.message = it.message })
+            }
+        }
+    }
+
+
+    /**
+     * Run this on JVM before executing tests.
+     */
+    @Test
+    fun runServer() = runTest {
+        val server = GrpcServer(
+            port = PORT,
+            builder = { registerService<EchoService> { EchoServiceImpl() } }
+        )
+
+        try {
+            server.start()
+            println("Server started")
+            server.awaitTermination()
+        } finally {
+            server.shutdown()
+            server.awaitTermination()
+        }
+    }
+}

grpc/grpc-core/src/commonTest/proto/echo_grpc.proto

@@ -1,10 +1,12 @@
 syntax = "proto3";
 
-package grpc.examples.echo;
+package kotlinx.rpc.grpc.test;
 
 // EchoRequest is the request for echo.
 message EchoRequest {
   string message = 1;
+  uint32 timeout = 2;
+  optional uint32 serverStreamReps = 3;
 }
 
 // EchoResponse is the response for echo.
@@ -13,7 +15,7 @@ message EchoResponse {
 }
 
 // Echo is the echo service.
-service Echo {
+service EchoService {
   // UnaryEcho is unary echo.
   rpc UnaryEcho(EchoRequest) returns (EchoResponse) {}
   // ServerStreamingEcho is server side streaming.

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/internal/NativeClientCall.kt

@@ -224,6 +224,7 @@ internal class NativeClientCall<Request, Response>(
             is BatchResult.Submitted -> {
                 callResult.future.onComplete {
                     val details = statusDetails.toByteArray().toKString()
+                    println("details: $details")
                     val status = Status(statusCode.value.toKotlin(), details, null)
                     val trailers = GrpcTrailers()
 

grpc/grpc-core/src/nativeTest/kotlin/kotlinx/rpc/grpc/internal/CoreTest.kt

@@ -9,10 +9,6 @@ import HelloReply
 import HelloReplyInternal
 import HelloRequest
 import HelloRequestInternal
-import grpc.examples.echo.EchoRequest
-import grpc.examples.echo.EchoRequestInternal
-import grpc.examples.echo.EchoResponseInternal
-import grpc.examples.echo.invoke
 import invoke
 import kotlinx.cinterop.ExperimentalForeignApi
 import kotlinx.coroutines.CompletableDeferred
@@ -26,6 +22,8 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 import kotlin.test.assertTrue
 
+
+// TODO: Start external service server automatically (KRPC-208)
 class GrpcCoreTest {
 
     private fun descriptorFor(fullName: String = "helloworld.Greeter/SayHello"): MethodDescriptor<HelloRequest, HelloReply> =
@@ -293,26 +291,4 @@ class GrpcCoreTest {
             assertEquals("Hello world", res.message)
         }
     }
-
-
-    private fun echoDescriptor(methodName: String, type: MethodType) =
-        methodDescriptor(
-            fullMethodName = "grpc.examples.echo.Echo/$methodName",
-            requestCodec = EchoRequestInternal.CODEC,
-            responseCodec = EchoResponseInternal.CODEC,
-            type = type,
-            schemaDescriptor = Unit,
-            idempotent = true,
-            safe = true,
-            sampledToLocalTracing = true,
-        )
-
-    @Test
-    fun unaryEchoTest() = runBlocking {
-        val ch = createChannel()
-        val desc = echoDescriptor("UnaryEcho", MethodType.UNARY)
-        val req = EchoRequest { message = "Echoooo" }
-        unaryRpc(ch.platformApi, desc, req)
-        return@runBlocking
-    }
 }