RPC Clients

For each declared service, kotlinx.rpc will generate an actual client implementation that can be used to send requests to a server. You must not use generated code directly. Instead, you should use the APIs that will provide you with the instance of your interface. This generated instance is commonly called a stub in RPC.

tip

Note that we talk about generated stubs (service implementations on the client side) that must not be called directly. There might be a case when the generated code is not a stub, but a service declaration itself (for example, the services generated from .proto files). In this case, you can use the generated code.

To be able to obtain an instance of your service, you need to have an RpcClient. You can call the withService() method on your client:

val rpcClient: RpcClient

val myService: MyService = rpcClient.withService<MyService>()

Now you have your client instance that is able to send RPC requests to your server. RpcClient can have multiple services that communicate through it. Conceptually, RpcClient is an abstraction of a client, that is able to convent service requests (represented by the RpcCall class) into actual network requests.

You can provide your own implementations of the RpcClient. But kotlinx.rpc already provides one out-of-the-box solution that uses in-house RPC protocol (called kRPC), and we are working on supporting more protocols (with priority on gRPC).

class MySimpleRpcTransport : KrpcTransport {
    val outChannel = Channel<KrpcTransportMessage>()
    val inChannel = Channel<KrpcTransportMessage>()

    override val coroutineContext: CoroutineContext = Job()

    override suspend fun send(message: KrpcTransportMessage) {
        outChannel.send(message)
    }

    override suspend fun receive(): KrpcTransportMessage {
        return inChannel.receive()
    }
}

class MySimpleRpcClient : KrpcClient(rpcClientConfig(), MySimpleRpcTransport())

val client = MySimpleRpcClient()
val service: MyService = client.withService<MyService>()