RSocketServer (rsocket-core 1.1.1 API)

java.lang.Object
- io.rsocket.core.RSocketServer

public final class RSocketServer
extends Object

The main class for starting an RSocket server.

For example:


 CloseableChannel closeable =
         RSocketServer.create(SocketAcceptor.with(new RSocket() {...}))
                 .bind(TcpServerTransport.create("localhost", 7000))
                 .block();

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RSocketServer`	`acceptor(SocketAcceptor acceptor)` Set the acceptor to handle incoming connections and handle requests.
`ServerTransport.ConnectionAcceptor`	`asConnectionAcceptor()` An alternative to `bind(ServerTransport)` that is useful for installing RSocket on a server that is started independently.
`ServerTransport.ConnectionAcceptor`	`asConnectionAcceptor(int maxFrameLength)` An alternative to `bind(ServerTransport)` that is useful for installing RSocket on a server that is started independently.
`<T extends Closeable> Mono<T>`	`bind(ServerTransport<T> transport)` Start the server on the given transport.
`<T extends Closeable> T`	`bindNow(ServerTransport<T> transport)` Start the server on the given transport.
`static RSocketServer`	`create()` Static factory method to create an `RSocketServer`.
`static RSocketServer`	`create(SocketAcceptor acceptor)` Static factory method to create an `RSocketServer` instance with the given `SocketAcceptor`.
`RSocketServer`	`fragment(int mtu)` When this is set, frames larger than the given maximum transmission unit (mtu) size value are fragmented.
`RSocketServer`	`interceptors(Consumer<InterceptorRegistry> configurer)` Configure interception at one of the following levels: Transport level At the level of accepting new connections Performing requests Responding to requests
`RSocketServer`	`lease(Consumer<LeaseSpec> leaseConfigurer)` Enables the Lease feature of the RSocket protocol where the number of requests that can be performed from either side are rationed via `LEASE` frames from the responder side.
`RSocketServer`	`maxInboundPayloadSize(int maxInboundPayloadSize)` When this is set, frames reassembler control maximum payload size which can be reassembled.
`RSocketServer`	`payloadDecoder(PayloadDecoder decoder)` Configure the `PayloadDecoder` used to create `Payload`'s from incoming raw frame buffers.
`RSocketServer`	`resume(Resume resume)` Enables the Resume capability of the RSocket protocol where if the client gets disconnected, the connection is re-acquired and any interrupted streams are transparently resumed.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - create
```
public static RSocketServer create()
```
    Static factory method to create an RSocketServer.
  - create
```
public static RSocketServer create(SocketAcceptor acceptor)
```
    Static factory method to create an RSocketServer instance with the given SocketAcceptor. Effectively a shortcut for:
```
 RSocketServer.create().acceptor(...);
 
```
    Parameters:
    
    acceptor - the acceptor to handle connections with
    
    Returns:
    
    the same instance for method chaining
    
    See Also:
    
    acceptor(SocketAcceptor)
  - acceptor
```
public RSocketServer acceptor(SocketAcceptor acceptor)
```
    Set the acceptor to handle incoming connections and handle requests.
    An example with access to the SETUP frame and sending RSocket for performing requests back to the client if needed:
```
 RSocketServer.create((setup, sendingRSocket) -> Mono.just(new RSocket() {...}))
         .bind(TcpServerTransport.create("localhost", 7000))
         .subscribe();
 
```
    A shortcut to provide the handling RSocket only:
```
 RSocketServer.create(SocketAcceptor.with(new RSocket() {...}))
         .bind(TcpServerTransport.create("localhost", 7000))
         .subscribe();
 
```
    A shortcut to handle request-response interactions only:
```
 RSocketServer.create(SocketAcceptor.forRequestResponse(payload -> ...))
         .bind(TcpServerTransport.create("localhost", 7000))
         .subscribe();
 
