ChannelOperations (Reactor Netty 0.9.20.RELEASE)

java.lang.Object
- reactor.netty.channel.ChannelOperations<INBOUND,OUTBOUND>

All Implemented Interfaces:

Publisher<Void>, Subscriber<Void>, CoreSubscriber<Void>, Disposable, Connection, DisposableChannel, NettyInbound, NettyOutbound

Direct Known Subclasses:

HttpOperations
```
public class ChannelOperations<INBOUND extends NettyInbound,OUTBOUND extends NettyOutbound>
extends Object
implements NettyInbound, NettyOutbound, Connection, CoreSubscriber<Void>
```
NettyInbound and NettyOutbound that apply to a Connection

Since:

0.6

Author:

Stephane Maldini

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface ChannelOperations.OnSetup
A ChannelOperations factory
- Nested classes/interfaces inherited from interface reactor.core.Disposable
  Disposable.Composite, Disposable.Swap

Nested Classes
Modifier and Type	Class and Description
`static interface`	`ChannelOperations.OnSetup` A `ChannelOperations` factory

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`ChannelOperations(ChannelOperations<INBOUND,OUTBOUND> replaced)`
	`ChannelOperations(Connection connection, ConnectionObserver listener)` Create a new `ChannelOperations` attached to the `Channel`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`addReactiveBridge(Channel ch, ChannelOperations.OnSetup opsFactory, ConnectionObserver listener)` Add `NettyPipeline.ReactiveBridge` handler at the end of `Channel` pipeline.
`protected void`	`afterInboundComplete()` React after inbound completion (last packet)
`ByteBufAllocator`	`alloc()` Returns the assigned `ByteBufAllocator`.
`<T extends Connection> T`	`as(Class<T> clazz)` Return an existing `Connection` that must match the given type wrapper or null.
`Channel`	`channel()` Returns the underlying `Channel`.
`protected Connection`	`connection()` Return the delegate IO `Connection` for low-level IO access
`Context`	`currentContext()`
`void`	`discard()` Drop pending content and complete inbound
`void`	`dispose()` Releases or closes the underlying `Channel`
`CoreSubscriber<Void>`	`disposeSubscriber()` Returns a `CoreSubscriber` that will dispose on complete or error
`protected String`	`formatName()` Return formatted name of this operation
`static ChannelOperations<?,?>`	`get(Channel ch)` Return the current `Channel` bound `ChannelOperations` or null if none
`NettyInbound`	`inbound()` Return the `NettyInbound` read API from this connection.
`boolean`	`isDisposed()`
`boolean`	`isInboundCancelled()` Return true if inbound traffic is not expected anymore
`boolean`	`isInboundDisposed()` Return true if inbound traffic is not incoming or expected anymore
`boolean`	`isPersistent()` Return false if it will force a close on terminal protocol events thus defeating any pooling strategy Return true (default) if it will release on terminal protocol events thus keeping alive the channel if possible.
`boolean`	`isSubscriptionDisposed()` Return true if dispose subscription has been terminated
`ConnectionObserver`	`listener()` Return the available parent `ConnectionObserver` for user-facing lifecycle handling
`void`	`onComplete()`
`Mono<Void>`	`onDispose()` Returns an observing `Mono` terminating with success when shutdown successfully or error.
`Connection`	`onDispose(Disposable onDispose)` Assigns a `Disposable` to be invoked when the channel is closed.
`void`	`onError(Throwable t)`
`protected void`	`onInboundCancel()` React on inbound cancel (receive() subscriber cancelled)
`protected void`	`onInboundClose()` React on inbound close (channel closed prematurely)
`protected void`	`onInboundComplete()` React on inbound completion (last packet)
`protected void`	`onInboundError(Throwable err)` React on inbound error
`protected void`	`onInboundNext(ChannelHandlerContext ctx, Object msg)` React on inbound `Channel.read()`
`void`	`onNext(Void aVoid)`
`protected void`	`onOutboundComplete()` React on inbound/outbound completion (last packet)
`protected void`	`onOutboundError(Throwable err)` React on inbound/outbound error
`void`	`onSubscribe(Subscription s)`
`Mono<Void>`	`onTerminate()` Return a Mono succeeding when a `ChannelOperations` has been terminated
`NettyOutbound`	`outbound()` Return the `NettyOutbound` write API from this connection.
`ByteBufFlux`	`receive()` A `Flux` extension that allows for extra decoding operators
`Flux<?>`	`receiveObject()` a Object inbound `Flux`
`NettyOutbound`	`send(Publisher<? extends ByteBuf> dataStream, java.util.function.Predicate<ByteBuf> predicate)` Sends data to the peer, listens for any error on write and closes on terminal signal (complete\|error).
`NettyOutbound`	`sendObject(Object message)` Sends data to the peer, listens for any error on write and closes on terminal signal (complete\|error).
`NettyOutbound`	`sendObject(Publisher<?> dataStream, java.util.function.Predicate<Object> predicate)` Sends an object through Netty pipeline.
`<S> NettyOutbound`	`sendUsing(Callable<? extends S> sourceInput, java.util.function.BiFunction<? super Connection,? super S,?> mappedInput, java.util.function.Consumer<? super S> sourceCleanup)` Binds a send to a starting/cleanup lifecycle
`protected void`	`terminate()` Final release/close (last packet)
`String`	`toString()`
`ChannelOperations<INBOUND,OUTBOUND>`	`withConnection(java.util.function.Consumer<? super Connection> withConnection)` Calls the passed callback with a `Connection` to operate on the underlying `Channel` state.
`protected Throwable`	`wrapInboundError(Throwable err)` Wrap an inbound error

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

