io.rsocket

Class RSocketFactory.ClientRSocketFactory

java.lang.Object

io.rsocket.RSocketFactory.ClientRSocketFactory

All Implemented Interfaces:

RSocketFactory.ClientTransportAcceptor

Enclosing class:

RSocketFactory

public static class RSocketFactory.ClientRSocketFactory
extends Object
implements RSocketFactory.ClientTransportAcceptor

Factory to create and configure an RSocket client, and connect to a server.

Constructor Summary

Constructors

Constructor and Description
ClientRSocketFactory()
ClientRSocketFactory(RSocketConnector connector)

Method Summary

Modifier and Type	Method and Description
RSocketFactory.ClientTransportAcceptor	acceptor(Function<RSocket,RSocket> acceptor)
RSocketFactory.ClientTransportAcceptor	acceptor(SocketAcceptor acceptor)
RSocketFactory.ClientTransportAcceptor	acceptor(Supplier<Function<RSocket,RSocket>> acceptorSupplier)
RSocketFactory.ClientRSocketFactory	addClientPlugin(RSocketInterceptor interceptor) Deprecated.
RSocketFactory.ClientRSocketFactory	addConnectionPlugin(DuplexConnectionInterceptor interceptor)
RSocketFactory.ClientRSocketFactory	addRequesterPlugin(RSocketInterceptor interceptor)
RSocketFactory.ClientRSocketFactory	addResponderPlugin(RSocketInterceptor interceptor)
RSocketFactory.ClientRSocketFactory	addServerPlugin(RSocketInterceptor interceptor) Deprecated.
RSocketFactory.ClientRSocketFactory	addSocketAcceptorPlugin(SocketAcceptorInterceptor interceptor)
RSocketFactory.ClientRSocketFactory	byteBufAllocator(ByteBufAllocator allocator) Deprecated. this method is deprecated and deliberately has no effect anymore. Right now, in order configure the custom ByteBufAllocator it is recommended to use the following setup for Reactor Netty based transport: 1. For Client: TcpClient.create() ... .bootstrap(bootstrap -> bootstrap.option(ChannelOption.ALLOCATOR, clientAllocator)) 2. For server: TcpServer.create() ... .bootstrap(serverBootstrap -> serverBootstrap.childOption(ChannelOption.ALLOCATOR, serverAllocator)) Or in case of local transport, to use corresponding factory method LocalClientTransport.creat(String, ByteBufAllocator)
RSocketFactory.ClientRSocketFactory	dataMimeType(String dataMimeType)
RSocketFactory.ClientRSocketFactory	errorConsumer(Consumer<Throwable> errorConsumer) Deprecated. this is deprecated with no replacement.
RSocketFactory.ClientRSocketFactory	fragment(int mtu)
RSocketFactory.ClientRSocketFactory	frameDecoder(PayloadDecoder payloadDecoder)
RSocketFactory.ClientRSocketFactory	keepAlive() Deprecated.
RSocketFactory.ClientTransportAcceptor	keepAlive(Duration tickPeriod, Duration ackTimeout, int missedAcks)
RSocketFactory.ClientRSocketFactory	keepAliveAckTimeout(Duration ackTimeout)
RSocketFactory.ClientRSocketFactory	keepAliveMissedAcks(int missedAcks)
RSocketFactory.ClientRSocketFactory	keepAliveTickPeriod(Duration tickPeriod)
RSocketFactory.ClientRSocketFactory	lease()
RSocketFactory.ClientRSocketFactory	lease(Supplier<Leases<? extends LeaseStats>> supplier)
RSocketFactory.ClientRSocketFactory	metadataMimeType(String metadataMimeType)
RSocketFactory.ClientRSocketFactory	mimeType(String metadataMimeType, String dataMimeType)
RSocketFactory.ClientRSocketFactory	reconnect(Retry retrySpec) Enables a reconnectable, shared instance of Mono<RSocket> so every subscriber will observe the same RSocket instance up on connection establishment.
RSocketFactory.ClientRSocketFactory	resume()
RSocketFactory.ClientRSocketFactory	resumeCleanupOnKeepAlive()
RSocketFactory.ClientRSocketFactory	resumeSessionDuration(Duration sessionDuration)
RSocketFactory.ClientRSocketFactory	resumeStore(Function<? super ByteBuf,? extends ResumableFramesStore> storeFactory)
RSocketFactory.ClientRSocketFactory	resumeStrategy(Supplier<ResumeStrategy> strategy)
RSocketFactory.ClientRSocketFactory	resumeStreamTimeout(Duration streamTimeout)
RSocketFactory.ClientRSocketFactory	resumeToken(Supplier<ByteBuf> supplier)
RSocketFactory.ClientRSocketFactory	setupPayload(Payload payload)
RSocketFactory.ClientRSocketFactory	singleSubscriberRequester() Deprecated. without a replacement and no longer used.
RSocketFactory.Start<RSocket>	transport(Supplier<ClientTransport> transport)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.rsocket.RSocketFactory.ClientTransportAcceptor

