io.vertx.core.net.impl

Class ConnectionBase

java.lang.Object

io.vertx.core.net.impl.ConnectionBase

Direct Known Subclasses:

Http1xClientConnection, Http1xServerConnection, Http2ServerConnection, NetSocketImpl

public abstract class ConnectionBase
extends Object

Abstract base class for TCP connections. This class is optimised for performance when used on the same event loop. However it can be used safely from other threads. The internal state is protected using the synchronized keyword. If always used on the same event loop, then we benefit from biased locking which makes the overhead of synchronized near zero.

Author:

Tim Fox

Field Summary

Fields

Modifier and Type	Field and Description
protected io.netty.channel.ChannelHandlerContext	chctx
static VertxException	CLOSED_EXCEPTION An exception used to signal a closed connection to an exception handler.
protected ContextInternal	context
static io.netty.util.AttributeKey<SocketAddress>	LOCAL_ADDRESS_OVERRIDE
static io.netty.util.AttributeKey<SocketAddress>	REMOTE_ADDRESS_OVERRIDE
protected VertxInternal	vertx
io.netty.channel.VoidChannelPromise	voidPromise

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	ConnectionBase(ContextInternal context, io.netty.channel.ChannelHandlerContext chctx)

Method Summary

Modifier and Type	Method and Description
io.netty.channel.Channel	channel()
io.netty.channel.ChannelPromise	channelFuture()
io.netty.channel.ChannelHandlerContext	channelHandlerContext()
Future<Void>	close() Close the connection
void	close(Handler<AsyncResult<Void>> handler) Close the connection and notifies the handler
Future<Void>	closeFuture()
ConnectionBase	closeHandler(Handler<Void> handler)
void	doPause()
void	doResume()
void	doSetWriteQueueMaxSize(int size)
protected Handler<Throwable>	exceptionHandler()
ConnectionBase	exceptionHandler(Handler<Throwable> handler)
void	fail(Throwable error) Fail the connection, the error will be sent to the pipeline and the connection will stop processing any further message.
void	flush() Asynchronous flush.
void	flush(io.netty.channel.ChannelPromise promise) Asynchronous flush.
void	flushBytesRead()
void	flushBytesWritten()
ContextInternal	getContext()
protected void	handleClosed()
protected void	handleException(Throwable t)
protected void	handleIdle() Called by the Netty handler when the connection becomes idle.
protected abstract void	handleInterestedOpsChanged()
protected void	handleMessage(Object msg)
String	indicatedServerName()
boolean	isNotWritable()
boolean	isSsl()
SocketAddress	localAddress()
Object	metric()
void	metric(Object metric)
abstract NetworkMetrics	metrics()
X509Certificate[]	peerCertificateChain()
SocketAddress	remoteAddress()
String	remoteName()
void	reportBytesRead(long numberOfBytes)
protected void	reportBytesRead(Object msg)
void	reportBytesWritten(long numberOfBytes)
protected void	reportsBytesWritten(Object msg)
io.netty.channel.ChannelFuture	sendFile(RandomAccessFile raf, long offset, long length)
SSLSession	sslSession()
protected boolean	supportsFileRegion()
void	writeToChannel(Object obj)
void	writeToChannel(Object msg, boolean forceFlush, io.netty.channel.ChannelPromise promise)
void	writeToChannel(Object msg, io.netty.channel.ChannelPromise promise)
void	writeToChannel(Object msg, io.netty.util.concurrent.FutureListener<Void> listener)

Methods inherited from class java.lang.Object

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

Field Detail

CLOSED_EXCEPTION

public static final VertxException CLOSED_EXCEPTION

An exception used to signal a closed connection to an exception handler. Exception are expensive to create, this instance can be used for this purpose. It does not capture a stack trace to not be misleading.

REMOTE_ADDRESS_OVERRIDE

public static final io.netty.util.AttributeKey<SocketAddress> REMOTE_ADDRESS_OVERRIDE

LOCAL_ADDRESS_OVERRIDE

