com.hazelcast.internal.networking.nio

Class NioOutboundPipeline

java.lang.Object

com.hazelcast.internal.networking.nio.NioPipeline

com.hazelcast.internal.networking.nio.NioOutboundPipeline

All Implemented Interfaces:

MigratablePipeline, OutboundPipeline, Supplier<OutboundFrame>, Runnable

public final class NioOutboundPipeline
extends NioPipeline
implements Supplier<OutboundFrame>, OutboundPipeline

Field Summary

Fields

Modifier and Type	Field and Description
Queue<OutboundFrame>	priorityWriteQueue
Queue<OutboundFrame>	writeQueue

Fields inherited from class com.hazelcast.internal.networking.nio.NioPipeline

channel, LOAD_BALANCING_BYTE, LOAD_BALANCING_FRAME, LOAD_BALANCING_HANDLE, loadType, logger, owner, processCount, selectionKey, socketChannel

Method Summary

Modifier and Type	Method and Description
OutboundPipeline	addLast(OutboundHandler... addedHandlers) Adds the handlers at the end of the pipeline No verification is done if the handler is already added and a handler should only be added once.
long	bytesPending()
OutboundFrame	get()
protected Iterable<? extends ChannelHandler>	handlers() Returns an Iterable that can iterate over each ChannelHandler of the pipeline.
long	lastWriteTimeMillis()
long	load() Get 'load' recorded by the current pipeline.
long	priorityBytesPending()
void	process() Called when the pipeline needs to be processed.
protected void	publishMetrics()
OutboundPipeline	remove(OutboundHandler handler) Removes the given handler from the pipeline.
OutboundPipeline	replace(OutboundHandler oldHandler, OutboundHandler... addedHandlers) Replaces the old OutboundHandler by the new ones.
void	requestClose()
String	toString()
int	totalFramesPending()
OutboundPipeline	wakeup() Request to flush all data to flush from the handlers to the network.
void	write(OutboundFrame frame)

Methods inherited from class com.hazelcast.internal.networking.nio.NioPipeline

getChannel, onError, owner, requestMigration, run

Methods inherited from class java.lang.Object

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

Field Detail

writeQueue

public final Queue<OutboundFrame> writeQueue

priorityWriteQueue

public final Queue<OutboundFrame> priorityWriteQueue

Method Detail

load

public long load()

Description copied from interface: MigratablePipeline

Get 'load' recorded by the current pipeline. It can be used to calculate whether this pipeline should be migrated to a different NioThread

Specified by:

load in interface MigratablePipeline

Returns:

total load recorded by this pipeline

totalFramesPending

public int totalFramesPending()

lastWriteTimeMillis

public long lastWriteTimeMillis()

bytesPending

public long bytesPending()

priorityBytesPending

public long priorityBytesPending()

write

public void write(OutboundFrame frame)

get

public OutboundFrame get()

Specified by:

get in interface Supplier<OutboundFrame>

process

public void process()
             throws Exception

Description copied from class: NioPipeline

Called when the pipeline needs to be processed. Any exception that leads to a termination of the connection like an IOException should not be dealt with in the handle method but should be propagated. The reason behind this is that the handle logic already is complicated enough and by pulling it out the flow will be easier to understand.

Throws:

Exception

requestClose

public void requestClose()

Overrides:

requestClose in class NioPipeline

publishMetrics

protected void publishMetrics()

toString

public String toString()

Overrides:

toString in class Object

handlers

protected Iterable<? extends ChannelHandler> handlers()

Description copied from class: NioPipeline

Returns an Iterable that can iterate over each ChannelHandler of the pipeline. This method is called only by the NioPipeline.onError(Throwable).

Specified by:

handlers in class NioPipeline

Returns:

the Iterable.

remove

public OutboundPipeline remove(OutboundHandler handler)

Description copied from interface: OutboundPipeline

Removes the given handler from the pipeline. This method should only be made on the thread 'owning' the handler.

Specified by:

remove in interface OutboundPipeline

Parameters:

handler - the handler to remove.

Returns:

this

addLast

public OutboundPipeline addLast(OutboundHandler... addedHandlers)

Description copied from interface: OutboundPipeline

Adds the handlers at the end of the pipeline No verification is done if the handler is already added and a handler should only be added once. This method should only be made on the thread 'owning' the handler.

Specified by:

addLast in interface OutboundPipeline

Parameters:

addedHandlers - the handlers to add.

Returns:

this

replace

public OutboundPipeline replace(OutboundHandler oldHandler,
                                OutboundHandler... addedHandlers)

Description copied from interface: OutboundPipeline

Replaces the old OutboundHandler by the new ones. So if there is a sequence of handlers [H1,H2,H3] and H2 gets replaced by [H4,H5] the new pipeline will be [H1,H4,H5,H3]. No verification is done if any of the handlers is already added and a handler should only be added once. This method should only be made on the thread 'owning' the handler.

Specified by:

replace in interface OutboundPipeline

Parameters:

oldHandler - the handlers to replace

addedHandlers - the new handlers to insert.

Returns:

this

wakeup

public OutboundPipeline wakeup()

Description copied from interface: OutboundPipeline

Request to flush all data to flush from the handlers to the network. It will cause at least one processing of the outbound pipeline. This method is threadsafe and can safely be called from any thread. Calling it while there is nothing in the pipeline will not do any damage, apart from consuming cpu cycles. This can be used for example, with protocol or handshaking. So imagine there is a handshake decoder (e.g. protocol or tls), that as soon as it has received some data like 'hello', it wants to send back a message to the other side as part of the handshake. This can be done by looking up the handshake encoder, queue the message on that encoder and then call this method. This will cause the outbound pipeline to get processed.

Specified by:

wakeup in interface OutboundPipeline

Returns:

this