transport

Constructor Detail

ClientRSocketFactory

public ClientRSocketFactory()

ClientRSocketFactory

public ClientRSocketFactory(RSocketConnector connector)

Method Detail

byteBufAllocator

public RSocketFactory.ClientRSocketFactory byteBufAllocator(ByteBufAllocator allocator)

Deprecated. this method is deprecated and deliberately has no effect anymore. Right now, in order configure the custom ByteBufAllocator it is recommended to use the following setup for Reactor Netty based transport:
1. For Client:

 TcpClient.create()
          ...
          .bootstrap(bootstrap -> bootstrap.option(ChannelOption.ALLOCATOR, clientAllocator))
 

2. For server:

 TcpServer.create()
          ...
          .bootstrap(serverBootstrap -> serverBootstrap.childOption(ChannelOption.ALLOCATOR, serverAllocator))
 

Or in case of local transport, to use corresponding factory method LocalClientTransport.creat(String, ByteBufAllocator)

Parameters:

allocator - instance of ByteBufAllocator

Returns:

this factory instance

addConnectionPlugin

public RSocketFactory.ClientRSocketFactory addConnectionPlugin(DuplexConnectionInterceptor interceptor)

addClientPlugin

@Deprecated
public RSocketFactory.ClientRSocketFactory addClientPlugin(RSocketInterceptor interceptor)

Deprecated.

Deprecated. Use addRequesterPlugin(RSocketInterceptor) instead

addRequesterPlugin

public RSocketFactory.ClientRSocketFactory addRequesterPlugin(RSocketInterceptor interceptor)

addServerPlugin

@Deprecated
public RSocketFactory.ClientRSocketFactory addServerPlugin(RSocketInterceptor interceptor)

Deprecated.

Deprecated. Use addResponderPlugin(RSocketInterceptor) instead

addResponderPlugin

public RSocketFactory.ClientRSocketFactory addResponderPlugin(RSocketInterceptor interceptor)

addSocketAcceptorPlugin

public RSocketFactory.ClientRSocketFactory addSocketAcceptorPlugin(SocketAcceptorInterceptor interceptor)

keepAlive

@Deprecated
public RSocketFactory.ClientRSocketFactory keepAlive()

Deprecated.

Deprecated without replacement as Keep-Alive is not optional according to spec

Returns:

this ClientRSocketFactory

keepAlive

public RSocketFactory.ClientTransportAcceptor keepAlive(Duration tickPeriod,
                                                        Duration ackTimeout,
                                                        int missedAcks)

keepAliveTickPeriod

public RSocketFactory.ClientRSocketFactory keepAliveTickPeriod(Duration tickPeriod)

keepAliveAckTimeout

public RSocketFactory.ClientRSocketFactory keepAliveAckTimeout(Duration ackTimeout)

keepAliveMissedAcks

public RSocketFactory.ClientRSocketFactory keepAliveMissedAcks(int missedAcks)

mimeType

public RSocketFactory.ClientRSocketFactory mimeType(String metadataMimeType,
                                                    String dataMimeType)

dataMimeType

public RSocketFactory.ClientRSocketFactory dataMimeType(String dataMimeType)

metadataMimeType

public RSocketFactory.ClientRSocketFactory metadataMimeType(String metadataMimeType)

lease

