Package org.glassfish.grizzly.connectionpool

Class MultiEndpointPool<E>

  • Type Parameters:
    E - the address type, for example for TCP transport it's SocketAddress
    public class MultiEndpointPool<E>
extends Object
    The multi endpoint Connection pool implementation where each endpoint sub-pool is represented by SingleEndpointPool and referenced by an Endpoint. There are number of configuration options supported by the MultiEndpointPool: - maxConnectionsPerEndpoint: the maximum number of Connections each SingleEndpointPool sub-pool is allowed to have; - maxConnectionsTotal: the total 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 until the pool size is greater than the 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

      • poolSync

        protected final Object poolSync
        Sync for endpointToPoolMap updates

    • Constructor Detail

      • MultiEndpointPool

        @Deprecated
protected MultiEndpointPool​(org.glassfish.grizzly.ConnectorHandler<E> defaultConnectorHandler,
                            int maxConnectionsPerEndpoint,
                            int maxConnectionsTotal,
                            org.glassfish.grizzly.utils.DelayedExecutor delayedExecutor,
                            long connectTimeoutMillis,
                            long keepAliveTimeoutMillis,
                            long keepAliveCheckIntervalMillis,
                            long reconnectDelayMillis,
                            int maxReconnectAttempts,
                            long asyncPollTimeoutMillis,
                            long connectionTTLMillis,
                            boolean failFastWhenMaxSizeReached,
                            MultiEndpointPool.EndpointPoolCustomizer<E> endpointPoolCustomizer)
        Deprecated.
        defaultConnectorHandler is deprecated
        Constructs MultiEndpointPool instance.
        Parameters:
        defaultConnectorHandler - the default ConnectorHandler to be used to establish new Connections
        maxConnectionsPerEndpoint - the maximum number of Connections single endpoint sub-pool is allowed to have
        maxConnectionsTotal - the total maximum number of Connections the pool is allowed to have
        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
        endpointPoolCustomizer - the customizer, which will be used to modify a specific endpoint pool settings and overwrite the default settings assigned by this MultiEndpointPool

      • MultiEndpointPool

        protected MultiEndpointPool​(int maxConnectionsPerEndpoint,
                            int maxConnectionsTotal,
                            org.glassfish.grizzly.utils.DelayedExecutor delayedExecutor,
                            long connectTimeoutMillis,
                            long keepAliveTimeoutMillis,
                            long keepAliveCheckIntervalMillis,
                            long reconnectDelayMillis,
                            int maxReconnectAttempts,
                            long asyncPollTimeoutMillis,
                            long connectionTTLMillis,
                            boolean failFastWhenMaxSizeReached,
                            MultiEndpointPool.EndpointPoolCustomizer<E> endpointPoolCustomizer)
        Constructs MultiEndpointPool instance.
        Parameters:
        maxConnectionsPerEndpoint - the maximum number of Connections single endpoint sub-pool is allowed to have
        maxConnectionsTotal - the total maximum number of Connections the pool is allowed to have
        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
        endpointPoolCustomizer - the customizer, which will be used to modify a specific endpoint pool settings and overwrite the default settings assigned by this MultiEndpointPool

    • Method Detail

      • getMaxConnectionsTotal

        public int getMaxConnectionsTotal()
        Returns:
        the total maximum number of Connections to be kept by the pool

      • getMaxConnectionsPerEndpoint

        public int getMaxConnectionsPerEndpoint()
        Returns:
        the maximum number of Connections each SingleEndpointPool sub-pool is allowed to have

      • 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.
        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

      • 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

      • 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​(Endpoint<E> endpoint)
        Obtains a Connection to the specified endpoint 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(endpoint).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());
 }
        Parameters:
        endpoint - Endpoint, that represents an endpoint
        Returns:
        GrizzlyFuture

      • take

        public void take​(Endpoint<E> endpoint,
                 org.glassfish.grizzly.CompletionHandler<org.glassfish.grizzly.Connection> completionHandler)
        Obtains a Connection to the specified endpoint 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:
        endpoint - Endpoint, that represents an endpoint
        completionHandler -

      • poll

        public org.glassfish.grizzly.Connection poll​(Endpoint<E> endpoint)
                                      throws IOException
        Parameters:
        endpoint - Endpoint, that represents an endpoint
        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(Endpoint, 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​(Endpoint<E> endpoint,
                      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.
        Parameters:
        endpoint - Endpoint, that represents an endpoint to which the the Connection will be attached
        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.connectionpool.Endpoint, 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 detached, otherwise returns false

      • close

        public void close​(Endpoint<E> endpoint)
        Closes specific endpoint associated pool and releases its resources. The ready Connections associated with the endpoint pool 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).
        Parameters:
        endpoint - Endpoint, that represents an endpoint

      • close

        public void close()
        Closes the pool and releases 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).

      • checkNotClosed

        protected void checkNotClosed()
                       throws IOException
        Method throws IOException if the pool has been closed.
        Throws:
        IOException - if the pool has been closed