Some impls

Author: Mr3zee

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/GrpcClient.kt

@@ -4,37 +4,35 @@
 
 package kotlinx.rpc.grpc
 
-import io.grpc.stub.AbstractStub
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.job
 import kotlinx.rpc.RpcCall
 import kotlinx.rpc.RpcClient
-import kotlinx.rpc.descriptor.RpcServiceDescriptor
+import kotlinx.rpc.grpc.descriptor.GrpcClientDelegate
+import kotlinx.rpc.grpc.descriptor.GrpcServiceDescriptor
+import kotlinx.rpc.internal.utils.map.ConcurrentHashMap
 import kotlin.coroutines.CoroutineContext
 
 public class GrpcClient(private val channel: ManagedChannel) : RpcClient {
     override val coroutineContext: CoroutineContext = SupervisorJob()
 
+    private val stubs = ConcurrentHashMap<Long, GrpcClientDelegate>()
+
     override suspend fun <T> call(call: RpcCall): T {
-        val stub = grpcStubByServiceDescriptor(call.descriptor)
-        return invokeRpcMethodOnGrpcStub(stub, call)
+        return call.delegate().call(call)
     }
 
-    private fun grpcStubByServiceDescriptor(descriptor: RpcServiceDescriptor<*>): AbstractStub<*> {
-        error("Not yet implemented")
+    override fun <T> callAsync(serviceScope: CoroutineScope, call: RpcCall): Deferred<T> {
+        return call.delegate().callAsync(call)
     }
 
-    private suspend fun <T> invokeRpcMethodOnGrpcStub(stub: AbstractStub<*>, call: RpcCall): T {
-        error("Not yet implemented")
-    }
+    private fun RpcCall.delegate(): GrpcClientDelegate {
+        val grpc = (descriptor as? GrpcServiceDescriptor<*>)
+            ?: error("Service ${descriptor.fqName} is not a gRPC service")
 
-    override fun <T> callAsync(
-        serviceScope: CoroutineScope,
-        call: RpcCall,
-    ): Deferred<T> {
-        TODO("Not yet implemented")
+        return stubs.computeIfAbsent(serviceId) { grpc.delegate.clientProvider(channel) }
     }
 
     override fun provideStubContext(serviceId: Long): CoroutineContext {

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/GrpcServer.kt

@@ -6,8 +6,10 @@ package kotlinx.rpc.grpc
 
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.job
-import kotlinx.rpc.RemoteService
 import kotlinx.rpc.RpcServer
+import kotlinx.rpc.descriptor.serviceDescriptorOf
+import kotlinx.rpc.grpc.annotations.Grpc
+import kotlinx.rpc.grpc.descriptor.GrpcServiceDescriptor
 import kotlinx.rpc.grpc.internal.MutableHandlerRegistry
 import kotlinx.rpc.grpc.internal.ServerServiceDefinition
 import kotlin.coroutines.CoroutineContext
@@ -29,7 +31,7 @@ public class GrpcServer internal constructor(
     override val coroutineContext: CoroutineContext
         get() = error("coroutineContext is not available for gRPC server builder")
 
-    override fun <Service : RemoteService> registerService(
+    override fun <@Grpc Service : Any> registerService(
         serviceKClass: KClass<Service>,
         serviceFactory: (CoroutineContext) -> Service,
     ) {
@@ -45,12 +47,15 @@ public class GrpcServer internal constructor(
         }
     }
 
-    private fun <Service : RemoteService> getDefinition(
+    private fun <@Grpc Service : Any> getDefinition(
         service: Service,
         serviceKClass: KClass<Service>,
     ): ServerServiceDefinition {
-        // generated locator
-        TODO("Not yet implemented")
+        val descriptor = serviceDescriptorOf<Service>(serviceKClass)
+        val grpc = (descriptor as? GrpcServiceDescriptor<Service>)
+            ?: error("Service ${descriptor.fqName} is not a gRPC service")
+
+        return grpc.delegate.definitionFor(service)
     }
 
     internal fun build() {

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/ManagedChannel.kt

@@ -8,6 +8,8 @@ package kotlinx.rpc.grpc
 
 import kotlin.time.Duration
 
+public expect abstract class ManagedChannelPlatform
+
 public interface ManagedChannel {
     public val isShutdown: Boolean
     public val isTerminated: Boolean
@@ -16,6 +18,8 @@ public interface ManagedChannel {
 
     public fun shutdown(): ManagedChannel
     public fun shutdownNow(): ManagedChannel
+
+    public val platformApi: ManagedChannelPlatform
 }
 
 public expect abstract class ManagedChannelBuilder<T : ManagedChannelBuilder<T>>

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/annotations/Grpc.kt

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.rpc.grpc.annotations
+
+import kotlinx.rpc.annotations.Rpc
+
+@Target(AnnotationTarget.CLASS, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.TYPE_PARAMETER)
+@Rpc
+public annotation class Grpc

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/descriptor/GrpcServiceDescriptor.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.rpc.grpc.descriptor
+
+import kotlinx.coroutines.Deferred
+import kotlinx.rpc.RpcCall
+import kotlinx.rpc.descriptor.RpcServiceDescriptor
+import kotlinx.rpc.grpc.ManagedChannel
+import kotlinx.rpc.grpc.annotations.Grpc
+import kotlinx.rpc.grpc.internal.ServerServiceDefinition
+import kotlinx.rpc.internal.utils.ExperimentalRpcApi
+
+@ExperimentalRpcApi
+public interface GrpcServiceDescriptor<@Grpc T : Any> : RpcServiceDescriptor<T> {
+    public val delegate: GrpcDelegate<T>
+}
+
+@ExperimentalRpcApi
+public interface GrpcDelegate<@Grpc T : Any> {
+    public fun clientProvider(channel: ManagedChannel): GrpcClientDelegate
+
+    public fun definitionFor(impl: T): ServerServiceDefinition
+}
+
+@ExperimentalRpcApi
+public interface GrpcClientDelegate {
+    public suspend fun <R> call(rpcCall: RpcCall): R
+
+    public fun <R> callAsync(rpcCall: RpcCall): Deferred<R>
+}

grpc/grpc-core/src/jvmMain/kotlin/kotlinx/rpc/grpc/ManagedChannel.jvm.kt

@@ -10,6 +10,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlin.time.Duration
 
+public actual typealias ManagedChannelPlatform = io.grpc.ManagedChannel
+
 public actual typealias ManagedChannelBuilder<T> = io.grpc.ManagedChannelBuilder<T>
 
 public actual fun ManagedChannelBuilder<*>.buildChannel(): ManagedChannel {
@@ -50,4 +52,7 @@ private class JvmManagedChannel(private val channel: io.grpc.ManagedChannel) : M
         channel.shutdownNow()
         return this
     }
+
+    override val platformApi: ManagedChannelPlatform
+        get() = channel
 }

grpc/grpc-core/src/jvmMain/kotlin/kotlinx/rpc/grpc/internal/ServerServiceDefinition.jvm.kt

@@ -6,4 +6,7 @@
 
 package kotlinx.rpc.grpc.internal
 
-internal actual typealias ServerServiceDefinition = io.grpc.ServerServiceDefinition
+import kotlinx.rpc.internal.utils.InternalRpcApi
+
+@InternalRpcApi
+public actual typealias ServerServiceDefinition = io.grpc.ServerServiceDefinition

protobuf-plugin/build.gradle.kts

@@ -61,7 +61,7 @@ tasks.jar {
     )
 }
 
-val buildDir: String = project.layout.buildDirectory.get().asFile.absolutePath
+val buildDirPath: String = project.layout.buildDirectory.get().asFile.absolutePath
 
 protobuf {
     protoc {
@@ -70,7 +70,7 @@ protobuf {
 
     plugins {
         create("kotlinx-rpc") {
-            path = "$buildDir/libs/protobuf-plugin-$version.jar"
+            path = "$buildDirPath/libs/protobuf-plugin-$version.jar"
         }
 
         create("grpc") {
@@ -80,27 +80,20 @@ protobuf {
         create("grpckt") {
             artifact = "io.grpc:protoc-gen-grpc-kotlin:1.3.1:jdk8@jar"
         }
-
-        create("javalite") {
-            artifact = "com.google.protobuf:protoc:3.24.1"
-        }
     }
 
     generateProtoTasks {
         all().matching { it.isTest }.all {
             plugins {
                 create("kotlinx-rpc") {
-                    option("debugOutput=$buildDir/protobuf-plugin.log")
+                    option("debugOutput=$buildDirPath/protobuf-plugin.log")
                     option("messageMode=interface")
                 }
                 create("grpc")
                 create("grpckt")
             }
 
             builtins {
-                named("java") {
-                    option("lite")
-                }
                 id("kotlin")
             }
 

protobuf-plugin/src/main/kotlin/kotlinx/rpc/protobuf/CodeGenerator.kt

@@ -8,7 +8,7 @@ import org.slf4j.Logger
 import org.slf4j.helpers.NOPLogger
 
 data class CodeGenerationParameters(
-    val messageMode: RPCProtobufPlugin.MessageMode,
+    val messageMode: RpcProtobufPlugin.MessageMode,
 )
 
 open class CodeGenerator(
@@ -71,12 +71,12 @@ open class CodeGenerator(
         CodeGenerator(parameters, "$indent$ONE_INDENT", builder, logger).block()
     }
 
-    private fun scope(prefix: String, block: (CodeGenerator.() -> Unit)? = null) {
+    internal fun scope(prefix: String, suffix: String = "", block: (CodeGenerator.() -> Unit)? = null) {
         addLine(prefix)
-        scope(block)
+        scopeWithSuffix(suffix, block)
     }
 
-    private fun scope(block: (CodeGenerator.() -> Unit)? = null) {
+    private fun scopeWithSuffix(suffix: String = "", block: (CodeGenerator.() -> Unit)? = null) {
         if (block == null) {
             newLine()
             lastIsDeclaration = true
@@ -94,7 +94,7 @@ open class CodeGenerator(
         append(" {")
         newLine()
         append(nested.build().trimEnd())
-        addLine("}")
+        addLine("}$suffix")
         newLine()
         lastIsDeclaration = true
     }
@@ -103,9 +103,26 @@ open class CodeGenerator(
         code.lines().forEach { addLine(it) }
     }
 
+    fun property(
+        name: String,
+        modifiers: String = "",
+        contextReceiver: String = "",
+        type: String = "",
+        delegate: Boolean = false,
+        value: String = "",
+        block: (CodeGenerator.() -> Unit)? = null,
+    ) {
+        val modifiersString = if (modifiers.isEmpty()) "" else "$modifiers "
+        val contextString = if (contextReceiver.isEmpty()) "" else "$contextReceiver."
+        val typeString = if (type.isEmpty()) "" else ": $type"
+        val delegateString = if (delegate) " by " else " = "
+        scope("${modifiersString}val $contextString$name$typeString$delegateString$value", block = block)
+    }
+
     fun function(
         name: String,
         modifiers: String = "",
+        typeParameters: String = "",
         args: String = "",
         contextReceiver: String = "",
         returnType: String = "",
@@ -114,7 +131,8 @@ open class CodeGenerator(
         val modifiersString = if (modifiers.isEmpty()) "" else "$modifiers "
         val contextString = if (contextReceiver.isEmpty()) "" else "$contextReceiver."
         val returnTypeString = if (returnType.isEmpty()) "" else ": $returnType"
-        scope("${modifiersString}fun $contextString$name($args)$returnTypeString", block)
+        val typeParametersString = if (typeParameters.isEmpty()) "" else " <$typeParameters>"
+        scope("${modifiersString}fun$typeParametersString $contextString$name($args)$returnTypeString", block = block)
     }
 
     enum class DeclarationType(val strValue: String) {
@@ -217,7 +235,7 @@ open class CodeGenerator(
 
         append(superString)
 
-        scope(block)
+        scopeWithSuffix(block = block)
     }
 
     open fun build(): String {

protobuf-plugin/src/main/kotlin/kotlinx/rpc/protobuf/Main.kt

@@ -26,7 +26,7 @@ import com.google.protobuf.compiler.PluginProtos
 fun main() {
     val inputBytes = System.`in`.readBytes()
     val request = PluginProtos.CodeGeneratorRequest.parseFrom(inputBytes)
-    val plugin = RPCProtobufPlugin()
+    val plugin = RpcProtobufPlugin()
     val output: PluginProtos.CodeGeneratorResponse = plugin.run(request)
     output.writeTo(System.out)
 }