public RSocketFactory.ClientRSocketFactory lease(Supplier<Leases<? extends LeaseStats>> supplier)

lease

public RSocketFactory.ClientRSocketFactory lease()

singleSubscriberRequester

@Deprecated
public RSocketFactory.ClientRSocketFactory singleSubscriberRequester()

Deprecated. without a replacement and no longer used.

reconnect

public RSocketFactory.ClientRSocketFactory reconnect(Retry retrySpec)

Enables a reconnectable, shared instance of Mono<RSocket> so every subscriber will observe the same RSocket instance up on connection establishment.
For example:

 Mono<RSocket> sharedRSocketMono =
   RSocketFactory
                .connect()
                .reconnect(Retry.fixedDelay(3, Duration.ofSeconds(1)))
                .transport(transport)
                .start();

  RSocket r1 = sharedRSocketMono.block();
  RSocket r2 = sharedRSocketMono.block();

  assert r1 == r2;

 

Apart of the shared behavior, if the connection is lost, the same Mono<RSocket> instance will transparently re-establish the connection for subsequent subscribers.
For example:

 Mono<RSocket> sharedRSocketMono =
   RSocketFactory
                .connect()
                .reconnect(Retry.fixedDelay(3, Duration.ofSeconds(1)))
                .transport(transport)
                .start();

  RSocket r1 = sharedRSocketMono.block();
  RSocket r2 = sharedRSocketMono.block();

  assert r1 == r2;

  r1.dispose()

  assert r2.isDisposed()

  RSocket r3 = sharedRSocketMono.block();
  RSocket r4 = sharedRSocketMono.block();


  assert r1 != r3;
  assert r4 == r3;

 

Note, having reconnect() enabled does not eliminate the need to accompany each individual request with the corresponding retry logic.
For example:

 Mono<RSocket> sharedRSocketMono =
   RSocketFactory
                .connect()
                .reconnect(Retry.fixedDelay(3, Duration.ofSeconds(1)))
                .transport(transport)
                .start();

  sharedRSocket.flatMap(rSocket -> rSocket.requestResponse(...))
               .retryWhen(ownRetry)
               .subscribe()

 

Parameters:

retrySpec - a retry factory applied for Mono.retryWhen(Retry)

Returns:

a shared instance of Mono<RSocket>.

resume

public RSocketFactory.ClientRSocketFactory resume()

resumeToken

public RSocketFactory.ClientRSocketFactory resumeToken(Supplier<ByteBuf> supplier)

resumeStore

public RSocketFactory.ClientRSocketFactory resumeStore(Function<? super ByteBuf,? extends ResumableFramesStore> storeFactory)

resumeSessionDuration

public RSocketFactory.ClientRSocketFactory resumeSessionDuration(Duration sessionDuration)

resumeStreamTimeout

public RSocketFactory.ClientRSocketFactory resumeStreamTimeout(Duration streamTimeout)

resumeStrategy

public RSocketFactory.ClientRSocketFactory resumeStrategy(Supplier<ResumeStrategy> strategy)

resumeCleanupOnKeepAlive

public RSocketFactory.ClientRSocketFactory resumeCleanupOnKeepAlive()

transport

public RSocketFactory.Start<RSocket> transport(Supplier<ClientTransport> transport)

Specified by:

transport in interface RSocketFactory.ClientTransportAcceptor

acceptor

public RSocketFactory.ClientTransportAcceptor acceptor(Function<RSocket,RSocket> acceptor)

acceptor

public RSocketFactory.ClientTransportAcceptor acceptor(Supplier<Function<RSocket,RSocket>> acceptorSupplier)

acceptor

public RSocketFactory.ClientTransportAcceptor acceptor(SocketAcceptor acceptor)

fragment

public RSocketFactory.ClientRSocketFactory fragment(int mtu)

errorConsumer

public RSocketFactory.ClientRSocketFactory errorConsumer(Consumer<Throwable> errorConsumer)

Deprecated. this is deprecated with no replacement.

setupPayload

public RSocketFactory.ClientRSocketFactory setupPayload(Payload payload)

frameDecoder

public RSocketFactory.ClientRSocketFactory frameDecoder(PayloadDecoder payloadDecoder)