org.glassfish.grizzly.connectionpool

Class SingleEndpointPool<E>

java.lang.Object

org.glassfish.grizzly.connectionpool.SingleEndpointPool<E>

public class SingleEndpointPool<E>
extends Object

The single endpoint Connection pool implementation, in other words this pool manages Connections to one specific endpoint. The endpoint address has to be represented by an objected understandable by a ConnectorHandler passed to the constructor. For example the endpoint address has to be represented by SocketAddress for TCPNIOConnectorHandler and UDPNIOConnectorHandler. There are number of configuration options supported by the SingleEndpointPool: - corePoolSize: the number of Connections to be kept in the pool and never timed out because of keep-alive setting; - maxPoolSize: the maximum number of Connections to be kept by the pool; - keepAliveTimeoutMillis: the maximum number of milliseconds an idle Connection will be kept in the pool. The idle Connections will be closed till the pool size is greater than corePoolSize; - keepAliveCheckIntervalMillis: the interval, which specifies how often the pool will perform idle Connections check; - reconnectDelayMillis: the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous connect had failed.

Author:

Alexey Stashok

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SingleEndpointPool.Builder<E> The Builder class responsible for constructing SingleEndpointPool.
protected static class	SingleEndpointPool.ConnectTimeoutTask
protected static class	SingleEndpointPool.ConnectTimeoutTaskResolver
protected static class	SingleEndpointPool.ConnectTimeoutWorker Connect timeout mechanism classes related to DelayedExecutor.
protected static class	SingleEndpointPool.KeepAliveCleaner Keep-alive mechanism classes related to DelayedExecutor.
protected static class	SingleEndpointPool.KeepAliveCleanerTask<E>
protected static class	SingleEndpointPool.KeepAliveCleanerTaskResolver
protected static class	SingleEndpointPool.Reconnector Reconnect mechanism classes related to DelayedExecutor.
protected static class	SingleEndpointPool.ReconnectTask<E>
protected static class	SingleEndpointPool.ReconnectTaskResolver

Field Summary

Fields

Modifier and Type	Field and Description
protected int	pendingConnections Number of connections we're currently trying to establish and waiting for the result

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	SingleEndpointPool(ConnectorHandler<E> connectorHandler, E endpointAddress, E localEndpointAddress, int corePoolSize, int maxPoolSize, DelayedExecutor.DelayQueue<SingleEndpointPool.ConnectTimeoutTask> connectTimeoutQueue, DelayedExecutor.DelayQueue<SingleEndpointPool.ReconnectTask> reconnectQueue, DelayedExecutor.DelayQueue<SingleEndpointPool.KeepAliveCleanerTask> keepAliveCleanerQueue, long connectTimeoutMillis, long keepAliveTimeoutMillis, long keepAliveCheckIntervalMillis, long reconnectDelayMillis, int maxReconnectAttempts) Constructs SingleEndpointPool instance.
protected	SingleEndpointPool(ConnectorHandler<E> connectorHandler, E endpointAddress, E localEndpointAddress, int corePoolSize, int maxPoolSize, DelayedExecutor delayedExecutor, long connectTimeoutMillis, long keepAliveTimeoutMillis, long keepAliveCheckIntervalMillis, long reconnectDelayMillis, int maxReconnectAttempts) Constructs SingleEndpointPool instance.

Method Summary

Methods

Modifier and Type	Method and Description
boolean	attach(Connection connection) Attaches "foreign" Connection to the pool.
static <T> SingleEndpointPool.Builder<T>	builder(Class<T> endpointType) Returns single endpoint pool SingleEndpointPool.Builder.
protected boolean	checkBeforeOpeningConnection() The method is called before the pool will try to establish new client connection.
void	close() Closes the pool and release associated resources.
protected boolean	createConnectionIfPossible() Checks if it's possible to create a new Connection by calling checkBeforeOpeningConnection() and if it is possible - establish new connection.
boolean	detach(Connection connection) Detaches a Connection from the pool.
ConnectionInfo<E>	getConnectionInfo(Connection connection) Returns pooled ConnectionInfo, that might be used for monitoring reasons, or null if the Connection does not belong to this pool.
int	getOpenConnectionsCount() Returns the number of connected Connections in the pool.
int	getReadyConnectionsCount() Returns the number of Connections ready to be retrieved and used.
boolean	isBusy(Connection connection) Returns true only if the Connection is registered in the pool and is currently in busy state (used by a user), otherwise returns false.
boolean	isMaxCapacityReached() Returns true is maximum number of Connections the pool can keep is reached and no new Connection can established, or false otherwise.
boolean	isRegistered(Connection connection) Returns true if the Connection is registered in the pool no matter if it's currently in busy or ready state, or false if the Connection is not registered in the pool.
boolean	release(Connection connection) Returns the Connection to the pool.
int	size() Returns the current pool size.
GrizzlyFuture<Connection>	take() Obtains a Connection from the pool in non-blocking/asynchronous fashion.
void	take(CompletionHandler<Connection> completionHandler) Obtains a Connection from the pool in non-blocking/asynchronous fashion.
String	toString()

