io.rsocket.resume

Class ResumableDuplexConnection

java.lang.Object

io.rsocket.resume.ResumableDuplexConnection

All Implemented Interfaces:

Availability, Closeable, DuplexConnection, ResumeStateHolder, Disposable

public class ResumableDuplexConnection
extends Object
implements DuplexConnection, ResumeStateHolder

Nested Class Summary

Nested classes/interfaces inherited from interface reactor.core.Disposable

Disposable.Composite, Disposable.Swap

Constructor Summary

Constructors

Constructor and Description
ResumableDuplexConnection(String tag, DuplexConnection duplexConnection, ResumableFramesStore resumableFramesStore, Duration resumeStreamTimeout, boolean cleanupOnKeepAlive)

Method Summary

Modifier and Type	Method and Description
double	availability()
void	disconnect()
void	dispose()
long	impliedPosition()
boolean	isDisposed()
Mono<Void>	onClose() Returns a Publisher that completes when this RSocket is closed.
void	onDisconnect(Runnable onDisconnectAction)
void	onImpliedPosition(long remoteImpliedPos)
void	onResume(Runnable onResumeAction)
long	position()
Flux<ByteBuf>	receive() Returns a stream of all Frames received on this connection.
void	reconnect(DuplexConnection connection)
void	resume(long remotePos, long remoteImpliedPos, Function<Mono<Long>,Mono<Void>> resumeFrameSent)
Mono<Void>	send(org.reactivestreams.Publisher<ByteBuf> frames) Sends the source of Frames on this connection and returns the Publisher representing the result of this send.
Mono<Void>	sendOne(ByteBuf frame) Sends a single Frame on this connection and returns the Publisher representing the result of this send.

Methods inherited from class java.lang.Object

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

Constructor Detail

ResumableDuplexConnection

public ResumableDuplexConnection(String tag,
                                 DuplexConnection duplexConnection,
                                 ResumableFramesStore resumableFramesStore,
                                 Duration resumeStreamTimeout,
                                 boolean cleanupOnKeepAlive)

Method Detail

disconnect

public void disconnect()

onDisconnect

public void onDisconnect(Runnable onDisconnectAction)

onResume

public void onResume(Runnable onResumeAction)

reconnect

public void reconnect(DuplexConnection connection)

resume

public void resume(long remotePos,
                   long remoteImpliedPos,
                   Function<Mono<Long>,Mono<Void>> resumeFrameSent)

sendOne

public Mono<Void> sendOne(ByteBuf frame)

Description copied from interface: DuplexConnection

Sends a single Frame on this connection and returns the Publisher representing the result of this send.

Specified by:

sendOne in interface DuplexConnection

Parameters:

frame - Frame to send.

Returns:

Publisher that completes when the frame is written on the connection successfully and errors when it fails.

send

public Mono<Void> send(org.reactivestreams.Publisher<ByteBuf> frames)

Description copied from interface: DuplexConnection

Sends the source of Frames on this connection and returns the Publisher representing the result of this send.

Flow control

The passed Publisher must

Specified by:

send in interface DuplexConnection

Parameters:

frames - Stream of Frames to send on the connection.

Returns:

Publisher that completes when all the frames are written on the connection successfully and errors when it fails.

receive

public Flux<ByteBuf> receive()

Description copied from interface: DuplexConnection

Returns a stream of all Frames received on this connection.

Completion

Returned Publisher MUST never emit a completion event (Subscriber.onComplete().

Error

Returned Publisher can error with various transport errors. If the underlying physical connection is closed by the peer, then the returned stream from here MUST emit an ClosedChannelException.

Multiple Subscriptions

Returned Publisher is not required to support multiple concurrent subscriptions. RSocket will never have multiple subscriptions to this source. Implementations MUST emit an IllegalStateException for subsequent concurrent subscriptions, if they do not support multiple concurrent subscriptions.

Specified by:

receive in interface DuplexConnection

Returns:

Stream of all Frames received.

position

public long position()

impliedPosition

public long impliedPosition()

Specified by:

impliedPosition in interface ResumeStateHolder

onImpliedPosition

public void onImpliedPosition(long remoteImpliedPos)

Specified by:

onImpliedPosition in interface ResumeStateHolder

onClose

public Mono<Void> onClose()

Description copied from interface: Closeable

Returns a Publisher that completes when this RSocket is closed. A RSocket can be closed by explicitly calling Disposable.dispose() or when the underlying transport connection is closed.

Specified by:

onClose in interface Closeable

Returns:

A Publisher that completes when this RSocket close is complete.

dispose

public void dispose()

Specified by:

dispose in interface Disposable

availability

public double availability()

Specified by:

availability in interface Availability

Specified by:

availability in interface DuplexConnection

Returns:

a positive numbers representing the availability of the entity. Higher is better, 0.0 means not available

isDisposed

public boolean isDisposed()

Specified by:

isDisposed in interface Disposable