Methods inherited from interface reactor.netty.NettyOutbound
neverComplete, send, sendByteArray, sendFile, sendFile, sendFileChunked, sendGroups, sendObject, sendString, sendString, subscribe, then, then, then

Methods inherited from interface reactor.netty.Connection
addHandler, addHandler, addHandlerFirst, addHandlerFirst, addHandlerLast, addHandlerLast, bind, from, markPersistent, onReadIdle, onWriteIdle, rebind, removeHandler, replaceHandler

Methods inherited from interface reactor.netty.DisposableChannel
address, disposeNow, disposeNow

- Constructor Detail
  - ChannelOperations
```
protected ChannelOperations(ChannelOperations<INBOUND,OUTBOUND> replaced)
```
  - ChannelOperations
```
public ChannelOperations(Connection connection,
                         ConnectionObserver listener)
```
    Create a new ChannelOperations attached to the Channel. Attach the NettyPipeline.ReactiveBridge handle.
    
    Parameters:
    
    connection - the new Connection connection
    
    listener - the events callback
- Method Detail
  - addReactiveBridge
```
public static void addReactiveBridge(Channel ch,
                                     ChannelOperations.OnSetup opsFactory,
                                     ConnectionObserver listener)
```
    Add NettyPipeline.ReactiveBridge handler at the end of Channel pipeline. The bridge will buffer outgoing write and pass along incoming read to the current get(Channel).
    
    Parameters:
    
    ch - the channel to bridge
    
    opsFactory - the operations factory to invoke on channel active
    
    listener - the listener to forward connection events to
  - get
```
@Nullable
public static ChannelOperations<?,?> get(Channel ch)
```
    Return the current Channel bound ChannelOperations or null if none
    
    Parameters:
    
    ch - the current Channel
    
    Returns:
    
    the current Channel bound ChannelOperations or null if none
  - as
```
@Nullable
public <T extends Connection> T as(Class<T> clazz)
```
    Description copied from interface: Connection
    
    Return an existing Connection that must match the given type wrapper or null.
    
    Specified by:
    
    as in interface Connection
    
    Parameters:
    
    clazz - connection type to match to
    
    Returns:
    
    a matching Connection reference or null
  - alloc
```
public ByteBufAllocator alloc()
```
    Description copied from interface: NettyOutbound
    
    Returns the assigned ByteBufAllocator.
    
    Specified by:
    
    alloc in interface NettyOutbound
    
    Returns:
    
    the ByteBufAllocator
  - inbound
```
public NettyInbound inbound()
```
    Description copied from interface: Connection
    
    Return the NettyInbound read API from this connection. If Connection has not been configured with a supporting bridge, receive operations will be unavailable.
    
    Specified by:
    
    inbound in interface Connection
    
    Returns:
    
    the NettyInbound read API from this connection.
  - outbound
```
public NettyOutbound outbound()
```
    Description copied from interface: Connection
    
    Return the NettyOutbound write API from this connection. If Connection has not been configured with a supporting bridge, send operations will be unavailable.
    
    Specified by:
    
    outbound in interface Connection
    
    Returns:
    
    the NettyOutbound read API from this connection.
  - channel
```
public final Channel channel()
```
    Description copied from interface: DisposableChannel
    
    Returns the underlying Channel. Direct interaction might be considered insecure if that affects the underlying I/O processing such as read, write or close or state such as pipeline handler addition/removal.
    
    Specified by:
    
    channel in interface DisposableChannel
    
    Returns:
    
    the underlying Channel
  - withConnection
```
public ChannelOperations<INBOUND,OUTBOUND> withConnection(java.util.function.Consumer<? super Connection> withConnection)
```
    Description copied from interface: NettyInbound
    
    Calls the passed callback with a Connection to operate on the underlying Channel state. This allows for chaining inbound API.
    
    Specified by:
    
    withConnection in interface NettyInbound
    
    Specified by:
    
    withConnection in interface NettyOutbound
    
    Parameters:
    
    withConnection - connection callback
    
    Returns:
    
    the Connection
  - dispose
