What is RSocket?
RSocket is a new communication protocol that addresses the problems that the current HTTP protocol faces. RSocket is a binary protocol used to transport byte streams such as TCP, WebSocket and Aeron. So what are the limitations of the HTTP protocol?
1 2 3 4 | - Nó chỉ support mô hình tương tác request/response - Không hiệu quả - Không reactive |
A modern architecture must support other communication models such as streaming and fire-and-forgot. HTTP (hypertext transfer protocol) is a text-base protocol useful for fetching documents over the internet, but for data centers this protocol is not effective. And the main problem is that HTTP is not reactive. Check out the FAQ section of HTTP / 2
1 2 | HTTP/1.x has a problem called “head-of-line blocking,” where effectively only one request can be outstanding on a connection at a time. |
1 2 | HTTP/1.1 tried to fix this with pipelining, but it didn’t completely address the problem (a large or slow response can still block others behind it). Additionally, pipelining has been found very difficult to deploy, because many intermediaries and servers don’t process it correctly. |
Rsocket is a message-base protocol and requires a few lower-level transport protocols to carry messages. Rsocket define 4 types of communication:
1 2 3 4 5 | 1. Request / Response 2. Fire And Forget 3. Request / Stream 4. Channel |
Terms in RSocket:
Frame:
Frame is a single message containing 1 request, response, or protocol processing.
Fragment:
As part of the message application, part has been included in the frame. See more about fragmentation and reassembly here
Transport:
The protocol for carrying the Rscoket protocol, this can be Websocket, TCP or Aeron
Stream:
Stream is understood as a calculation unit (can be request or response or …)
Request:
As a stream request, can be one of the 4 types I mentioned above
1 2 3 4 5 | 1. Request / Response 2. Fire And Forget 3. Request / Stream 4. Channel |
Payload:
A stream message (upstream or downstream). Contains data associated with a stream created by a previous request. In Reactive Streams and Rx this is the ‘onNext’ event.
Complete:
1 event was sent to the stream to notify the completion of the success. In Reactive Streams and Rx, what is an onComplete event?
1 2 | A frame (PAYLOAD or REQUEST_CHANNEL) with the Complete bit set is sometimes referred to as COMPLETE in this document when reference to the frame is semantically about the Complete bit/event. |
Client:
The side initiating a connection.
Server:
The side accepting connections from clients.
Connection:
The instance of a transport session between client and server.
Requester:
The side sending a request. A connection has at most 2 Requesters. One in each direction.
Responder:
The side receiving a request. A connection has at most 2 Responders. One in each direction.
Data And Metadata
RSocket provides a mechanism for the application to distinguish whether payload is data or metadata. Data and MetaData features:
- Metadata can be encoded registering than Data.
- Metadata can be “attached” (ie correlated) with the following entities:
- Connection via Metadata Push and Stream ID of 0
- Individual Request or Payload (upstream or downstream)
Framing
Transport Protocol:
RSocket protocol uses transport lower level protocol to carry RSocket frames. A transport protocol must provide the following information:
- Unicast Reliable Delivery .
- Connection-Oriented and preservation of frame ordering. Frame A sent before Frame B MUST arrive in source order. ie if Frame A is sent by the same source as Frame B, then Frame A will always arrive before Frame B. No assumptions about ordering across sources is assumed.
- FCS is assumed to be in use either at the transport protocol or at each MAC layer hop. But no protection against malicious corruption is assumed.
Framing Format:
When the transport protocol provides framing, the RSocket frame is packed into the transport protocol message:
1 2 3 4 5 | +-----------------------------------------------+ | RSocket Frame ... | +-----------------------------------------------+ |
When using a transport protocol that does not provide a compatible frame, LENGTH frames must be added to the RSocket frame.
1 2 3 4 5 6 7 8 9 | 0 1 2 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Frame Length | +-----------------------------------------------+ | RSocket Frame ... | +-----------------------------------------------+ |
- Frame Length: (24 bits = max value 16,777,215) Unsigned 24-bit integer representing the length of Frame in bytes. Excluding the Frame Length field.
Frame Header:
All RSocket Frames start with the frame header, the frame header will include Stream ID, Frame Type, and flags information. 2 Flag (I) gnore and (M) etadata will always be present
1 2 3 4 5 6 7 8 | 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |0| Stream ID | +-----------+-+-+---------------+-------------------------------+ |Frame Type |I|M| Flags | Depends on Frame Type ... +-------------------------------+ |
- Stream ID : (31 bits = max value 2 ^ 31-1 = 2,147,483,647) Unsigned 31-bit integer representing the stream Identifier for this frame or 0 to indicate the entire connection. Transport protocols that include demultiplexing, such as HTTP / 2, MAY omit the Stream ID field if all parties agree. The means of negotiation and agreement is left to the transport protocol.
- Frame Type : (6 bits = max value 63) Type of Frame.
- Flags : (10 bits) Any Flag bit not specifically indicated in the frame type should be set to 0 when sent and not interpreted on reception. Flags generally depend on Frame Type, but all frame types MUST provide space for the following flags: (I) gnore: Ignore frame if not understood (M) etadata: Metadata present
Connection Setup:
The client must connect to the server to set up a connection. When the connection is established, it will send the SETUP frame. Assuming the transport protocol is TCP, the SETUP frame will look like the following (if not reused):
1 2 3 4 5 6 7 8 | +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| 00 00 28 00 00 00 00 04 00 00 01 00 00 00 00 4e |..(............N| |00000010| 20 00 01 5f 90 0a 74 65 78 74 2f 70 6c 61 69 6e | .._..text/plain| |00000020| 0a 74 65 78 74 2f 70 6c 61 69 6e |.text/plain | +--------+-------------------------------------------------+----------------+ |
Request / Response:
Request / Response is the most popular interactive model, but for RSocket as well as Reactive Stream, this is a special case of Request / Stream – in which the response stream has only 1 element or 1 frame. Requester sends 1 request frame and responder reply 1 stream of one frame
The request frame has a Stream ID and a frame type (in this case, REQUEST_RESPONSE). If the client initiates stream ID, it is an odd number and begins with 1 for the first stream, the server uses even stream IDs starting with 2. The following is an example of request / response using TCP. The client is a requester sending a “Hello World!” for server and server to send that message.
1 2 3 4 5 6 7 | +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| 00 00 12 00 00 00 01 10 00 48 65 6c 6c 6f 20 57 |.........Hello W| |00000010| 6f 72 6c 64 21 |orld! | +--------+-------------------------------------------------+----------------+ |
And here is the response from the server:
1 2 3 4 5 6 7 | +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| 00 00 12 00 00 00 01 28 60 48 65 6c 6c 6f 20 57 |.......(`Hello W| |00000010| 6f 72 6c 64 21 |orld! | +--------+-------------------------------------------------+----------------+ |
Demo
The theory above seems confusing and headache. Ok now I try the Request / Response demo (Using Spring boot)
Create Project:
Create a normal Spring boot project like any other project, pay attention to some information below:
Dependency
1 2 3 4 5 6 7 8 9 10 11 | <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-rsocket</artifactId> <version>2.3.1.RELEASE</version> </dependency> |
Here I use lombok for fast, and must have dependency is rsocket
application.properties:
Define port for rsocket to connet to
1 2 3 | spring.rsocket.server.port=7000 spring.main.lazy-initialization=true |
Controller:
Here I create a RsocketController controller, the endpoint is the request-response receives a String request and returns a String Hello + request.
1 2 3 4 5 6 7 8 9 10 11 12 13 | @Controller @Slf4j public class RsocketController { private static final String SERVER = "Serverx"; private static final String RESPONSE = "ResponseX"; @MessageMapping("request-response") String requestResponse(String request) { log.info("Received request-response request: {}", request); return " Hello " + request; } } |
Result:
OK, that’s it. To start the demo request response, start the project: ./mvnw clean package spring-boot:run -DskipTests => Result:
1 2 3 4 5 | 2020-07-22 21:12:30.415 INFO 5274 --- [ main] c.e.rsocketcli.RsocketCliApplication : No active profile set, falling back to default profiles: default 2020-07-22 21:12:31.041 INFO 5274 --- [ main] o.s.b.web.embedded.netty.NettyWebServer : Netty started on port(s): 8080 2020-07-22 21:12:31.050 INFO 5274 --- [ main] o.s.b.rsocket.netty.NettyRSocketServer : Netty RSocket started on port(s): 7000 2020-07-22 21:12:31.074 INFO 5274 --- [ main] c.e.rsocketcli.RsocketCliApplication : Started RsocketCliApplication in 0.961 seconds (JVM running for 1.208) |
=> Ok, Port 7000 has started, now I need to send a command to port 7000 using Rsocket CLI: To use Rsocket CLI, you clone the jar file here about it:
1 2 | wget -O rsc.jar https://github.com/making/rsc/releases/download/0.4.2/rsc-0.4.2.jar |
Then cd to the folder that downloaded the jar file and call the endpoint request-response with the data request as the rsocket client :
1 2 | java -jar rsc.jar --debug --request --data "rsocket client" --route request-response tcp://localhost:7000 |
=> The result will look like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | jav $ java -jar rsc.jar --debug --request --data "rsocket client" --route request-response tcp://localhost:7000 2020-07-22 21:16:34.391 DEBUG --- [actor-tcp-nio-1] i.r.FrameLogger : sending -> Frame => Stream ID: 1 Type: REQUEST_RESPONSE Flags: 0b100000000 Length: 40 Metadata: +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| 10 72 65 71 75 65 73 74 2d 72 65 73 70 6f 6e 73 |.request-respons| |00000010| 65 |e | +--------+-------------------------------------------------+----------------+ Data: +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| 72 73 6f 63 6b 65 74 20 63 6c 69 65 6e 74 |rsocket client | +--------+-------------------------------------------------+----------------+ 2020-07-22 21:16:34.449 DEBUG --- [actor-tcp-nio-1] i.r.FrameLogger : receiving -> Frame => Stream ID: 1 Type: NEXT_COMPLETE Flags: 0b1100000 Length: 27 Data: +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| 20 48 65 6c 6c 6f 20 72 73 6f 63 6b 65 74 20 63 | Hello rsocket c| |00000010| 6c 69 65 6e 74 |lient | +--------+-------------------------------------------------+----------------+ Hello rsocket client |
Looking at the request section you will see Frame => Stream ID: 1 Type: REQUEST_RESPONSE Flags: 0b100000000 Length: 40 , the type here is REQUEST_RESPONSE And the data request is an rsocket client string rsocket client :
1 2 3 | | 0 1 2 3 4 5 6 7 8 9 a b c d e f | |00000000| 72 73 6f 63 6b 65 74 20 63 6c 69 65 6e 74 | |
Receive a response whose type is Type: NEXT_COMPLETE , and data is Hello rsocket c and lient :
1 2 3 4 | | 0 1 2 3 4 5 6 7 8 9 a b c d e f | |00000000| 20 48 65 6c 6c 6f 20 72 73 6f 63 6b 65 74 20 63 | => Hello rsocket c |00000010| 6c 69 65 6e 74 | => lient |
Explain
OK, now I explain it a bit here: Rsocket client (rsc.jar download above) will send a request message to RsocketController using RSocket message protocol. The message is sent via TCP to the address localhost:7000 where the server has been deployed. A routing routing instruction will be sent in the first message frame (corresponding to the –route option) it will send request-response
1 2 3 4 5 6 7 | +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| 10 72 65 71 75 65 73 74 2d 72 65 73 70 6f 6e 73 |.request-respons| |00000010| 65 |e | +--------+-------------------------------------------------+----------------+ |
Spring will use this routing information to select the correct @MessageMapping endpoint to call, in this case the requestResponse(String request) . This method will respond to a String, and the CLI client prints all interactions in the terminal, a series of message frames
1 2 3 4 5 6 7 8 | +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| 20 48 65 6c 6c 6f 20 72 73 6f 63 6b 65 74 20 63 | Hello rsocket c| |00000010| 6c 69 65 6e 74 |lient | +--------+-------------------------------------------------+----------------+ Hello rsocket client |
Summary:
OK, here I just want to introduce about RSocket, and a small demo to understand, There are some terms and definitions that I don’t know how to translate so I understand the original. 
. You should look to the source page to read for ease In the next article I will demo the connection types of RSocket on the application layer instead of going into this.
Refer:
https://rsocket.io/docs/Protocol.html https://dzone.com/articles/an-introduction-to-rsocket