public static final io.netty.util.AttributeKey<SocketAddress> LOCAL_ADDRESS_OVERRIDE

voidPromise

public final io.netty.channel.VoidChannelPromise voidPromise

vertx

protected final VertxInternal vertx

chctx

protected final io.netty.channel.ChannelHandlerContext chctx

context

protected final ContextInternal context

Constructor Detail

ConnectionBase

protected ConnectionBase(ContextInternal context,
                         io.netty.channel.ChannelHandlerContext chctx)

Method Detail

closeFuture

public Future<Void> closeFuture()

Returns:

a promise that will be completed when the connection becomes closed

fail

public void fail(Throwable error)

Fail the connection, the error will be sent to the pipeline and the connection will stop processing any further message.

Parameters:

error - the Throwable to propagate

writeToChannel

public final void writeToChannel(Object msg,
                                 io.netty.util.concurrent.FutureListener<Void> listener)

writeToChannel

public final void writeToChannel(Object msg,
                                 io.netty.channel.ChannelPromise promise)

writeToChannel

public final void writeToChannel(Object msg,
                                 boolean forceFlush,
                                 io.netty.channel.ChannelPromise promise)

writeToChannel

public void writeToChannel(Object obj)

flush

public final void flush()

Asynchronous flush.

flush

public final void flush(io.netty.channel.ChannelPromise promise)

Asynchronous flush.

Parameters:

promise - the promise resolved when flush occurred

isNotWritable

public boolean isNotWritable()

close

public Future<Void> close()

Close the connection

close

public final void close(Handler<AsyncResult<Void>> handler)

Close the connection and notifies the handler

closeHandler

public ConnectionBase closeHandler(Handler<Void> handler)

exceptionHandler

public ConnectionBase exceptionHandler(Handler<Throwable> handler)

exceptionHandler

protected Handler<Throwable> exceptionHandler()

doPause

public void doPause()

doResume

public void doResume()

doSetWriteQueueMaxSize

public void doSetWriteQueueMaxSize(int size)

channel

public final io.netty.channel.Channel channel()

Returns:

the Netty channel - for internal usage only

channelHandlerContext

public final io.netty.channel.ChannelHandlerContext channelHandlerContext()

getContext

public final ContextInternal getContext()

metric

public final void metric(Object metric)

metric

public final Object metric()

metrics

public abstract NetworkMetrics metrics()

handleException

protected void handleException(Throwable t)

handleClosed

protected void handleClosed()

handleIdle

protected void handleIdle()

Called by the Netty handler when the connection becomes idle. The default implementation closes the connection.

Subclasses can override it to prevent the idle event to happen (e.g when the connection is pooled) or perform extra work when the idle event happens.

handleInterestedOpsChanged

protected abstract void handleInterestedOpsChanged()

supportsFileRegion

protected boolean supportsFileRegion()

reportBytesRead

protected void reportBytesRead(Object msg)

reportBytesRead

public void reportBytesRead(long numberOfBytes)

reportsBytesWritten

protected void reportsBytesWritten(Object msg)

reportBytesWritten

public void reportBytesWritten(long numberOfBytes)

flushBytesRead

public void flushBytesRead()

flushBytesWritten

public void flushBytesWritten()

sendFile

public final io.netty.channel.ChannelFuture sendFile(RandomAccessFile raf,
                                                     long offset,
                                                     long length)
                                              throws IOException

Throws:

IOException

isSsl

public boolean isSsl()

sslSession

public SSLSession sslSession()

peerCertificateChain

public X509Certificate[] peerCertificateChain()
                                       throws SSLPeerUnverifiedException

Throws:

SSLPeerUnverifiedException

indicatedServerName

public String indicatedServerName()

channelFuture

public io.netty.channel.ChannelPromise channelFuture()

remoteName

public String remoteName()

remoteAddress

public SocketAddress remoteAddress()

localAddress

public SocketAddress localAddress()

handleMessage

protected void handleMessage(Object msg)