grpc-native: Resolve review requests

Signed-off-by: Johannes Zottele <[email protected]>

Author: Jozott00

grpc/grpc-core/build.gradle.kts

@@ -41,12 +41,13 @@ kotlin {
 
     val grpcppCLib = projectDir.resolve("../grpcpp-c")
 
+    // TODO: Replace function implementation, so it does not use an internal API
     fun findProgram(name: String) = org.gradle.internal.os.OperatingSystem.current().findInPath(name)
     val checkBazel by tasks.registering {
         doLast {
             val bazelPath = findProgram("bazel")
             if (bazelPath != null) {
-                println("bazel: $bazelPath")
+                logger.debug("bazel: {}", bazelPath)
             } else {
                 throw GradleException("'bazel' not found on PATH. Please install Bazel (https://bazel.build/).")
             }
@@ -73,7 +74,7 @@ kotlin {
                         grpcppCLib.resolve("bazel-grpcpp-c/external/grpc+/include")
                     )
                     extraOpts(
-                    "-libraryPath", "${grpcppCLib.resolve("bazel-out/darwin_arm64-opt/bin")}",
+                        "-libraryPath", "${grpcppCLib.resolve("bazel-out/darwin_arm64-opt/bin")}",
                     )
                 }
 

grpc/grpc-core/gradle.properties

@@ -1,7 +1,6 @@
 #
 # Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
 #
-
 kotlinx.rpc.exclude.wasmWasi=true
 kotlinx.rpc.exclude.iosArm64=true
 kotlinx.rpc.exclude.iosX64=true

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/bridge/GrpcByteBuffer.kt

@@ -10,22 +10,22 @@ import libgrpcpp_c.*
 @OptIn(ExperimentalForeignApi::class)
 internal class GrpcByteBuffer internal constructor(
     internal val cByteBuffer: CPointer<grpc_byte_buffer>
-): AutoCloseable {
+) : AutoCloseable {
 
-    constructor(slice: GrpcSlice): this(memScoped {
+    constructor(slice: GrpcSlice) : this(memScoped {
         grpc_raw_byte_buffer_create(slice.cSlice, 1u) ?: error("Failed to create byte buffer")
     })
 
     fun intoSlice(): GrpcSlice {
         memScoped {
-            val resp_slice = alloc<grpc_slice>()
-            grpc_byte_buffer_dump_to_single_slice(cByteBuffer, resp_slice.ptr)
-            return GrpcSlice(resp_slice.readValue())
+            val respSlice = alloc<grpc_slice>()
+            grpc_byte_buffer_dump_to_single_slice(cByteBuffer, respSlice.ptr)
+            return GrpcSlice(respSlice.readValue())
         }
     }
 
     override fun close() {
         grpc_byte_buffer_destroy(cByteBuffer)
     }
 
-}
+}

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/bridge/GrpcClient.kt

@@ -6,14 +6,14 @@ package kotlinx.rpc.grpc.bridge
 
 import kotlinx.cinterop.*
 import kotlinx.coroutines.suspendCancellableCoroutine
+import libgrpcpp_c.*
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
-import libgrpcpp_c.*
-
 
 @OptIn(ExperimentalForeignApi::class)
-internal class GrpcClient(target: String): AutoCloseable {
-    private var clientPtr: CPointer<grpc_client_t> = grpc_client_create_insecure(target) ?: error("Failed to create client")
+internal class GrpcClient(target: String) : AutoCloseable {
+    private var clientPtr: CPointer<grpc_client_t> =
+        grpc_client_create_insecure(target) ?: error("Failed to create client")
 
     fun callUnaryBlocking(method: String, req: GrpcSlice): GrpcSlice {
         memScoped {
@@ -23,45 +23,48 @@ internal class GrpcClient(target: String): AutoCloseable {
         }
     }
 
-    suspend fun callUnary(method: String, req: GrpcByteBuffer): GrpcByteBuffer = suspendCancellableCoroutine { continuation ->
+    suspend fun callUnary(method: String, req: GrpcByteBuffer): GrpcByteBuffer =
+        suspendCancellableCoroutine { continuation ->
             val context = grpc_context_create()
             val method = grpc_method_create(method)
 
-            val req_raw_buf = nativeHeap.alloc<CPointerVar<grpc_byte_buffer>>()
-            req_raw_buf.value = req.cByteBuffer
+            val reqRawBuf = nativeHeap.alloc<CPointerVar<grpc_byte_buffer>>()
+            reqRawBuf.value = req.cByteBuffer
 
-            val resp_raw_buf: CPointerVar<grpc_byte_buffer> = nativeHeap.alloc()
+            val respRawBuf: CPointerVar<grpc_byte_buffer> = nativeHeap.alloc()
 
             val continueCb = { st: grpc_status_code_t ->
                 // cleanup allocations owned by this method (this runs always)
                 grpc_method_delete(method)
                 grpc_context_delete(context)
-                nativeHeap.free(req_raw_buf)
+                nativeHeap.free(reqRawBuf)
 
                 if (st != GRPC_C_STATUS_OK) {
                     continuation.resumeWithException(RuntimeException("Call failed with code: $st"))
                 } else {
-                    val result = resp_raw_buf.value
+                    val result = respRawBuf.value
                     if (result == null) {
                         continuation.resumeWithException(RuntimeException("No response received"))
                     } else {
                         continuation.resume(GrpcByteBuffer(result))
                     }
                 }
 
-                nativeHeap.free(resp_raw_buf)
+                nativeHeap.free(respRawBuf)
             }
             val cbCtxStable = StableRef.create(continueCb)
 
-            grpc_client_call_unary_callback(clientPtr, method, context, req_raw_buf.ptr, resp_raw_buf.ptr, cbCtxStable.asCPointer(), staticCFunction { st, ctx ->
-                val cbCtxStable = ctx!!.asStableRef<(grpc_status_code_t) -> Unit>()
-                cbCtxStable.get()(st)
-                cbCtxStable.dispose()
-            })
-    }
+            grpc_client_call_unary_callback(
+                clientPtr, method, context, reqRawBuf.ptr, respRawBuf.ptr,
+                cbCtxStable.asCPointer(), staticCFunction { st, ctx ->
+                    val cbCtxStable = ctx!!.asStableRef<(grpc_status_code_t) -> Unit>()
+                    cbCtxStable.get()(st)
+                    cbCtxStable.dispose()
+                })
+        }
 
     override fun close() {
         grpc_client_delete(clientPtr)
     }
 
-}
+}

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/bridge/GrpcSlice.kt

@@ -12,7 +12,6 @@ import libgrpcpp_c.grpc_slice
 import libgrpcpp_c.grpc_slice_from_copied_buffer
 import libgrpcpp_c.grpc_slice_unref
 
-
 @OptIn(ExperimentalForeignApi::class)
 internal class GrpcSlice internal constructor(internal val cSlice: CValue<grpc_slice>) : AutoCloseable {
 
@@ -25,4 +24,4 @@ internal class GrpcSlice internal constructor(internal val cSlice: CValue<grpc_s
     override fun close() {
         grpc_slice_unref(cSlice)
     }
-}
+}

grpc/grpc-core/src/nativeTest/kotlin/kotlinx/rpc/grpc/BridgeTest.kt

@@ -8,14 +8,14 @@ import kotlinx.coroutines.runBlocking
 import kotlinx.rpc.grpc.bridge.GrpcByteBuffer
 import kotlinx.rpc.grpc.bridge.GrpcClient
 import kotlinx.rpc.grpc.bridge.GrpcSlice
+import libgrpcpp_c.pb_decode_greeter_sayhello_response
 import kotlin.test.Test
-import libgrpcpp_c.*
 
 @OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
 class BridgeTest {
 
     @Test
-    fun `test basic unary async call`() {
+    fun testBasicUnaryAsyncCall() {
         runBlocking {
             GrpcClient("localhost:50051").use { client ->
                 GrpcSlice(byteArrayOf(8, 4)).use { request ->
@@ -30,7 +30,7 @@ class BridgeTest {
                             }
                     }
                 }
-        }
+            }
         }
     }
 }