Methods inherited from class java.lang.Object

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

Field Detail

pendingConnections

protected int pendingConnections

Number of connections we're currently trying to establish and waiting for the result

Constructor Detail

SingleEndpointPool

protected SingleEndpointPool(ConnectorHandler<E> connectorHandler,
                  E endpointAddress,
                  E localEndpointAddress,
                  int corePoolSize,
                  int maxPoolSize,
                  DelayedExecutor delayedExecutor,
                  long connectTimeoutMillis,
                  long keepAliveTimeoutMillis,
                  long keepAliveCheckIntervalMillis,
                  long reconnectDelayMillis,
                  int maxReconnectAttempts)

Constructs SingleEndpointPool instance.

Parameters:

connectorHandler - ConnectorHandler to be used to establish new Connections

endpointAddress - endpoint address

localEndpointAddress - local bind address. May be null.

corePoolSize - the number of Connections, kept in the pool, that are immune to keep-alive mechanism

maxPoolSize - the max number of Connections kept by this pool

delayedExecutor - custom DelayedExecutor to be used by keep-alive and reconnect mechanisms

connectTimeoutMillis - timeout, after which, if a connection is not established, it is considered failed

keepAliveTimeoutMillis - the maximum number of milliseconds an idle Connection will be kept in the pool

keepAliveCheckIntervalMillis - the interval, which specifies how often the pool will perform idle Connections check

reconnectDelayMillis - the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous connect had failed

maxReconnectAttempts - the maximum number of reconnect attempts that may be made before failure notification.

SingleEndpointPool

protected SingleEndpointPool(ConnectorHandler<E> connectorHandler,
                  E endpointAddress,
                  E localEndpointAddress,
                  int corePoolSize,
                  int maxPoolSize,
                  DelayedExecutor.DelayQueue<SingleEndpointPool.ConnectTimeoutTask> connectTimeoutQueue,
                  DelayedExecutor.DelayQueue<SingleEndpointPool.ReconnectTask> reconnectQueue,
                  DelayedExecutor.DelayQueue<SingleEndpointPool.KeepAliveCleanerTask> keepAliveCleanerQueue,
                  long connectTimeoutMillis,
                  long keepAliveTimeoutMillis,
                  long keepAliveCheckIntervalMillis,
                  long reconnectDelayMillis,
                  int maxReconnectAttempts)

Constructs SingleEndpointPool instance.

Parameters:

connectorHandler - ConnectorHandler to be used to establish new Connections

endpointAddress - endpoint address

localEndpointAddress - local bind address. May be null.

corePoolSize - the number of Connections, kept in the pool, that are immune to keep-alive mechanism

maxPoolSize - the max number of Connections kept by this pool

connectTimeoutQueue - the DelayedExecutor.DelayQueue used by connect timeout mechanism

reconnectQueue - the DelayedExecutor.DelayQueue used by reconnect mechanism

keepAliveCleanerQueue - the DelayedExecutor.DelayQueue used by keep-alive mechanism

connectTimeoutMillis - timeout, after which, if a connection is not established, it is considered failed

keepAliveTimeoutMillis - the maximum number of milliseconds an idle Connection will be kept in the pool

keepAliveCheckIntervalMillis - the interval, which specifies how often the pool will perform idle Connections check

reconnectDelayMillis - the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous connect had failed

maxReconnectAttempts - the maximum number of reconnect attempts that may be made before failure notification.

Method Detail

builder

public static <T> SingleEndpointPool.Builder<T> builder(Class<T> endpointType)

Returns single endpoint pool SingleEndpointPool.Builder.

Parameters:

endpointType - endpoint address type, for example SocketAddress for TCP and UDP transports

Returns:

SingleEndpointPool.Builder

size

public int size()