```
public void dispose()
```
    Description copied from interface: DisposableChannel
    
    Releases or closes the underlying Channel
    
    Specified by:
    
    dispose in interface Disposable
    
    Specified by:
    
    dispose in interface DisposableChannel
  - disposeSubscriber
```
public CoreSubscriber<Void> disposeSubscriber()
```
    Description copied from interface: DisposableChannel
    
    Returns a CoreSubscriber that will dispose on complete or error
    
    Specified by:
    
    disposeSubscriber in interface DisposableChannel
  - isDisposed
```
public final boolean isDisposed()
```
    Specified by:
    
    isDisposed in interface Disposable
    
    Specified by:
    
    isDisposed in interface DisposableChannel
  - isSubscriptionDisposed
```
public final boolean isSubscriptionDisposed()
```
    Return true if dispose subscription has been terminated
    
    Returns:
    
    true if dispose subscription has been terminated
  - onDispose
```
public final Mono<Void> onDispose()
```
    Description copied from interface: DisposableChannel
    
    Returns an observing Mono terminating with success when shutdown successfully or error.
    
    Specified by:
    
    onDispose in interface DisposableChannel
    
    Returns:
    
    a Mono terminating with success if shutdown successfully or error
  - onDispose
```
public Connection onDispose(Disposable onDispose)
```
    Description copied from interface: DisposableChannel
    
    Assigns a Disposable to be invoked when the channel is closed.
    
    Specified by:
    
    onDispose in interface Connection
    
    Specified by:
    
    onDispose in interface DisposableChannel
    
    Parameters:
    
    onDispose - the close event handler
    
    Returns:
    
    this
  - onComplete
```
public final void onComplete()
```
    Specified by:
    
    onComplete in interface Subscriber<Void>
  - onError
```
public final void onError(Throwable t)
```
    Specified by:
    
    onError in interface Subscriber<Void>
  - onNext
```
public final void onNext(Void aVoid)
```
    Specified by:
    
    onNext in interface Subscriber<Void>
  - onSubscribe
```
public final void onSubscribe(Subscription s)
```
    Specified by:
    
    onSubscribe in interface Subscriber<Void>
    
    Specified by:
    
    onSubscribe in interface CoreSubscriber<Void>
  - receiveObject
```
public Flux<?> receiveObject()
```
    Description copied from interface: NettyInbound
    
    a Object inbound Flux
    
    Specified by:
    
    receiveObject in interface NettyInbound
    
    Returns:
    
    a Object inbound Flux
  - receive
```
public ByteBufFlux receive()
```
    Description copied from interface: NettyInbound
    
    A Flux extension that allows for extra decoding operators
    
    Specified by:
    
    receive in interface NettyInbound
    
    Returns:
    
    a new ByteBufFlux
  - send
```
public NettyOutbound send(Publisher<? extends ByteBuf> dataStream,
                          java.util.function.Predicate<ByteBuf> predicate)
```
    Description copied from interface: NettyOutbound
    
    Sends data to the peer, listens for any error on write and closes on terminal signal (complete|error).
    A new NettyOutbound type (or the same) for typed send sequences.
    
    Note: Nesting any send* method is not supported.
    
    Specified by:
    
    send in interface NettyOutbound
    
    Parameters:
    
    dataStream - the dataStream publishing OUT items to write on this channel
    
    predicate - that returns true if explicit flush operation is needed after that buffer
    
    Returns:
    
    A new NettyOutbound to append further send. It will emit a complete signal successful sequence write (e.g. after "flush") or any error during write.
  - sendObject
```
public NettyOutbound sendObject(Publisher<?> dataStream,
                                java.util.function.Predicate<Object> predicate)
```
    Description copied from interface: NettyOutbound
    
    Sends an object through Netty pipeline. If type of Publisher, sends all signals, flushing on complete by default. Write occur in FIFO sequence.
    Note: Nesting any send* method is not supported.
    
    Specified by:
    
    sendObject in interface NettyOutbound
    
    Parameters:
    
    dataStream - the dataStream publishing items to write on this channel or a simple pojo supported by configured Netty handlers
    
    predicate - that returns true if explicit flush operation is needed after that object
    
    Returns:
    
    A Publisher to signal successful sequence write (e.g. after "flush") or any error during write
  - sendObject
```
public NettyOutbound sendObject(Object message)
```
    Description copied from interface: NettyOutbound
    
    Sends data to the peer, listens for any error on write and closes on terminal signal (complete|error).
    Note: Nesting any send* method is not supported.
    
    Specified by:
    
    sendObject in interface NettyOutbound
    
    Parameters:
    
    message - the object to publish
    
    Returns:
    
    A Mono to signal successful sequence write (e.g. after "flush") or any error during write
  - sendUsing
