Reworks configuration API using builders instead of data classes (#113)

* Introduce transports API (so reconnect and resume will be easier to support from client side)
* rename plugin to interceptor
* remove for now server TCP transport support

Author: whyoleg

README.md

@@ -17,7 +17,7 @@ Transports are implemented based on [ktor](https://github.com/ktorio/ktor) to en
 So it depends on `ktor` engines for available transports and platforms (JVM, JS, Native):
 * JVM - TCP and WebSocket for both client and server
 * JS - WebSocket client only
-* Native - TCP for both client and server (linux x64, macos, ios, watchos, tvos)
+* Native - TCP client only (linux x64, macos, ios, watchos, tvos)
 
 ## Interactions
 
@@ -113,27 +113,30 @@ dependencies {
 //create ktor client
 val client = HttpClient(CIO) {
     install(WebSockets)
-    install(RSocketClientSupport) {
-        //configure rSocket client (all values have defaults)
-        
-        keepAlive = KeepAlive(
-            interval = 30.seconds,
-            maxLifetime = 2.minutes 
-        )
-        
-        //payload for setup frame
-        setupPayload = Payload(...)
+    install(RSocketSupport) {
+        connector = RSocketConnector {
+            //configure rSocket connector (all values have defaults)
+            connectionConfig {
+                keepAlive = KeepAlive(
+                    interval = 30.seconds,
+                    maxLifetime = 2.minutes 
+                )
+
+                //payload for setup frame
+                setupPayload { Payload("hello world") }
+                
+                //mime types
+                payloadMimeType = PayloadMimeType(
+                    data = "application/json",
+                    metadata = "application/json"
+                )
+            }
 
-        //mime types
-        payloadMimeType = PayloadMimeType(
-            data = "application/json",
-            metadata = "application/json"
-        )   
-        
-        //optional acceptor for server requests
-        acceptor = {
-            RSocketRequestHandler {
-                requestResponse = { it } //echo request payload
+            //optional acceptor for server requests
+            acceptor {
+                RSocketRequestHandler {
+                    requestResponse { it } //echo request payload
+                }
             }
         }
     }   
@@ -156,27 +159,28 @@ stream.take(5).collect { payload: Payload ->
 ```kotlin
 //create ktor server
 embeddedServer(CIO) {
-    install(RSocketServerSupport) {
+    install(RSocketSupport) {
         //configure rSocket server (all values have defaults)
-        
-        //install interceptors
-        plugin = Plugin(
-            connection = listOf(::SomeConnectionInterceptor)
-        )   
+        server = RSocketServer {
+            //install interceptors
+            interceptors {
+                forConnection(::SomeConnectionInterceptor)
+            }
+        }
     }   
     //configure routing
     routing {
         //configure route `url:port/rsocket`
         rSocket("rsocket") {
             RSocketRequestHandler {
                 //handler for request/response
-                requestResponse = { request: Payload ->
+                requestResponse { request: Payload ->
                     //... some work here
                     delay(500) // work emulation
                     Payload("data", "metadata")
                 }         
                 //handler for request/stream      
-                requestStream = { request: Payload ->
+                requestStream { request: Payload ->
                     flow {
                         repeat(1000) { i -> 
                             emit(Payload("data: $i"))

benchmarks/src/kotlinMain/kotlin/io/rsocket/kotlin/benchmarks/RSocketKotlinBenchmark.kt

@@ -16,13 +16,11 @@
 
 package io.rsocket.kotlin.benchmarks
 
-import io.ktor.utils.io.core.*
 import io.rsocket.kotlin.*
-import io.rsocket.kotlin.connection.*
 import io.rsocket.kotlin.core.*
 import io.rsocket.kotlin.payload.*
+import io.rsocket.kotlin.transport.local.*
 import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.*
 import kotlinx.coroutines.flow.*
 import kotlin.random.*
 
@@ -38,28 +36,22 @@ class RSocketKotlinBenchmark : RSocketBenchmark<Payload>() {
         payload = createPayload(payloadSize)
         payloadsFlow = flow { repeat(5000) { emit(payload.copy()) } }
 
-        val clientChannel = Channel<ByteReadPacket>(Channel.UNLIMITED)
-        val serverChannel = Channel<ByteReadPacket>(Channel.UNLIMITED)
-        val serverConnection = LocalConnection("server", clientChannel, serverChannel)
-        val clientConnection = LocalConnection("client", serverChannel, clientChannel)
-
-        client = runBlocking {
-            launch {
-                server = RSocketServer(ConnectionProvider(serverConnection)).start {
-                    RSocketRequestHandler {
-                        requestResponse = {
-                            it.release()
-                            payload
-                        }
-                        requestStream = {
-                            it.release()
-                            payloadsFlow
-                        }
-                        requestChannel = { it }
-                    }
+        val localServer = LocalServer()
+        server = RSocketServer().bind(localServer) {
+            RSocketRequestHandler {
+                requestResponse {
+                    it.release()
+                    payload
+                }
+                requestStream {
+                    it.release()
+                    payloadsFlow
                 }
+                requestChannel { it }
             }
-            RSocketConnector(ConnectionProvider(clientConnection)).connect()
+        }
+        return runBlocking {
+            RSocketConnector().connect(localServer)
         }
     }
 

examples/interactions/src/jvmMain/kotlin/RequestChannelExample.kt

@@ -15,33 +15,30 @@
  */
 
 import io.rsocket.kotlin.*
-import io.rsocket.kotlin.connection.*
+import io.rsocket.kotlin.core.*
 import io.rsocket.kotlin.payload.*
+import io.rsocket.kotlin.transport.local.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 
 
 fun main(): Unit = runBlocking {
-    val (clientConnection, serverConnection) = SimpleLocalConnection()
-
-    launch {
-        serverConnection.startServer {
-            RSocketRequestHandler {
-                requestChannel = { request ->
-                    request.buffer(3).take(3).flatMapConcat { payload ->
-                        val data = payload.data.readText()
-                        flow {
-                            repeat(3) {
-                                emit(Payload("$data(copy $it)"))
-                            }
+    val server = LocalServer()
+    RSocketServer().bind(server) {
+        RSocketRequestHandler {
+            requestChannel { request ->
+                request.buffer(3).take(3).flatMapConcat { payload ->
+                    val data = payload.data.readText()
+                    flow {
+                        repeat(3) {
+                            emit(Payload("$data(copy $it)"))
                         }
                     }
                 }
             }
         }
     }
-
-    val rSocket = clientConnection.connectClient()
+    val rSocket = RSocketConnector().connect(server)
 
     val request = flow {
         emit(Payload("Hello"))

examples/interactions/src/jvmMain/kotlin/RequestResponseErrorExample.kt

@@ -15,26 +15,23 @@
  */
 
 import io.rsocket.kotlin.*
-import io.rsocket.kotlin.connection.*
+import io.rsocket.kotlin.core.*
 import io.rsocket.kotlin.payload.*
+import io.rsocket.kotlin.transport.local.*
 import kotlinx.coroutines.*
 
 fun main(): Unit = runBlocking {
-    val (clientConnection, serverConnection) = SimpleLocalConnection()
-
-    launch {
-        serverConnection.startServer {
-            RSocketRequestHandler {
-                requestResponse = {
-                    val data = it.data.readText()
-                    if ("hello" in data) Payload("hello client")
-                    else error("I don't understand you")
-                }
+    val server = LocalServer()
+    RSocketServer().bind(server) {
+        RSocketRequestHandler {
+            requestResponse {
+                val data = it.data.readText()
+                if ("hello" in data) Payload("hello client")
+                else error("I don't understand you")
             }
         }
     }
-
-    val rSocket = clientConnection.connectClient()
+    val rSocket = RSocketConnector().connect(server)
 
     val response = rSocket.requestResponse(Payload("hello server"))
 

examples/interactions/src/jvmMain/kotlin/RequestResponseExample.kt

@@ -15,28 +15,25 @@
  */
 
 import io.rsocket.kotlin.*
-import io.rsocket.kotlin.connection.*
+import io.rsocket.kotlin.core.*
 import io.rsocket.kotlin.payload.*
+import io.rsocket.kotlin.transport.local.*
 import kotlinx.coroutines.*
 
 fun main(): Unit = runBlocking {
-    val (clientConnection, serverConnection) = SimpleLocalConnection()
-
-    launch {
-        serverConnection.startServer {
-            RSocketRequestHandler {
-                requestResponse = {
-                    val data = it.data.readText()
-                    val metadata = it.metadata?.readText()
-                    println("Server received payload: data=$data, metadata=$metadata")
-
-                    Payload(data.repeat(3), "SERVER_METADATA") //response
-                }
+    val server = LocalServer()
+    RSocketServer().bind(server) {
+        RSocketRequestHandler {
+            requestResponse {
+                val data = it.data.readText()
+                val metadata = it.metadata?.readText()
+                println("Server received payload: data=$data, metadata=$metadata")
+
+                Payload(data.repeat(3), "SERVER_METADATA") //response
             }
         }
     }
-
-    val rSocket = clientConnection.connectClient()
+    val rSocket = RSocketConnector().connect(server)
 
     val response = rSocket.requestResponse(Payload("Hello", "World"))
 

examples/interactions/src/jvmMain/kotlin/RequestStreamExample.kt

@@ -15,39 +15,36 @@
  */
 
 import io.rsocket.kotlin.*
-import io.rsocket.kotlin.connection.*
+import io.rsocket.kotlin.core.*
 import io.rsocket.kotlin.payload.*
+import io.rsocket.kotlin.transport.local.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 
 fun main(): Unit = runBlocking {
-    val (clientConnection, serverConnection) = SimpleLocalConnection()
+    val server = LocalServer()
+    RSocketServer().bind(server) {
+        RSocketRequestHandler {
+            requestStream {
+                val data = it.data.readText()
+                val metadata = it.metadata?.readText()
+                println("Server received payload: data=$data, metadata=$metadata")
 
-    launch {
-        serverConnection.startServer {
-            RSocketRequestHandler {
-                requestStream = {
-                    val data = it.data.readText()
-                    val metadata = it.metadata?.readText()
-                    println("Server received payload: data=$data, metadata=$metadata")
-
-                    flow {
-                        repeat(10) { i ->
-                            emit(Payload("Payload: $i", metadata))
-                            println("Server sent: $i")
-                        }
+                flow {
+                    repeat(10) { i ->
+                        emit(Payload("Payload: $i", metadata))
+                        println("Server sent: $i")
                     }
                 }
             }
         }
     }
-
-    val rSocket = clientConnection.connectClient()
+    val rSocket = RSocketConnector().connect(server)
 
     val response = rSocket.requestStream(Payload("Hello", "World"))
 
     response
-        .buffer(2) //use buffer as first operator to use RequestN semantic
+        .buffer(2) //use buffer as first operator to use RequestN semantic, so request by 2 elements
         .map { it.data.readText().substringAfter("Payload: ").toInt() }
         .take(2)
         .collect {

examples/interactions/src/jvmMain/kotlin/ServerRequestExample.kt

@@ -15,42 +15,36 @@
  */
 
 import io.rsocket.kotlin.*
-import io.rsocket.kotlin.connection.*
 import io.rsocket.kotlin.core.*
 import io.rsocket.kotlin.payload.*
+import io.rsocket.kotlin.transport.local.*
 import kotlinx.coroutines.*
 
 fun main(): Unit = runBlocking {
-    val (clientConnection, serverConnection) = SimpleLocalConnection()
-
-    launch {
-        serverConnection.startServer { clientRSocket ->
-            RSocketRequestHandler {
-                requestResponse = {
-                    val clientRequest = it.data.readText()
-                    println("Server got from client request: $clientRequest")
-                    val response = clientRSocket.requestResponse(Payload("What happens?"))
-                    val clientResponse = response.data.readText()
-                    println("Server got from client response: $clientResponse")
-                    Payload("I'm frustrated because of `$clientResponse`")
-                }
+    val server = LocalServer()
+    RSocketServer().bind(server) {
+        RSocketRequestHandler {
+            requestResponse {
+                val clientRequest = it.data.readText()
+                println("Server got from client request: $clientRequest")
+                val response = requester.requestResponse(Payload("What happens?"))
+                val clientResponse = response.data.readText()
+                println("Server got from client response: $clientResponse")
+                Payload("I'm frustrated because of `$clientResponse`")
             }
         }
     }
-
-    val rSocket = clientConnection.connectClient(
-        RSocketConnectorConfiguration(
-            acceptor = {
-                RSocketRequestHandler {
-                    requestResponse = {
-                        val serverRequest = it.data.readText()
-                        println("Client got from server request: $serverRequest")
-                        Payload("I'm client!")
-                    }
+    val rSocket = RSocketConnector {
+        acceptor {
+            RSocketRequestHandler {
+                requestResponse {
+                    val serverRequest = it.data.readText()
+                    println("Client got from server request: $serverRequest")
+                    Payload("I'm client!")
                 }
             }
-        )
-    )
+        }
+    }.connect(server)
 
     val response = rSocket.requestResponse(Payload("How are you server?"))
     val data = response.data.readText()