Returns the current pool size. This value includes connected and connecting (connect in progress) Connections.

getOpenConnectionsCount

public int getOpenConnectionsCount()

Returns the number of connected Connections in the pool. Unlike size() the value doesn't include connecting (connect in progress) Connections.

getReadyConnectionsCount

public int getReadyConnectionsCount()

Returns the number of Connections ready to be retrieved and used.

isMaxCapacityReached

public boolean isMaxCapacityReached()

Returns true is maximum number of Connections the pool can keep is reached and no new Connection can established, or false otherwise.

isRegistered

public boolean isRegistered(Connection connection)

Returns true if the Connection is registered in the pool no matter if it's currently in busy or ready state, or false if the Connection is not registered in the pool.

Parameters:

connection - Connection

Returns:

true if the Connection is registered in the pool no matter if it's currently in busy or ready state, or false if the Connection is not registered in the pool

isBusy

public boolean isBusy(Connection connection)

Returns true only if the Connection is registered in the pool and is currently in busy state (used by a user), otherwise returns false.

Parameters:

connection - Connection

Returns:

true only if the Connection is registered in the pool and is currently in busy state (used by a user), otherwise returns false

toString

public String toString()

Overrides:

toString in class Object

getConnectionInfo

public ConnectionInfo<E> getConnectionInfo(Connection connection)

Returns pooled ConnectionInfo, that might be used for monitoring reasons, or null if the Connection does not belong to this pool.

Parameters:

connection - Connection

Returns:

pooled ConnectionInfo, that might be used for monitoring reasons, or null if the Connection does not belong to this pool

take

public GrizzlyFuture<Connection> take()

Obtains a Connection from the pool in non-blocking/asynchronous fashion. Returns a GrizzlyFuture representing the pending result of the non-blocking/asynchronous obtain task. Future's get method will return the Connection once it becomes available in the pool.

If you would like to immediately block waiting for a Connection, you can use constructions of the form connection = pool.take().get();

Note: returned GrizzlyFuture must be checked and released properly. It must not be forgotten, because a Connection, that might be assigned as a result of GrizzlyFuture has to be returned to the pool. If you gave up on waiting for a Connection or you are not interested in the Connection anymore, the proper release code has to look like:

 if (!future.cancel(false)) {
     // means Connection is ready
     pool.release(future.get());
 }
 

Returns:

GrizzlyFuture

take

public void take(CompletionHandler<Connection> completionHandler)

Obtains a Connection from the pool in non-blocking/asynchronous fashion. The passed CompletionHandler will be notified about the result of the non-blocking/asynchronous obtain task.

release

public boolean release(Connection connection)

Returns the Connection to the pool. The Connection will be returned to the pool only in case it was created by this pool, or it was attached to it using attach(org.glassfish.grizzly.Connection) method. If the Connection is not registered in the pool - it will be closed. If the Connection is registered in the pool and already marked as ready - this method call will not have any effect. If the Connection was returned - it is illegal to use it until it is retrieved from the pool again.

Parameters:

connection - the Connection to return

Returns:

true if the connection was successfully released. If the connection cannot be released, the connection will be closed and false will be returned.

attach

public boolean attach(Connection connection)
               throws IOException

Attaches "foreign" Connection to the pool. This method might be used to add to the pool a Connection, that either has not been created by this pool or has been detached.

Parameters:

connection - Connection

Returns:

true if the Connection has been successfully attached, or false otherwise. If the Connection had been already registered in the pool - the method call doesn't have any effect and true will be returned.

Throws:

IOException - thrown if this pool has been already closed

detach

public boolean detach(Connection connection)

Detaches a Connection from the pool. De-registers the Connection from the pool and decreases the pool size by 1. It is possible to re-attach the detached Connection later by calling attach(org.glassfish.grizzly.Connection). If the Connection was not registered in the pool - the method call doesn't have any effect.

Parameters:

connection - the Connection to detach

close

public void close()

Closes the pool and release associated resources. The ready Connections will be closed, the busy Connection, that are still in use - will be kept open and will be automatically closed when returned to the pool by release(org.glassfish.grizzly.Connection).

checkBeforeOpeningConnection

protected boolean checkBeforeOpeningConnection()

The method is called before the pool will try to establish new client connection.

createConnectionIfPossible

protected boolean createConnectionIfPossible()

Checks if it's possible to create a new Connection by calling checkBeforeOpeningConnection() and if it is possible - establish new connection.