```
public <S> NettyOutbound sendUsing(Callable<? extends S> sourceInput,
                                   java.util.function.BiFunction<? super Connection,? super S,?> mappedInput,
                                   java.util.function.Consumer<? super S> sourceCleanup)
```
    Description copied from interface: NettyOutbound
    
    Binds a send to a starting/cleanup lifecycle
    Note: Nesting any send* method is not supported.
    
    Specified by:
    
    sendUsing in interface NettyOutbound
    
    Type Parameters:
    
    S - state type
    
    Parameters:
    
    sourceInput - state generator
    
    mappedInput - input to send
    
    sourceCleanup - state cleaner
    
    Returns:
    
    a new NettyOutbound
  - onTerminate
```
public final Mono<Void> onTerminate()
```
    Return a Mono succeeding when a ChannelOperations has been terminated
    
    Specified by:
    
    onTerminate in interface Connection
    
    Returns:
    
    a Mono succeeding when a ChannelOperations has been terminated
  - listener
```
public final ConnectionObserver listener()
```
    Return the available parent ConnectionObserver for user-facing lifecycle handling
    
    Returns:
    
    the available parent ConnectionObserverfor user-facing lifecycle handling
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - discard
```
public final void discard()
```
    Drop pending content and complete inbound
  - isInboundCancelled
```
public final boolean isInboundCancelled()
```
    Return true if inbound traffic is not expected anymore
    
    Returns:
    
    true if inbound traffic is not expected anymore
  - isInboundDisposed
```
public final boolean isInboundDisposed()
```
    Return true if inbound traffic is not incoming or expected anymore
    
    Returns:
    
    true if inbound traffic is not incoming or expected anymore
  - onInboundNext
```
protected void onInboundNext(ChannelHandlerContext ctx,
                             Object msg)
```
    React on inbound Channel.read()
    
    Parameters:
    
    ctx - the context
    
    msg - the read payload
  - onInboundCancel
```
protected void onInboundCancel()
```
    React on inbound cancel (receive() subscriber cancelled)
  - onInboundComplete
```
protected void onInboundComplete()
```
    React on inbound completion (last packet)
  - afterInboundComplete
```
protected void afterInboundComplete()
```
    React after inbound completion (last packet)
  - onInboundClose
```
protected void onInboundClose()
```
    React on inbound close (channel closed prematurely)
  - onOutboundComplete
```
protected void onOutboundComplete()
```
    React on inbound/outbound completion (last packet)
  - onOutboundError
```
protected void onOutboundError(Throwable err)
```
    React on inbound/outbound error
    
    Parameters:
    
    err - the Throwable cause
  - terminate
```
protected final void terminate()
```
    Final release/close (last packet)
  - onInboundError
```
protected final void onInboundError(Throwable err)
```
    React on inbound error
    
    Parameters:
    
    err - the Throwable cause
  - connection
```
protected final Connection connection()
```
    Return the delegate IO Connection for low-level IO access
    
    Returns:
    
    the delegate IO Connection for low-level IO access
  - formatName
```
protected final String formatName()
```
    Return formatted name of this operation
    
    Returns:
    
    formatted name of this operation
  - wrapInboundError
```
protected Throwable wrapInboundError(Throwable err)
```
    Wrap an inbound error
    
    Parameters:
    
    err - the Throwable cause
  - isPersistent
```
public boolean isPersistent()
```
    Description copied from interface: Connection
    
    Return false if it will force a close on terminal protocol events thus defeating any pooling strategy Return true (default) if it will release on terminal protocol events thus keeping alive the channel if possible.
    
    Specified by:
    
    isPersistent in interface Connection
    
    Returns:
    
    whether or not the underlying Connection will be disposed on terminal handler event
  - currentContext
```
public Context currentContext()
```
    Specified by:
    
    currentContext in interface CoreSubscriber<Void>

Class ChannelOperations<INBOUND extends NettyInbound,OUTBOUND extends NettyOutbound>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface reactor.netty.NettyOutbound

Methods inherited from interface reactor.netty.Connection

Methods inherited from interface reactor.netty.DisposableChannel

Constructor Detail

ChannelOperations

ChannelOperations

Method Detail

addReactiveBridge

get

as

alloc

inbound

outbound

channel

withConnection

dispose

disposeSubscriber

isDisposed

isSubscriptionDisposed

onDispose

onDispose

onComplete

onError

onNext

onSubscribe

receiveObject

receive

send

sendObject

sendObject

sendUsing

onTerminate

listener

toString

discard

isInboundCancelled

isInboundDisposed

onInboundNext

onInboundCancel

onInboundComplete

afterInboundComplete

onInboundClose

onOutboundComplete

onOutboundError

terminate

onInboundError

connection

formatName

wrapInboundError

isPersistent

currentContext