gRPC runtime declarations

Author: Mr3zee

core/src/jvmMain/kotlin/kotlinx/rpc/internal/internalServiceDescriptorOf.jvm.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
 
 package kotlinx.rpc.internal
@@ -13,8 +13,12 @@ private const val RPC_SERVICE_STUB_SIMPLE_NAME = "\$rpcServiceStub"
 internal actual fun <@Rpc T : Any> internalServiceDescriptorOf(kClass: KClass<T>): Any? {
     val className = "${kClass.qualifiedName}\$$RPC_SERVICE_STUB_SIMPLE_NAME"
 
-    return kClass.java.classLoader
-        .loadClass(className)
-        ?.kotlin
-        ?.companionObjectInstance
+    return try {
+        kClass.java.classLoader
+            .loadClass(className)
+            ?.kotlin
+            ?.companionObjectInstance
+    } catch (_ : ClassNotFoundException) {
+        null
+    }
 }

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.rpc.grpc
+
+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.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 {
+        return call.delegate().call(call)
+    }
+
+    override fun <T> callAsync(serviceScope: CoroutineScope, call: RpcCall): Deferred<T> {
+        return call.delegate().callAsync(call)
+    }
+
+    private fun RpcCall.delegate(): GrpcClientDelegate {
+        val grpc = (descriptor as? GrpcServiceDescriptor<*>)
+            ?: error("Service ${descriptor.fqName} is not a gRPC service")
+
+        return stubs.computeIfAbsent(serviceId) { grpc.delegate.clientProvider(channel) }
+    }
+
+    override fun provideStubContext(serviceId: Long): CoroutineContext {
+        // todo create lifetime hierarchy if possible
+        return SupervisorJob(coroutineContext.job)
+    }
+}
+
+public fun GrpcClient(
+    name: String,
+    port: Int,
+    configure: ManagedChannelBuilder<*>.() -> Unit = {},
+): GrpcClient {
+    val channel = ManagedChannelBuilder(name, port).apply(configure).buildChannel()
+    return GrpcClient(channel)
+}
+
+public fun GrpcClient(
+    target: String,
+    configure: ManagedChannelBuilder<*>.() -> Unit = {},
+): GrpcClient {
+    val channel = ManagedChannelBuilder(target).apply(configure).buildChannel()
+    return GrpcClient(channel)
+}

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

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.rpc.grpc
+
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.rpc.RpcServer
+import kotlinx.rpc.descriptor.serviceDescriptorOf
+import kotlinx.rpc.grpc.annotations.Grpc
+import kotlinx.rpc.grpc.descriptor.GrpcServiceDescriptor
+import kotlin.coroutines.CoroutineContext
+import kotlin.reflect.KClass
+import kotlin.time.Duration
+
+public class GrpcServer internal constructor(
+    override val port: Int = 8080,
+    builder: ServerBuilder<*>.() -> Unit,
+) : RpcServer, Server {
+    private var isBuilt = false
+    private lateinit var internalServer: Server
+
+    private val serverBuilder: ServerBuilder<*> = ServerBuilder(port).apply(builder)
+    private val registry: MutableHandlerRegistry by lazy {
+        MutableHandlerRegistry().apply { serverBuilder.fallbackHandlerRegistry(this) }
+    }
+
+    override val coroutineContext: CoroutineContext
+        get() = error("coroutineContext is not available for gRPC server builder")
+
+    override fun <@Grpc Service : Any> registerService(
+        serviceKClass: KClass<Service>,
+        serviceFactory: (CoroutineContext) -> Service,
+    ) {
+        val childJob = SupervisorJob()
+        val service = serviceFactory(childJob)
+
+        val definition: ServerServiceDefinition = getDefinition(service, serviceKClass)
+
+        if (isBuilt) {
+            registry.addService(definition)
+        } else {
+            serverBuilder.addService(definition)
+        }
+    }
+
+    private fun <@Grpc Service : Any> getDefinition(
+        service: Service,
+        serviceKClass: KClass<Service>,
+    ): ServerServiceDefinition {
+        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() {
+        internalServer = Server(serverBuilder)
+        isBuilt = true
+    }
+
+    override val isShutdown: Boolean
+        get() = internalServer.isShutdown
+
+    override val isTerminated: Boolean
+        get() = internalServer.isTerminated
+
+    override fun start(): GrpcServer {
+        internalServer.start()
+        return this
+    }
+
+    override fun shutdown(): GrpcServer {
+        internalServer.shutdown()
+        return this
+    }
+
+    override fun shutdownNow(): GrpcServer {
+        internalServer.shutdownNow()
+        return this
+    }
+
+    override suspend fun awaitTermination(duration: Duration): GrpcServer {
+        internalServer.awaitTermination(duration)
+        return this
+    }
+}
+
+public fun GrpcServer(
+    port: Int,
+    configure: ServerBuilder<*>.() -> Unit = {},
+    builder: RpcServer.() -> Unit = {},
+): GrpcServer {
+    return GrpcServer(port, configure).apply(builder).apply { build() }
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
+
+package kotlinx.rpc.grpc
+
+import kotlin.time.Duration
+
+public expect abstract class ManagedChannelPlatform
+
+public interface ManagedChannel {
+    public val isShutdown: Boolean
+    public val isTerminated: Boolean
+
+    public suspend fun awaitTermination(duration: Duration): Boolean
+
+    public fun shutdown(): ManagedChannel
+    public fun shutdownNow(): ManagedChannel
+
+    public val platformApi: ManagedChannelPlatform
+}
+
+public expect abstract class ManagedChannelBuilder<T : ManagedChannelBuilder<T>>
+
+public expect fun ManagedChannelBuilder(name: String, port: Int): ManagedChannelBuilder<*>
+public expect fun ManagedChannelBuilder(target: String): ManagedChannelBuilder<*>
+
+public expect fun ManagedChannelBuilder<*>.buildChannel(): ManagedChannel

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

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
+
+package kotlinx.rpc.grpc
+
+public expect abstract class HandlerRegistry
+
+@Suppress("RedundantConstructorKeyword")
+public expect class MutableHandlerRegistry constructor() : HandlerRegistry {
+    internal fun addService(@Suppress("unused") service: ServerServiceDefinition): ServerServiceDefinition?
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
+
+package kotlinx.rpc.grpc
+
+import kotlin.time.Duration
+
+public expect abstract class ServerBuilder<T : ServerBuilder<T>> {
+    public abstract fun addService(service: ServerServiceDefinition): T
+
+    public abstract fun fallbackHandlerRegistry(registry: HandlerRegistry?): T
+}
+
+internal expect fun ServerBuilder(port: Int): ServerBuilder<*>
+
+public interface Server {
+    public val port: Int
+    public val isShutdown: Boolean
+    public val isTerminated: Boolean
+
+    public fun start() : Server
+    public fun shutdown() : Server
+    public fun shutdownNow() : Server
+    public suspend fun awaitTermination(duration: Duration = Duration.INFINITE) : Server
+}
+
+internal expect fun Server(builder: ServerBuilder<*>): Server

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

@@ -0,0 +1,9 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
+
+package kotlinx.rpc.grpc
+
+public expect class ServerServiceDefinition

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:Suppress("MemberVisibilityCanBePrivate")
+
+package kotlinx.rpc.grpc
+
+public interface Status {
+    public val code: Code
+    public val description: String?
+    public val cause: Throwable?
+
+    public enum class Code(public val value: Int) {
+        OK(0),
+        CANCELLED(1),
+        UNKNOWN(2),
+        INVALID_ARGUMENT(3),
+        DEADLINE_EXCEEDED(4),
+        NOT_FOUND(5),
+        ALREADY_EXISTS(6),
+        PERMISSION_DENIED(7),
+        RESOURCE_EXHAUSTED(8),
+        FAILED_PRECONDITION(9),
+        ABORTED(10),
+        OUT_OF_RANGE(11),
+        UNIMPLEMENTED(12),
+        INTERNAL(13),
+        UNAVAILABLE(14),
+        DATA_LOSS(15),
+        UNAUTHENTICATED(16);
+
+        public val valueAscii: ByteArray = value.toString().encodeToByteArray()
+    }
+}

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

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.rpc.grpc
+
+public interface StatusRuntimeException {
+    public val status: Status
+}
+
+public expect fun StatusRuntimeException(status: Status) : StatusRuntimeException

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

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2023-2025 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