grpc-native: Rename ChannelCredentials to ClientCredentials

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

Author: Jozott00

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

@@ -131,7 +131,7 @@ public class GrpcClient internal constructor(
 public fun GrpcClient(
     hostname: String,
     port: Int,
-    credentials: ChannelCredentials? = null,
+    credentials: ClientCredentials? = null,
     messageCodecResolver: MessageCodecResolver = EmptyMessageCodecResolver,
     configure: ManagedChannelBuilder<*>.() -> Unit = {},
 ): GrpcClient {
@@ -144,7 +144,7 @@ public fun GrpcClient(
  */
 public fun GrpcClient(
     target: String,
-    credentials: ChannelCredentials? = null,
+    credentials: ClientCredentials? = null,
     messageCodecResolver: MessageCodecResolver = EmptyMessageCodecResolver,
     configure: ManagedChannelBuilder<*>.() -> Unit = {},
 ): GrpcClient {

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

@@ -76,12 +76,12 @@ public expect abstract class ManagedChannelBuilder<T : ManagedChannelBuilder<T>>
 internal expect fun ManagedChannelBuilder(
     hostname: String,
     port: Int,
-    credentials: ChannelCredentials? = null,
+    credentials: ClientCredentials? = null,
 ): ManagedChannelBuilder<*>
 
 internal expect fun ManagedChannelBuilder(
     target: String,
-    credentials: ChannelCredentials? = null,
+    credentials: ClientCredentials? = null,
 ): ManagedChannelBuilder<*>
 
 internal expect fun ManagedChannelBuilder<*>.buildChannel(): ManagedChannel

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

@@ -6,17 +6,17 @@ package kotlinx.rpc.grpc/*
  * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
 
-public expect abstract class ChannelCredentials
+public expect abstract class ClientCredentials
 public expect abstract class ServerCredentials
 
-public expect class InsecureChannelCredentials : ChannelCredentials
+public expect class InsecureClientCredentials : ClientCredentials
 public expect class InsecureServerCredentials : ServerCredentials
 
-public expect class TlsChannelCredentials : ChannelCredentials
+public expect class TlsClientCredentials : ClientCredentials
 public expect class TlsServerCredentials : ServerCredentials
 
-public fun TlsChannelCredentials(configure: TlsChannelCredentialsBuilder.() -> Unit = {}): ChannelCredentials {
-    val builder = TlsChannelCredentialsBuilder()
+public fun TlsClientCredentials(configure: TlsClientCredentialsBuilder.() -> Unit = {}): ClientCredentials {
+    val builder = TlsClientCredentialsBuilder()
     builder.configure()
     return builder.build()
 }
@@ -31,10 +31,10 @@ public fun TlsServerCredentials(
     return builder.build()
 }
 
-public interface TlsChannelCredentialsBuilder {
-    public fun trustManager(rootCertsPem: String): TlsChannelCredentialsBuilder
-    public fun keyManager(certChainPem: String, privateKeyPem: String): TlsChannelCredentialsBuilder
-    public fun build(): ChannelCredentials
+public interface TlsClientCredentialsBuilder {
+    public fun trustManager(rootCertsPem: String): TlsClientCredentialsBuilder
+    public fun keyManager(certChainPem: String, privateKeyPem: String): TlsClientCredentialsBuilder
+    public fun build(): ClientCredentials
 }
 
 public enum class TlsClientAuth {
@@ -62,7 +62,7 @@ public interface TlsServerCredentialsBuilder {
     public fun build(): ServerCredentials
 }
 
-internal expect fun TlsChannelCredentialsBuilder(): TlsChannelCredentialsBuilder
+internal expect fun TlsClientCredentialsBuilder(): TlsClientCredentialsBuilder
 internal expect fun TlsServerCredentialsBuilder(
     certChain: String,
     privateKey: String,

grpc/grpc-core/src/commonTest/kotlin/kotlinx/rpc/grpc/test/proto/GrpcProtoTest.kt

@@ -8,7 +8,7 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.test.runTest
 import kotlinx.rpc.RpcServer
-import kotlinx.rpc.grpc.ChannelCredentials
+import kotlinx.rpc.grpc.ClientCredentials
 import kotlinx.rpc.grpc.GrpcClient
 import kotlinx.rpc.grpc.GrpcServer
 import kotlinx.rpc.grpc.ServerCredentials
@@ -20,7 +20,7 @@ abstract class GrpcProtoTest {
 
     protected fun runGrpcTest(
         serverCreds: ServerCredentials? = null,
-        clientCreds: ChannelCredentials? = null,
+        clientCreds: ClientCredentials? = null,
         overrideAuthority: String? = null,
         test: suspend (GrpcClient) -> Unit,
     ) = runTest {

grpc/grpc-core/src/commonTest/kotlin/kotlinx/rpc/grpc/test/proto/GrpcTlsTest.kt

@@ -11,8 +11,8 @@ import kotlinx.coroutines.test.runTest
 import kotlinx.rpc.RpcServer
 import kotlinx.rpc.grpc.GrpcClient
 import kotlinx.rpc.grpc.StatusCode
-import kotlinx.rpc.grpc.TlsChannelCredentials
 import kotlinx.rpc.grpc.TlsClientAuth
+import kotlinx.rpc.grpc.TlsClientCredentials
 import kotlinx.rpc.grpc.TlsServerCredentials
 import kotlinx.rpc.grpc.test.CA_PEM
 import kotlinx.rpc.grpc.test.CLIENT_CERT_PEM
@@ -55,7 +55,7 @@ class GrpcTlsTest : GrpcProtoTest() {
     @Test
     fun `test TLS with valid certificates - should succeed`() {
         val serverTls = TlsServerCredentials(SERVER_CERT_PEM, SERVER_KEY_PEM)
-        val clientTls = TlsChannelCredentials { trustManager(SERVER_CERT_PEM) }
+        val clientTls = TlsClientCredentials { trustManager(SERVER_CERT_PEM) }
 
         runGrpcTest(serverTls, clientTls, overrideAuthority = "foo.test.google.fr", test = ::defaultUnaryTest)
     }
@@ -66,7 +66,7 @@ class GrpcTlsTest : GrpcProtoTest() {
             trustManager(CA_PEM)
             clientAuth(TlsClientAuth.REQUIRE)
         }
-        val clientTls = TlsChannelCredentials {
+        val clientTls = TlsClientCredentials {
             keyManager(CLIENT_CERT_PEM, CLIENT_KEY_PEM)
             trustManager(CA_PEM)
         }
@@ -85,7 +85,7 @@ class GrpcTlsTest : GrpcProtoTest() {
             // clientAuth is optional, so a client without a certificate can connect
             clientAuth(TlsClientAuth.OPTIONAL)
         }
-        val clientTls = TlsChannelCredentials {
+        val clientTls = TlsClientCredentials {
             keyManager(CLIENT_CERT_PEM, CLIENT_KEY_PEM)
             trustManager(CA_PEM)
         }
@@ -101,7 +101,7 @@ class GrpcTlsTest : GrpcProtoTest() {
             clientAuth(TlsClientAuth.REQUIRE)
         }
         // client does NOT provide keyManager, only trusts CA
-        val clientTls = TlsChannelCredentials {
+        val clientTls = TlsClientCredentials {
             trustManager(CA_PEM)
         }
 
@@ -114,7 +114,7 @@ class GrpcTlsTest : GrpcProtoTest() {
     fun `test TLS with no client trustManager - should fail`() = runTest {
         val serverTls = TlsServerCredentials(SERVER_CERT_PEM, SERVER_KEY_PEM)
         // client credential doesn't contain a trustManager, so server authentication will fail
-        val clientTls = TlsChannelCredentials {}
+        val clientTls = TlsClientCredentials {}
         assertGrpcFailure(StatusCode.UNAVAILABLE) {
             runGrpcTest(serverTls, clientTls, overrideAuthority = "foo.test.google.fr", test = ::defaultUnaryTest)
         }
@@ -123,7 +123,7 @@ class GrpcTlsTest : GrpcProtoTest() {
     @Test
     fun `test TLS with invalid authority - should fail`() = runTest {
         val serverTls = TlsServerCredentials(SERVER_CERT_PEM, SERVER_KEY_PEM)
-        val clientTls = TlsChannelCredentials { trustManager(CA_PEM) }
+        val clientTls = TlsClientCredentials { trustManager(CA_PEM) }
         // the authority does not match the certificate
         assertGrpcFailure(StatusCode.UNAVAILABLE) {
             runGrpcTest(serverTls, clientTls, overrideAuthority = "invalid.host.name", test = ::defaultUnaryTest)
@@ -140,7 +140,7 @@ class GrpcTlsTest : GrpcProtoTest() {
 
     @Test
     fun `test TLS client with plaintext server - should fail`() = runTest {
-        val clientTls = TlsChannelCredentials { trustManager(CA_PEM) }
+        val clientTls = TlsClientCredentials { trustManager(CA_PEM) }
         assertGrpcFailure(StatusCode.UNAVAILABLE) {
             runGrpcTest(clientCreds = clientTls, overrideAuthority = "foo.test.google.fr", test = ::defaultUnaryTest)
         }

grpc/grpc-core/src/jvmMain/kotlin/kotlinx/rpc/grpc/ManagedChannel.jvm.kt

@@ -27,15 +27,15 @@ internal actual fun ManagedChannelBuilder<*>.buildChannel(): ManagedChannel {
 internal actual fun ManagedChannelBuilder(
     hostname: String,
     port: Int,
-    credentials: ChannelCredentials?,
+    credentials: ClientCredentials?,
 ): ManagedChannelBuilder<*> {
     if (credentials != null) return io.grpc.Grpc.newChannelBuilderForAddress(hostname, port, credentials)
     return io.grpc.ManagedChannelBuilder.forAddress(hostname, port)
 }
 
 internal actual fun ManagedChannelBuilder(
     target: String,
-    credentials: ChannelCredentials?,
+    credentials: ClientCredentials?,
 ): ManagedChannelBuilder<*> {
     if (credentials != null) return io.grpc.Grpc.newChannelBuilder(target, credentials)
     return io.grpc.ManagedChannelBuilder.forTarget(target)

grpc/grpc-core/src/jvmMain/kotlin/kotlinx/rpc/grpc/credentials.jvm.kt

@@ -4,37 +4,37 @@
 
 package kotlinx.rpc.grpc
 
-public actual typealias ChannelCredentials = io.grpc.ChannelCredentials
+public actual typealias ClientCredentials = io.grpc.ChannelCredentials
 
 public actual typealias ServerCredentials = io.grpc.ServerCredentials
 
 // we need a wrapper for InsecureChannelCredentials as our constructor would conflict with the private
 // java constructor.
-public actual typealias InsecureChannelCredentials = io.grpc.InsecureChannelCredentials
+public actual typealias InsecureClientCredentials = io.grpc.InsecureChannelCredentials
 public actual typealias InsecureServerCredentials = io.grpc.InsecureServerCredentials
 
-public actual typealias TlsChannelCredentials = io.grpc.TlsChannelCredentials
+public actual typealias TlsClientCredentials = io.grpc.TlsChannelCredentials
 public actual typealias TlsServerCredentials = io.grpc.TlsServerCredentials
 
-internal actual fun TlsChannelCredentialsBuilder(): TlsChannelCredentialsBuilder =
-    object : TlsChannelCredentialsBuilder {
-        private var cb = TlsChannelCredentials.newBuilder()
+internal actual fun TlsClientCredentialsBuilder(): TlsClientCredentialsBuilder =
+    object : TlsClientCredentialsBuilder {
+        private var cb = TlsClientCredentials.newBuilder()
 
 
-        override fun trustManager(rootCertsPem: String): TlsChannelCredentialsBuilder {
+        override fun trustManager(rootCertsPem: String): TlsClientCredentialsBuilder {
             cb.trustManager(rootCertsPem.byteInputStream())
             return this
         }
 
         override fun keyManager(
             certChainPem: String,
             privateKeyPem: String,
-        ): TlsChannelCredentialsBuilder {
+        ): TlsClientCredentialsBuilder {
             cb.keyManager(certChainPem.byteInputStream(), privateKeyPem.byteInputStream())
             return this
         }
 
-        override fun build(): ChannelCredentials {
+        override fun build(): ClientCredentials {
             return cb.build()
         }
     }

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/ManagedChannel.native.kt

@@ -28,7 +28,7 @@ public actual abstract class ManagedChannelBuilder<T : ManagedChannelBuilder<T>>
 
 internal class NativeManagedChannelBuilder(
     private val target: String,
-    private var credentials: Lazy<ChannelCredentials>,
+    private var credentials: Lazy<ClientCredentials>,
 ) : ManagedChannelBuilder<NativeManagedChannelBuilder>() {
 
     private var authority: String? = null
@@ -61,14 +61,14 @@ internal actual fun ManagedChannelBuilder<*>.buildChannel(): ManagedChannel {
 internal actual fun ManagedChannelBuilder(
     hostname: String,
     port: Int,
-    credentials: ChannelCredentials?,
+    credentials: ClientCredentials?,
 ): ManagedChannelBuilder<*> {
-    val credentials = if (credentials == null) lazy { TlsChannelCredentials() } else lazy { credentials }
+    val credentials = if (credentials == null) lazy { TlsClientCredentials() } else lazy { credentials }
     return NativeManagedChannelBuilder(target = "$hostname:$port", credentials)
 }
 
-internal actual fun ManagedChannelBuilder(target: String, credentials: ChannelCredentials?): ManagedChannelBuilder<*> {
-    val credentials = if (credentials == null) lazy { TlsChannelCredentials() } else lazy { credentials }
+internal actual fun ManagedChannelBuilder(target: String, credentials: ClientCredentials?): ManagedChannelBuilder<*> {
+    val credentials = if (credentials == null) lazy { TlsClientCredentials() } else lazy { credentials }
     return NativeManagedChannelBuilder(target, credentials)
 }
 

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/credentials.native.kt

@@ -31,7 +31,7 @@ import libkgrpc.grpc_tls_server_credentials_create
 import kotlin.experimental.ExperimentalNativeApi
 import kotlin.native.ref.createCleaner
 
-public actual abstract class ChannelCredentials internal constructor(
+public actual abstract class ClientCredentials internal constructor(
     internal val raw: CPointer<grpc_channel_credentials>,
 ) {
     @Suppress("unused")
@@ -49,25 +49,25 @@ public actual abstract class ServerCredentials internal constructor(
     }
 }
 
-public actual class InsecureChannelCredentials internal constructor(
+public actual class InsecureClientCredentials internal constructor(
     raw: CPointer<grpc_channel_credentials>,
-) : ChannelCredentials(raw)
+) : ClientCredentials(raw)
 
 public actual class InsecureServerCredentials internal constructor(
     raw: CPointer<grpc_server_credentials>,
 ) : ServerCredentials(raw)
 
-public actual class TlsChannelCredentials internal constructor(
+public actual class TlsClientCredentials internal constructor(
     raw: CPointer<grpc_channel_credentials>,
-) : ChannelCredentials(raw)
+) : ClientCredentials(raw)
 
 public actual class TlsServerCredentials(
     raw: CPointer<grpc_server_credentials>,
 ) : ServerCredentials(raw)
 
 
-public fun InsecureChannelCredentials(): ChannelCredentials {
-    return InsecureChannelCredentials(
+public fun InsecureChannelCredentials(): ClientCredentials {
+    return InsecureClientCredentials(
         grpc_insecure_credentials_create() ?: error("grpc_insecure_credentials_create() returned null")
     )
 }
@@ -78,31 +78,31 @@ public fun InsecureServerCredentials(): ServerCredentials {
     )
 }
 
-internal actual fun TlsChannelCredentialsBuilder(): TlsChannelCredentialsBuilder =
-    object : TlsChannelCredentialsBuilder {
+internal actual fun TlsClientCredentialsBuilder(): TlsClientCredentialsBuilder =
+    object : TlsClientCredentialsBuilder {
         var optionsBuilder = TlsCredentialsOptionsBuilder()
 
-        override fun trustManager(rootCertsPem: String): TlsChannelCredentialsBuilder {
+        override fun trustManager(rootCertsPem: String): TlsClientCredentialsBuilder {
             optionsBuilder.trustManager(rootCertsPem)
             return this
         }
 
         override fun keyManager(
             certChainPem: String,
             privateKeyPem: String,
-        ): TlsChannelCredentialsBuilder {
+        ): TlsClientCredentialsBuilder {
             optionsBuilder.keyManager(certChainPem, privateKeyPem)
             return this
         }
 
-        override fun build(): ChannelCredentials {
+        override fun build(): ClientCredentials {
             val opts = optionsBuilder.build()
             val creds = grpc_tls_credentials_create(opts)
                 ?: run {
                     grpc_tls_credentials_options_destroy(opts);
                     error("TLS channel credential creation failed")
                 }
-            return TlsChannelCredentials(creds)
+            return TlsClientCredentials(creds)
         }
     }
 

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/internal/NativeManagedChannel.kt

@@ -19,7 +19,7 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancelChildren
 import kotlinx.coroutines.withTimeoutOrNull
-import kotlinx.rpc.grpc.ChannelCredentials
+import kotlinx.rpc.grpc.ClientCredentials
 import kotlinx.rpc.grpc.ManagedChannel
 import kotlinx.rpc.grpc.ManagedChannelPlatform
 import libkgrpc.GPR_CLOCK_REALTIME
@@ -48,7 +48,7 @@ internal class NativeManagedChannel(
     target: String,
     val authority: String?,
     // we must store them, otherwise the credentials are getting released
-    credentials: ChannelCredentials,
+    credentials: ClientCredentials,
 ) : ManagedChannel, ManagedChannelPlatform() {
 
     // a reference to make sure the grpc_init() was called. (it is released after shutdown)