grpc: Update kmp example

Author: Jozott00

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

@@ -191,6 +191,10 @@ private fun GrpcClient(
  * Configuration class for a gRPC client, providing customization options
  * for client behavior, including interceptors, credentials, codec resolution,
  * and authority overrides.
+ *
+ * @see credentials
+ * @see overrideAuthority
+ * @see intercept
  */
 public class GrpcClientConfiguration internal constructor() {
     internal val interceptors: MutableList<ClientInterceptor> = mutableListOf()
@@ -226,6 +230,9 @@ public class GrpcClientConfiguration internal constructor() {
      *     credentials = plaintext() // for testing purposes only!
      * }
      * ```
+     *
+     * @see tls
+     * @see plaintext
      */
     public var credentials: ClientCredentials? = null
 

samples/grpc-kmp-app/composeApp/build.gradle.kts

@@ -32,7 +32,7 @@ kotlin {
             implementation(libs.androidx.lifecycle.runtimeCompose)
             implementation(libs.kotlinx.datetime)
             implementation(libs.kotlinx.rpc.protobuf.core)
-            implementation(libs.kotlinx.rpc.grpc.core)
+            implementation(libs.kotlinx.rpc.grpc.client)
             implementation(libs.grpc.netty)
             implementation(projects.shared)
         }

samples/grpc-kmp-app/composeApp/src/commonMain/kotlin/kotlinx/rpc/sample/App.kt

@@ -33,10 +33,16 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.retryWhen
 import kotlinx.coroutines.launch
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
-import kotlinx.rpc.grpc.GrpcClient
+import kotlinx.rpc.grpc.StatusException
+import kotlinx.rpc.grpc.client.GrpcClient
+import kotlinx.rpc.grpc.statusCode
 import kotlinx.rpc.internal.utils.ExperimentalRpcApi
 import kotlinx.rpc.sample.messages.ChatEntry
 import kotlinx.rpc.sample.messages.MessageService
@@ -45,7 +51,9 @@ import kotlinx.rpc.sample.messages.SendMessageRequest
 import kotlinx.rpc.sample.messages.invoke
 import kotlinx.rpc.withService
 import org.jetbrains.compose.ui.tooling.preview.Preview
+import kotlin.random.Random
 import kotlin.time.Clock
+import kotlin.time.Duration.Companion.seconds
 import kotlin.time.ExperimentalTime
 import kotlin.time.Instant
 
@@ -56,7 +64,7 @@ fun App() {
 
     val grpcClient = remember {
         GrpcClient("localhost", 8080) {
-            usePlaintext()
+            credentials = plaintext()
         }
     }
 
@@ -72,34 +80,63 @@ fun App() {
 private fun ChatScreen(service: MessageService) {
     val scope = rememberCoroutineScope()
 
-    var me by remember { mutableStateOf("me") }
+    var me by remember { mutableStateOf("user-${Random.nextInt(until = 999)}" ) }
     var input by remember { mutableStateOf("") }
     val messages = remember { mutableStateListOf<ChatEntry>() }
+    var error by remember { mutableStateOf<String?>(null) }
 
     fun sendMessage() {
         scope.launch {
-            val result = service.SendMessage(
-                SendMessageRequest{
-                    user = me
-                    text = input
-                }
-            )
-            if (result.success) {
-                messages += ChatEntry {
-                    user = me
-                    text = input
-                    tsMillis = Clock.System.now().toEpochMilliseconds()
+            try {
+                val result = service.SendMessage(
+                    SendMessageRequest {
+                        user = me
+                        text = input
+                    }
+                )
+                if (result.success) {
+                    messages += ChatEntry {
+                        user = me
+                        text = input
+                        tsMillis = Clock.System.now().toEpochMilliseconds()
+                    }
+                    input = ""
+                    error = null
+                } else {
+                    error = "Message not accepted by server."
                 }
-                input = ""
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: StatusException) {
+                error = e.getStatus().getDescription()?.let { "${e.getStatus().statusCode}: $it" } ?: "gRPC error: ${e.getStatus().statusCode}"
+            } catch (e: Throwable) {
+                error = e.message ?: "Unknown error while sending."
             }
         }
     }
 
     LaunchedEffect(me) {
         messages.clear()
+        error = null
         val req = ReceiveMessagesRequest { user = me }
-        service.ReceiveMessages(req).collect { msg ->
-            messages += msg
+        try {
+            service.ReceiveMessages(req)
+                .retryWhen { cause, attempt ->
+                    if (cause is CancellationException) false
+                    else {
+                        error = (cause as? StatusException)?.getStatus()?.getDescription()?.let { "${cause.getStatus().statusCode}: $it" }
+                            ?: cause.message ?: "Error receiving messages."
+                        delay(2.seconds)
+                        true
+                    }
+                }
+                .collect { msg -> messages += msg; error = null }
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: StatusException) {
+            error = e.getStatus().getDescription() ?: "gRPC error: ${e.getStatus().statusCode}"
+        } catch (e: Throwable) {
+            error = e.message ?: "Unknown error while receiving."
         }
     }
 
@@ -108,6 +145,18 @@ private fun ChatScreen(service: MessageService) {
         .windowInsetsPadding(WindowInsets.safeDrawing)
         .padding(16.dp)
     ) {
+
+        if (error != null) {
+            Text(
+                error!!,
+                color = MaterialTheme.colorScheme.error,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .background(MaterialTheme.colorScheme.errorContainer)
+                    .padding(8.dp)
+            )
+        }
+
         OutlinedTextField(
             value = me,
             onValueChange = { me = it },

samples/grpc-kmp-app/gradle/libs.versions.toml

@@ -24,6 +24,8 @@ ktor-serverCore = { module = "io.ktor:ktor-server-core-jvm", version.ref = "ktor
 ktor-serverNetty = { module = "io.ktor:ktor-server-netty-jvm", version.ref = "ktor" }
 ktor-serverTestHost = { module = "io.ktor:ktor-server-test-host-jvm", version.ref = "ktor" }
 kotlinx-rpc-grpc-core = { module = "org.jetbrains.kotlinx:kotlinx-rpc-grpc-core", version.ref = "kotlinx-rpc" }
+kotlinx-rpc-grpc-client = { module = "org.jetbrains.kotlinx:kotlinx-rpc-grpc-client", version.ref = "kotlinx-rpc" }
+kotlinx-rpc-grpc-server = { module = "org.jetbrains.kotlinx:kotlinx-rpc-grpc-server", version.ref = "kotlinx-rpc" }
 kotlinx-rpc-protobuf-core = { module = "org.jetbrains.kotlinx:kotlinx-rpc-protobuf-core", version.ref = "kotlinx-rpc" }
 grpc-netty = { module = "io.grpc:grpc-netty", version.ref = "grpc" }
 kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datatime" }

samples/grpc-kmp-app/server/build.gradle.kts

@@ -16,6 +16,6 @@ dependencies {
     implementation(projects.shared)
     implementation(libs.logback)
     implementation(libs.kotlinx.rpc.protobuf.core)
-    implementation(libs.kotlinx.rpc.grpc.core)
+    implementation(libs.kotlinx.rpc.grpc.server)
     implementation(libs.grpc.netty)
 }

samples/grpc-kmp-app/server/src/main/kotlin/kotlinx/rpc/sample/Application.kt

@@ -1,15 +1,17 @@
 package kotlinx.rpc.sample
 
 import kotlinx.coroutines.runBlocking
-import kotlinx.rpc.grpc.GrpcServer
+import kotlinx.rpc.grpc.server.GrpcServer
 import kotlinx.rpc.internal.utils.ExperimentalRpcApi
 import kotlinx.rpc.registerService
 import kotlinx.rpc.sample.messages.MessageService
 
 @OptIn(ExperimentalRpcApi::class)
 fun main(): Unit = runBlocking {
     val grpcServer = GrpcServer(8080) {
-        registerService<MessageService> { MessageServiceImpl() }
+        services {
+            registerService<MessageService> { MessageServiceImpl() }
+        }
     }
 
     grpcServer.start()