Added server APIs (no codegen)

Author: Mr3zee

grpc/grpc-core/build.gradle.kts

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+plugins {
+    alias(libs.plugins.conventions.kmp)
+}
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api(projects.core)
+                api(libs.coroutines.core)
+            }
+        }
+
+        jvmMain {
+            dependencies {
+                implementation("io.grpc:grpc-util:1.67.1")
+                implementation("io.grpc:grpc-stub:1.67.1")
+                implementation("io.grpc:grpc-protobuf:1.67.1")
+                implementation("io.grpc:grpc-kotlin-stub:1.3.1")
+                implementation("com.google.protobuf:protobuf-java-util:3.24.1")
+                implementation("com.google.protobuf:protobuf-kotlin:3.24.1")
+            }
+        }
+    }
+}

grpc/grpc-core/gradle.properties

@@ -0,0 +1,8 @@
+#
+# Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+#
+
+kotlinx.rpc.excludeWasmWasi=true
+kotlinx.rpc.excludeWasmJs=true
+kotlinx.rpc.excludeJs=true
+kotlinx.rpc.excludeNative=true

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

@@ -0,0 +1,39 @@
+/*
+ * 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
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+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")
+
+    override suspend fun <T> call(call: RPCCall): T {
+        TODO("Not yet implemented")
+    }
+
+    override fun <T> registerPlainFlowField(serviceScope: CoroutineScope, field: RPCField): Flow<T> {
+        error("gRPC client does not support field declarations")
+    }
+
+    override fun <T> registerSharedFlowField(serviceScope: CoroutineScope, field: RPCField): SharedFlow<T> {
+        error("gRPC client does not support field declarations")
+    }
+
+    override fun <T> registerStateFlowField(serviceScope: CoroutineScope, field: RPCField): StateFlow<T> {
+        error("gRPC client does not support field declarations")
+    }
+
+    override fun provideStubContext(serviceId: Long): CoroutineContext {
+        TODO("Not yet implemented")
+    }
+}

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

@@ -0,0 +1,94 @@
+/*
+ * 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
+
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.job
+import kotlinx.rpc.RPC
+import kotlinx.rpc.RPCServer
+import kotlinx.rpc.grpc.internal.MutableHandlerRegistry
+import kotlinx.rpc.grpc.internal.ServerServiceDefinition
+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 <Service : RPC> registerService(
+        serviceKClass: KClass<Service>,
+        serviceFactory: (CoroutineContext) -> Service,
+    ) {
+        val childJob = SupervisorJob(coroutineContext.job)
+        val service = serviceFactory(childJob)
+
+        val definition: ServerServiceDefinition = getDefinition(service, serviceKClass)
+
+        if (isBuilt) {
+            registry.addService(definition)
+        } else {
+            serverBuilder.addService(definition)
+        }
+    }
+
+    private fun <Service : RPC> getDefinition(
+        service: Service,
+        serviceKClass: KClass<Service>,
+    ): ServerServiceDefinition {
+        // generated locator
+        TODO("Not yet implemented")
+    }
+
+    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/Server.kt

@@ -0,0 +1,20 @@
+/*
+ * 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
+
+import kotlin.time.Duration
+
+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/ServerBuilder.kt

@@ -0,0 +1,18 @@
+/*
+ * 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.rpc.grpc.internal.HandlerRegistry
+import kotlinx.rpc.grpc.internal.ServerServiceDefinition
+
+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<*>

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2023-2024 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().toByteArray(Charsets.US_ASCII)
+    }
+}

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/StatusRuntimeException.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
+
+public interface StatusRuntimeException {
+    public val status: Status
+}
+
+public expect fun StatusRuntimeException(status: Status) : StatusRuntimeException

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

@@ -0,0 +1,17 @@
+/*
+ * 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.internal
+
+import kotlinx.rpc.internal.utils.InternalRPCApi
+
+@InternalRPCApi
+public expect abstract class HandlerRegistry
+
+@InternalRPCApi
+public expect class MutableHandlerRegistry constructor() : HandlerRegistry {
+    internal fun addService(service: ServerServiceDefinition): ServerServiceDefinition?
+}

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

@@ -0,0 +1,12 @@
+/*
+ * 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.internal
+
+import kotlinx.rpc.internal.utils.InternalRPCApi
+
+@InternalRPCApi
+public expect class ServerServiceDefinition