```
    By default, new RSocket(){} is used for handling which rejects requests from the client with UnsupportedOperationException.
    Parameters:
    
    acceptor - the acceptor to handle incoming connections and requests with
    
    Returns:
    
    the same instance for method chaining
  - interceptors
```
public RSocketServer interceptors(Consumer<InterceptorRegistry> configurer)
```
    Configure interception at one of the following levels:
    - Transport level
    - At the level of accepting new connections
    - Performing requests
    - Responding to requests
    Parameters:
    
    configurer - a configurer to customize interception with.
    
    Returns:
    
    the same instance for method chaining
    
    See Also:
    
    LimitRateInterceptor
  - resume
```
public RSocketServer resume(Resume resume)
```
    Enables the Resume capability of the RSocket protocol where if the client gets disconnected, the connection is re-acquired and any interrupted streams are transparently resumed. For this to work clients must also support and request to enable this when connecting.
    Use the Resume argument to customize the Resume session duration, storage, retry logic, and others.
    By default this is not enabled.
    
    Parameters:
    
    resume - configuration for the Resume capability
    
    Returns:
    
    the same instance for method chaining
    
    See Also:
    
    Resuming Operation
  - lease
```
public RSocketServer lease(Consumer<LeaseSpec> leaseConfigurer)
```
    Enables the Lease feature of the RSocket protocol where the number of requests that can be performed from either side are rationed via LEASE frames from the responder side. For this to work clients must also support and request to enable this when connecting.
    Example usage:
```
 RSocketServer.create(SocketAcceptor.with(new RSocket() {...}))
         .lease(spec ->
            spec.sender(() -> Flux.interval(ofSeconds(1))
                                  .map(__ -> Lease.create(ofSeconds(1), 1)))
         )
         .bind(TcpServerTransport.create("localhost", 7000))
         .subscribe();
 
```
    By default this is not enabled.
    Parameters:
    
    leaseConfigurer - consumer which accepts LeaseSpec and use it for configuring
    
    Returns:
    
    the same instance for method chaining
    
    See Also:
    
    Lease Semantics
  - maxInboundPayloadSize
```
public RSocketServer maxInboundPayloadSize(int maxInboundPayloadSize)
```
    When this is set, frames reassembler control maximum payload size which can be reassembled.
    By default this is not set in which case maximum reassembled payloads size is not controlled.
    
    Parameters:
    
    maxInboundPayloadSize - the threshold size for reassembly, must no be less than 64 bytes. Please note, maxInboundPayloadSize must always be greater or equal to Transport.maxFrameLength(), otherwise inbound frame can exceed the maxInboundPayloadSize
    
    Returns:
    
    the same instance for method chaining
    
    See Also:
    
    Fragmentation and Reassembly
  - fragment
```
public RSocketServer fragment(int mtu)
```
    When this is set, frames larger than the given maximum transmission unit (mtu) size value are fragmented.
    By default this is not set in which case payloads are sent whole up to the maximum frame size of 16,777,215 bytes.
    
    Parameters:
    
    mtu - the threshold size for fragmentation, must be no less than 64
    
    Returns:
    
    the same instance for method chaining
    
    See Also:
    
    Fragmentation and Reassembly
  - payloadDecoder
```
public RSocketServer payloadDecoder(PayloadDecoder decoder)
```
    Configure the PayloadDecoder used to create Payload's from incoming raw frame buffers. The following decoders are available:
    - PayloadDecoder.DEFAULT -- the data and metadata are independent copies of the underlying frame ByteBuf
    - PayloadDecoder.ZERO_COPY -- the data and metadata are retained slices of the underlying ByteBuf. That's more efficient but requires careful tracking and release of the payload when no longer needed.
    By default this is set to PayloadDecoder.DEFAULT in which case data and metadata are copied and do not need to be tracked and released.
    Parameters:
    
    decoder - the decoder to use
    
    Returns:
    
    the same instance for method chaining
  - bind
```
public <T extends Closeable> Mono<T> bind(ServerTransport<T> transport)
```
    Start the server on the given transport.
    The following transports are available from additional RSocket Java modules:
    - TcpServerTransport via rsocket-transport-netty.
    - WebsocketServerTransport via rsocket-transport-netty.
    - LocalServerTransport via rsocket-transport-local
    Type Parameters:
    
    T - the type of Closeable for the given transport
    
    Parameters:
    
    transport - the transport of choice to connect with
    
    Returns:
    
    a Mono with a Closeable that can be used to obtain information about the server, stop it, or be notified of when it is stopped.
  - bindNow
```
public <T extends Closeable> T bindNow(ServerTransport<T> transport)
```
    Start the server on the given transport. Effectively is a shortcut for .bind(ServerTransport).block()
  - asConnectionAcceptor
```
public ServerTransport.ConnectionAcceptor asConnectionAcceptor()
```
    An alternative to bind(ServerTransport) that is useful for installing RSocket on a server that is started independently.
    
    See Also:
    
    io.rsocket.examples.transport.ws.WebSocketHeadersSample
  - asConnectionAcceptor
```
public ServerTransport.ConnectionAcceptor asConnectionAcceptor(int maxFrameLength)
```
    An alternative to bind(ServerTransport) that is useful for installing RSocket on a server that is started independently.
    
    See Also:
    
    io.rsocket.examples.transport.ws.WebSocketHeadersSample

Class RSocketServer

Method Summary

Methods inherited from class java.lang.Object

Method Detail

create

create

acceptor

interceptors

resume

lease

maxInboundPayloadSize

fragment

payloadDecoder

bind

bindNow

asConnectionAcceptor

asConnectionAcceptor