Package org.glassfish.grizzly.connectionpool

Class SingleEndpointPool<E>

  • Type Parameters:
    E - the address type, for example for TCP transport it's SocketAddress
    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. - asyncPollTimeoutMillis: maximum amount of time, after which the async connection poll operation will be failed with a timeout exception - connectionTTLMillis: the maximum amount of time, a Connection could be associated with the pool
    Author:
    Alexey Stashok

    • Field Detail

      • maxPoolSize

        protected final int maxPoolSize
        The max number of Connections kept by this pool

      • pendingConnections

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

    • Constructor Detail

      • SingleEndpointPool

        protected SingleEndpointPool​(Endpoint<E> endpoint,
                             int corePoolSize,
                             int maxPoolSize,
                             org.glassfish.grizzly.utils.DelayedExecutor delayedExecutor,
                             long connectTimeoutMillis,
                             long keepAliveTimeoutMillis,
                             long keepAliveCheckIntervalMillis,
                             long reconnectDelayMillis,
                             int maxReconnectAttempts,
                             long asyncPollTimeoutMillis,
                             long connectionTTLMillis,
                             boolean failFastWhenMaxSizeReached)
        Constructs SingleEndpointPool instance.
        Parameters:
        endpoint - Endpoint to be used to establish new Connections
        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.
        asyncPollTimeoutMillis - the maximum time, the async poll operation could wait for a connection to become available
        connectionTTLMillis - the maximum time, a connection could stay registered with the pool
        failFastWhenMaxSizeReached - true if the "take" method should fail fast if there is no free connection in the pool and max pool size is reached

      • SingleEndpointPool

        protected SingleEndpointPool​(Endpoint<E> endpoint,
                             int corePoolSize,
                             int maxPoolSize,
                             org.glassfish.grizzly.utils.DelayedExecutor.DelayQueue<SingleEndpointPool.ConnectTimeoutTask> connectTimeoutQueue,
                             org.glassfish.grizzly.utils.DelayedExecutor.DelayQueue<SingleEndpointPool.ReconnectTask> reconnectQueue,
                             org.glassfish.grizzly.utils.DelayedExecutor.DelayQueue<SingleEndpointPool.KeepAliveCleanerTask> keepAliveCleanerQueue,
                             org.glassfish.grizzly.utils.DelayedExecutor.DelayQueue<Link<SingleEndpointPool.AsyncPoll>> asyncPollTimeoutQueue,
                             org.glassfish.grizzly.utils.DelayedExecutor.DelayQueue<ConnectionInfo> connectionTTLQueue,
                             long connectTimeoutMillis,
                             long keepAliveTimeoutMillis,
                             long keepAliveCheckIntervalMillis,
                             long reconnectDelayMillis,
                             int maxReconnectAttempts,
                             long asyncPollTimeoutMillis,
                             long connectionTTLMillis,
                             boolean failFastWhenMaxSizeReached)
        Constructs SingleEndpointPool instance.
        Parameters:
        endpoint - Endpoint to be used to establish new Connections
        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
        asyncPollTimeoutQueue - the DelayedExecutor.DelayQueue used by async connection poll mechanism
        connectionTTLQueue - the DelayedExecutor.DelayQueue used by connection TTL 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.
        asyncPollTimeoutMillis - the maximum time, the async poll operation could wait for a connection to become available
        connectionTTLMillis - the maximum time, a connection could stay registered with the pool
        failFastWhenMaxSizeReached - true if the "take" method should fail fast if there is no free connection in the pool and max pool size is reached

    • Method Detail

      • getEndpoint

        public Endpoint<E> getEndpoint()
        Returns:
        the endpoint description

      • getCorePoolSize

        public int getCorePoolSize()
        Returns:
        the number of Connections, kept in the pool, that are immune to keep-alive mechanism

      • getMaxPoolSize

        public int getMaxPoolSize()
        Returns:
        the max number of Connections kept by this pool

      • getConnectTimeout

        public long getConnectTimeout​(TimeUnit timeUnit)
        Parameters:
        timeUnit - TimeUnit
        Returns:
        the connection timeout, after which, if a connection is not established, it is considered failed

      • getReconnectDelay

        public long getReconnectDelay​(TimeUnit timeUnit)
        Parameters:
        timeUnit - TimeUnit
        Returns:
        the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous attempt fail

      • getMaxReconnectAttempts

        public int getMaxReconnectAttempts()
        Returns:
        the maximum number of reconnect attempts

      • getKeepAliveTimeout

        public long getKeepAliveTimeout​(TimeUnit timeUnit)
        Returns the maximum amount of time an idle Connection will be kept in the pool. The idle Connections will be closed till the pool size is greater than corePoolSize.
        Parameters:
        timeUnit - TimeUnit
        Returns:
        the maximum amount of time an idle Connection will be kept in the pool

      • getKeepAliveCheckInterval

        public long getKeepAliveCheckInterval​(TimeUnit timeUnit)
        Parameters:
        timeUnit - TimeUnit
        Returns:
        the interval, which specifies how often the pool will perform idle Connections check

      • getAsyncPollTimeout

        public long getAsyncPollTimeout​(TimeUnit timeUnit)
        Parameters:
        timeUnit - TimeUnit
        Returns:
        the timeout, after which, the async connection poll operation will fail with a timeout exception

      • getConnectionTTL

        public long getConnectionTTL​(TimeUnit timeUnit)
        Return the maximum amount of time, a Connection could be associated with the pool. Once timeout is hit - the connection will be either closed, if it's idle, or detached from the pool, if it's being used.
        Parameters:
        timeUnit - TimeUnit
        Returns:
        the maximum amount of time, a Connection could be associated with the pool

      • isFailFastWhenMaxSizeReached

        public boolean isFailFastWhenMaxSizeReached()
        Returns:
        true, if the "take" method will fail fast if there is no free connection in the pool and max pool size is reached

      • size

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

      • 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 be established, or false otherwise.

      • isRegistered

        public boolean isRegistered​(org.glassfish.grizzly.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​(org.glassfish.grizzly.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

      • getConnectionInfo

        public ConnectionInfo<E> getConnectionInfo​(org.glassfish.grizzly.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 org.glassfish.grizzly.GrizzlyFuture<org.glassfish.grizzly.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​(org.glassfish.grizzly.CompletionHandler<org.glassfish.grizzly.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.
        Parameters:
        completionHandler - to be notified once Connection is available or an error occurred

      • poll

        public org.glassfish.grizzly.Connection poll()
                                      throws IOException
        Returns:
        a Connection from the pool, if there is one available at the moment, or null otherwise
        Throws:
        IOException - if the pool is closed

      • release

        public boolean release​(org.glassfish.grizzly.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​(org.glassfish.grizzly.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. After calling this method, the Connection could be still used by the caller and release(org.glassfish.grizzly.Connection) should be called to return the Connection to the pool so it could be reused.
        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​(org.glassfish.grizzly.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
        Returns:
        true if the connection was successfully detached from this pool, otherwise returns false

      • 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. Please note, if the method returns true it also increases the pendingConnections counter, so don't forget to decrease it, if needed.
        Returns:
        true if new connection could be created, or false otherwise

      • getWaitingListSize

        protected int getWaitingListSize()
        Returns:
        the number of consumers waiting for a 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.
        Returns:
        true if a new Connection could be open, or false otherwise