Added client APIs (no codegen)

Author: Mr3zee

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

@@ -5,20 +5,24 @@
 package kotlinx.rpc.grpc
 
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.job
 import kotlinx.rpc.RPCCall
 import kotlinx.rpc.RPCClient
 import kotlinx.rpc.RPCField
 import kotlin.coroutines.CoroutineContext
 
-public class GrpcClient : RPCClient {
-    override val coroutineContext: CoroutineContext
-        get() = TODO("Not yet implemented")
+public class GrpcClient(
+    private val channel: ManagedChannel,
+) : RPCClient {
+    override val coroutineContext: CoroutineContext = SupervisorJob()
 
     override suspend fun <T> call(call: RPCCall): T {
-        TODO("Not yet implemented")
+        // todo perform call
+        error("not implemented")
     }
 
     override fun <T> registerPlainFlowField(serviceScope: CoroutineScope, field: RPCField): Flow<T> {
@@ -34,6 +38,24 @@ public class GrpcClient : RPCClient {
     }
 
     override fun provideStubContext(serviceId: Long): CoroutineContext {
-        TODO("Not yet implemented")
+        // 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/ManagedChannel.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023-2024 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 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 expect abstract class ManagedChannelBuilder<T : io.grpc.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/jvmMain/kotlin/kotlinx/rpc/grpc/ManagedChannel.jvm.kt

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2023-2024 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 kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlin.time.Duration
+
+public actual typealias ManagedChannelBuilder<T> = io.grpc.ManagedChannelBuilder<T>
+
+public actual fun ManagedChannelBuilder<*>.buildChannel(): ManagedChannel {
+    return build().toKotlin()
+}
+
+public actual fun ManagedChannelBuilder(name: String, port: Int): ManagedChannelBuilder<*> {
+    return io.grpc.ManagedChannelBuilder.forAddress(name, port)
+}
+
+public actual fun ManagedChannelBuilder(target: String): ManagedChannelBuilder<*> {
+    return io.grpc.ManagedChannelBuilder.forTarget(target)
+}
+
+public fun io.grpc.ManagedChannel.toKotlin(): ManagedChannel {
+    return JvmManagedChannel(this)
+}
+
+private class JvmManagedChannel(private val channel: io.grpc.ManagedChannel) : ManagedChannel {
+    override val isShutdown: Boolean
+        get() = channel.isShutdown
+
+    override val isTerminated: Boolean
+        get() = channel.isTerminated
+
+    override suspend fun awaitTermination(duration: Duration): Boolean {
+        return withContext(Dispatchers.IO) {
+            channel.awaitTermination(duration.inWholeNanoseconds, java.util.concurrent.TimeUnit.NANOSECONDS)
+        }
+    }
+
+    override fun shutdown(): ManagedChannel {
+        channel.shutdown()
+        return this
+    }
+
+    override fun shutdownNow(): ManagedChannel {
+        channel.shutdownNow()
+        return this
+    }
+}