ConnectionPool (Payara Project 4.1.2.174 API)

java.lang.Object
- com.sun.enterprise.resource.pool.ConnectionPool

All Implemented Interfaces:

ConnectionLeakListener, PoolProperties, ResourceHandler, ResourcePool

Direct Known Subclasses:

AssocWithThreadResourcePool, UnpooledResource
```
public class ConnectionPool
extends Object
implements ResourcePool, ConnectionLeakListener, ResourceHandler, PoolProperties
```
Connection Pool for Connector & JDBC resources

Author:

Jagadish Ramu

Field Summary

Fields
Modifier and Type	Field and Description
`protected static Logger`	`_logger`
`protected ResourceAllocator`	`allocator`
`protected long`	`conCreationRetryInterval_`
`protected boolean`	`connectionCreationRetry_`
`protected int`	`connectionCreationRetryAttempts_`
`protected String`	`dataStructureParameters`
`protected String`	`dataStructureType`
`protected DataStructure`	`ds`
`protected boolean`	`failAllConnections`
`protected ResourceGateway`	`gateway`
`protected long`	`idletime`
`protected ConnectionLeakDetector`	`leakDetector`
`protected static StringManager`	`localStrings`
`protected boolean`	`matchConnections`
`protected int`	`maxConnectionUsage_`
`protected int`	`maxPoolSize`
`protected int`	`maxWaitTime`
`protected PoolInfo`	`poolInfo`
`protected boolean`	`poolInitialized`
`protected PoolLifeCycleListener`	`poolLifeCycleListener`
`protected String`	`poolWaitQueueClass`
`protected boolean`	`preferValidateOverRecreate`
`protected PoolWaitQueue`	`reconfigWaitQueue`
`protected int`	`resizeQuantity`
`protected Resizer`	`resizerTask`
`protected String`	`resourceGatewayClass`
`protected String`	`resourceSelectionStrategyClass`
`protected int`	`steadyPoolSize`
`protected Timer`	`timer`
`protected long`	`validateAtmostPeriodInMilliSeconds_`
`protected boolean`	`validation`
`protected PoolWaitQueue`	`waitQueue`

Constructor Summary

Constructors
Constructor and Description

ConnectionPool(PoolInfo poolInfo, Hashtable env)

Constructors
Constructor and Description
`ConnectionPool(PoolInfo poolInfo, Hashtable env)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addResource(ResourceAllocator alloc)` add a resource with status busy and not enlisted
`void`	`blockRequests(long waitTimeout)` block any new requests to the pool Used for transparent dynamic reconfiguration of the pool
`void`	`cancelResizerTask()`
`protected boolean`	`cleanupResource(ResourceHandle handle)`
`ResourceHandle`	`createResource(ResourceAllocator alloc)` create a new resource using the given resource-allocator
`void`	`createResourceAndAddToPool()` create a new resource and add it to pool (using default resource-allocator)
`protected ResourceHandle`	`createSingleResource(ResourceAllocator resourceAllocator)` Method to be used to create resource, instead of calling ResourceAllocator.createConfigBean().
`protected ResourceHandle`	`createSingleResourceAndAdjustPool(ResourceAllocator alloc, ResourceSpec spec)` This method will be called from the getUnenlistedResource method if we detect a failAllConnection flag.
`void`	`deleteResource(ResourceHandle resourceHandle)` destroys the given resource
`void`	`dumpPoolStatus()` This method can be used for debugging purposes
`void`	`emptyFreeConnectionsInPool()`
`void`	`emptyPool()`
`boolean`	`flushConnectionPool()` Reinitialize connections established in the connection pool and bring the pool to steady pool size.
`protected void`	`freeResource(ResourceHandle resourceHandle)`
`protected void`	`freeUnenlistedResource(ResourceHandle h)`
`long`	`getIdleTimeout()` gets the idle connection timeout value
`Set`	`getInvalidConnections(Set connections)` gets the invalid connections from the given connections set
`int`	`getMaxPoolSize()` Gets the max-pool-size attribute of this pool.
`protected ConnectorConnectionPool`	`getPoolConfigurationFromJndi(Hashtable env)`
`PoolInfo`	`getPoolInfo()` query the name of this pool.
`PoolStatus`	`getPoolStatus()` Get Connection Pool status by computing the free/used values of the connections in the pool.
`PoolWaitQueue`	`getPoolWaitQueue()` returns pool-wait-queue
`PoolWaitQueue`	`getReconfigWaitQueue()` returns wait-queue used during transparent dynamic reconfiguration
`long`	`getReconfigWaitTime()` returns the reconfig-wait-time
`int`	`getResizeQuantity()` gets the resize quantity of the pool
`ResourceHandle`	`getResource(ResourceSpec spec, ResourceAllocator alloc, Transaction txn)` returns resource from the pool.
`protected ResourceHandle`	`getResourceFromPool(ResourceAllocator alloc, ResourceSpec spec)` return resource in free list.
`int`	`getSteadyPoolSize()` Gets the steady-pool-size attribute of this pool.
`protected ResourceHandle`	`getUnenlistedResource(ResourceSpec spec, ResourceAllocator alloc, Transaction tran)` To provide an unenlisted, valid, matched resource from pool.
`int`	`getWaitQueueLength()` gets the current wait queue length
`protected void`	`initializePoolDataStructure()`
`protected void`	`initializePoolWaitQueue()`
`protected Resizer`	`initializeResizer()`
`protected void`	`initializeResourceSelectionStrategy()`
`protected void`	`initPool(ResourceAllocator allocator)`
`protected ResourceHandle`	`internalGetResource(ResourceSpec spec, ResourceAllocator alloc, Transaction tran)`
`void`	`invalidConnectionDetected(ResourceHandle h)` callback method to handle the case of invalid connection detected
`protected boolean`	`isConnectionValid(ResourceHandle h, ResourceAllocator alloc)` Check whether the connection is valid
`protected boolean`	`isResourceUnused(ResourceHandle h)`
`protected boolean`	`isSelfManaged()`
`protected boolean`	`matchConnection(ResourceHandle resource, ResourceAllocator alloc)` check whether the connection retrieved from the pool matches with the request.
`protected void`	`notifyWaitingThreads()`
`protected void`	`performMaxConnectionUsageOperation(ResourceHandle handle)` If the resource is used for maxConnectionUsage times, destroy and create one
`void`	`potentialConnectionLeakFound()` listener method to handle in the event of connection leak detected
`protected ResourceHandle`	`prefetch(ResourceSpec spec, ResourceAllocator alloc, Transaction tran)` Overridden in AssocWithThreadResourcePool to fetch the resource cached in the ThreadLocal In ConnectionPool this simply returns null.
`void`	`printConnectionLeakTrace(StringBuffer stackTrace)` to print the stack trace of the caller of getConnection
`void`	`reclaimConnection(ResourceHandle handle)` reclaim the leaked connection
`void`	`reconfigurePool(ConnectorConnectionPool poolResource)` Reconfigure the Pool's properties.
`protected void`	`reconfigureSteadyPoolSize(int oldSteadyPoolSize, int newSteadyPoolSize)`
`void`	`removePoolLifeCycleListener()` remove pool life cycle listener
`void`	`resizePool(boolean forced)`
`void`	`resourceClosed(ResourceHandle h)` this method is called to indicate that the resource is not used by a bean/application anymore
`void`	`resourceEnlisted(Transaction tran, ResourceHandle resource)` this method is called when a resource is enlisted in
`void`	`resourceErrorOccurred(ResourceHandle h)`
`void`	`setMaxPoolSize(int size)` Sets the max-pool-size value for this pool.
`void`	`setPoolLifeCycleListener(PoolLifeCycleListener listener)` set pool life cycle listener
`protected void`	`setResourceStateToBusy(ResourceHandle resourceHandle)` marks resource as busy.
`protected void`	`setResourceStateToFree(ResourceHandle resourceHandle)` marks resource as free.
`void`	`setSelfManaged(boolean selfManaged)` Sets/Resets the flag indicating if this pool is self managed.
`void`	`setSteadyPoolSize(int size)` Sets the steady-pool-size value for this pool.
`void`	`switchOnMatching()` Switch on matching of connections in the pool.
`String`	`toString()`
`void`	`transactionCompleted(Transaction tran, int status)` this method is called when transaction tran is completed

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - localStrings
```
protected static final StringManager localStrings
```
  - _logger
```
protected static final Logger _logger
```
  - maxPoolSize
```
protected int maxPoolSize
```
  - steadyPoolSize
```
protected int steadyPoolSize
```
  - resizeQuantity
```
protected int resizeQuantity
```
  - maxWaitTime
```
protected int maxWaitTime
```
  - idletime
```
protected long idletime
```
  - failAllConnections
```
protected boolean failAllConnections
```
  - matchConnections
```
protected boolean matchConnections
```
  - validation
```
protected boolean validation
```
  - preferValidateOverRecreate
```
protected boolean preferValidateOverRecreate
```
  - resizerTask
```
protected Resizer resizerTask
```
  - poolInitialized
```
protected volatile boolean poolInitialized
```
  - timer
```
protected Timer timer
```
  - connectionCreationRetry_
```
protected boolean connectionCreationRetry_
```
  - connectionCreationRetryAttempts_
```
protected int connectionCreationRetryAttempts_
```
  - conCreationRetryInterval_
```
protected long conCreationRetryInterval_
```
  - validateAtmostPeriodInMilliSeconds_
```
protected long validateAtmostPeriodInMilliSeconds_
```
  - maxConnectionUsage_
```
protected int maxConnectionUsage_
```
  - resourceSelectionStrategyClass
```
protected String resourceSelectionStrategyClass
```
  - poolLifeCycleListener
```
protected PoolLifeCycleListener poolLifeCycleListener
```
  - gateway
```
protected ResourceGateway gateway
```
  - resourceGatewayClass
```
protected String resourceGatewayClass
```
  - leakDetector
```
protected ConnectionLeakDetector leakDetector
```
  - ds
```
protected DataStructure ds
```
  - dataStructureType
```
protected String dataStructureType
```
  - dataStructureParameters
```
protected String dataStructureParameters
```
  - waitQueue
```
protected PoolWaitQueue waitQueue
```
  - reconfigWaitQueue
```
protected PoolWaitQueue reconfigWaitQueue
```
  - poolWaitQueueClass
```
protected String poolWaitQueueClass
```
  - poolInfo
```
protected final PoolInfo poolInfo
```
  - allocator
```
protected ResourceAllocator allocator
```
- Constructor Detail
  - ConnectionPool
```
public ConnectionPool(PoolInfo poolInfo,
                      Hashtable env)
               throws PoolingException
```
    Throws:
    
    PoolingException
- Method Detail
  - initializePoolWaitQueue
```
protected void initializePoolWaitQueue()
                                throws PoolingException
```
    Throws:
    
    PoolingException
  - initializePoolDataStructure
```
protected void initializePoolDataStructure()
                                    throws PoolingException
```
    Throws:
    
    PoolingException
  - initializeResourceSelectionStrategy
```
protected void initializeResourceSelectionStrategy()
```
  - getPoolConfigurationFromJndi
```
protected ConnectorConnectionPool getPoolConfigurationFromJndi(Hashtable env)
                                                        throws PoolingException
```
    Throws:
    
    PoolingException
  - initPool
```
protected void initPool(ResourceAllocator allocator)
                 throws PoolingException
```
    Throws:
    
    PoolingException
  - initializeResizer
```
protected Resizer initializeResizer()
```
  - addResource
```
public void addResource(ResourceAllocator alloc)
                 throws PoolingException
```
    add a resource with status busy and not enlisted
    
    Parameters:
    
    alloc - ResourceAllocator
    
    Throws:
    
    PoolingException - when unable to add a resource
  - setResourceStateToFree
```
protected void setResourceStateToFree(ResourceHandle resourceHandle)
```
    marks resource as free. This method should be used instead of directly calling resoureHandle.getResourceState().setBusy(false) OR getResourceState(resourceHandle).setBusy(false) as this method handles stopping of connection leak tracing If connection leak tracing is enabled, takes care of stopping connection leak tracing
    
    Parameters:
    
    resourceHandle - Resource
  - setResourceStateToBusy
```
protected void setResourceStateToBusy(ResourceHandle resourceHandle)
```
    marks resource as busy. This method should be used instead of directly calling resoureHandle.getResourceState().setBusy(true) OR getResourceState(resourceHandle).setBusy(true) as this method handles starting of connection leak tracing If connection leak tracing is enabled, takes care of starting connection leak tracing
    
    Parameters:
    
    resourceHandle - Resource
  - getResource
```
public ResourceHandle getResource(ResourceSpec spec,
                                  ResourceAllocator alloc,
                                  Transaction txn)
                           throws PoolingException,
                                  javax.resource.spi.RetryableUnavailableException
```
    returns resource from the pool.
    
    Specified by:
    
    getResource in interface ResourcePool
    
    Returns:
    
    a free pooled resource object matching the ResourceSpec
    
    Throws:
    
    PoolingException - - if any error occurrs - or the pool has reached its max size and the max-connection-wait-time-in-millis has expired.
    
    javax.resource.spi.RetryableUnavailableException
  - prefetch
```
protected ResourceHandle prefetch(ResourceSpec spec,
                                  ResourceAllocator alloc,
                                  Transaction tran)
```
    Overridden in AssocWithThreadResourcePool to fetch the resource cached in the ThreadLocal In ConnectionPool this simply returns null.
    
    Parameters:
    
    spec - ResourceSpec
    
    alloc - ResourceAllocator to create a resource
    
    tran - Transaction
    
    Returns:
    
    ResourceHandle resource from ThreadLocal
  - internalGetResource
```
protected ResourceHandle internalGetResource(ResourceSpec spec,
                                             ResourceAllocator alloc,
                                             Transaction tran)
                                      throws PoolingException
```
    Throws:
    
    PoolingException
  - getUnenlistedResource
```
protected ResourceHandle getUnenlistedResource(ResourceSpec spec,
                                               ResourceAllocator alloc,
                                               Transaction tran)
                                        throws PoolingException
```
    To provide an unenlisted, valid, matched resource from pool.
    
    Parameters:
    
    spec - ResourceSpec
    
    alloc - ResourceAllocator
    
    tran - Transaction
    
    Returns:
    
    ResourceHandle resource from pool
    
    Throws:
    
    PoolingException - Exception while getting resource from pool
  - isConnectionValid
```
protected boolean isConnectionValid(ResourceHandle h,
                                    ResourceAllocator alloc)
```
    Check whether the connection is valid
    
    Parameters:
    
    h - Resource to be validated
    
    alloc - Allocator to validate the resource
    
    Returns:
    
    boolean representing validation result
  - matchConnection
```
protected boolean matchConnection(ResourceHandle resource,
                                  ResourceAllocator alloc)
```
    check whether the connection retrieved from the pool matches with the request.
    
    Parameters:
    
    resource - Resource to be matched
    
    alloc - ResourceAllocator used to match the connection
    
    Returns:
    
    boolean representing the match status of the connection
  - getResourceFromPool
```
protected ResourceHandle getResourceFromPool(ResourceAllocator alloc,
                                             ResourceSpec spec)
                                      throws PoolingException
```
    return resource in free list. If none is found, try to scale up the pool/purge pool and
    return a new resource. returns null if the pool new resources cannot be created.
    
    Parameters:
    
    alloc - ResourceAllocator
    
    Returns:
    
    ResourceHandle resource from pool
    
    Throws:
    
    PoolingException - if unable to create a new resource
  - createSingleResourceAndAdjustPool
```
protected ResourceHandle createSingleResourceAndAdjustPool(ResourceAllocator alloc,
                                                           ResourceSpec spec)
                                                    throws PoolingException
```
    This method will be called from the getUnenlistedResource method if we detect a failAllConnection flag. Here we simply create a new resource and replace a free resource in the pool by this resource and then give it out. This replacement is required since the steadypoolsize might equal maxpoolsize and in that case if we were not to remove a resource from the pool, our resource would be above maxPoolSize
    
    Parameters:
    
    alloc - ResourceAllocator to create resource
    
    spec - ResourceSpec
    
    Returns:
    
    newly created resource
    
    Throws:
    
    PoolingException - when unable to create a resource
  - createSingleResource
```
protected ResourceHandle createSingleResource(ResourceAllocator resourceAllocator)
                                       throws PoolingException
```
    Method to be used to create resource, instead of calling ResourceAllocator.createConfigBean(). This method handles the connection creation retrial in case of failure
    
    Parameters:
    
    resourceAllocator - ResourceAllocator
    
    Returns:
    
    ResourceHandle newly created resource
    
    Throws:
    
    PoolingException - when unable create a resource
  - setPoolLifeCycleListener
```
public void setPoolLifeCycleListener(PoolLifeCycleListener listener)
```
    Description copied from interface: ResourcePool
    
    set pool life cycle listener
    
    Specified by:
    
    setPoolLifeCycleListener in interface ResourcePool
  - removePoolLifeCycleListener
```
public void removePoolLifeCycleListener()
```
    Description copied from interface: ResourcePool
    
    remove pool life cycle listener
    
    Specified by:
    
    removePoolLifeCycleListener in interface ResourcePool
  - deleteResource
```
public void deleteResource(ResourceHandle resourceHandle)
```
    Description copied from interface: ResourceHandler
    
    destroys the given resource
    
    Specified by:
    
    deleteResource in interface ResourceHandler
    
    Parameters:
    
    resourceHandle - resource to be destroyed
  - resourceClosed
```
public void resourceClosed(ResourceHandle h)
                    throws IllegalStateException
```
    this method is called to indicate that the resource is not used by a bean/application anymore
    
    Specified by:
    
    resourceClosed in interface ResourcePool
    
    Throws:
    
    IllegalStateException
  - performMaxConnectionUsageOperation
```
protected void performMaxConnectionUsageOperation(ResourceHandle handle)
```
    If the resource is used for maxConnectionUsage times, destroy and create one
    
    Parameters:
    
    handle - Resource to be checked
  - freeUnenlistedResource
```
protected void freeUnenlistedResource(ResourceHandle h)
```
  - freeResource
```
protected void freeResource(ResourceHandle resourceHandle)
```
  - cleanupResource
```
protected boolean cleanupResource(ResourceHandle handle)
```
  - resourceErrorOccurred
```
public void resourceErrorOccurred(ResourceHandle h)
                           throws IllegalStateException
```
    Specified by:
    
    resourceErrorOccurred in interface ResourcePool
    
    Throws:
    
    IllegalStateException
  - resourceEnlisted
```
public void resourceEnlisted(Transaction tran,
                             ResourceHandle resource)
                      throws IllegalStateException
```
    this method is called when a resource is enlisted in
    
    Specified by:
    
    resourceEnlisted in interface ResourcePool
    
    Parameters:
    
    tran - Transaction
    
    resource - ResourceHandle
    
    Throws:
    
    IllegalStateException
  - transactionCompleted
```
public void transactionCompleted(Transaction tran,
                                 int status)
                          throws IllegalStateException
```
    this method is called when transaction tran is completed
    
    Specified by:
    
    transactionCompleted in interface ResourcePool
    
    Parameters:
    
    tran - Transaction
    
    status - status of transaction
    
    Throws:
    
    IllegalStateException
  - isResourceUnused
```
protected boolean isResourceUnused(ResourceHandle h)
```
  - createResource
```
public ResourceHandle createResource(ResourceAllocator alloc)
                              throws PoolingException
```
    Description copied from interface: ResourceHandler
    
    create a new resource using the given resource-allocator
    
    Specified by:
    
    createResource in interface ResourceHandler
    
    Parameters:
    
    alloc - allocator to create a resource
    
    Returns:
    
    newly created resource
    
    Throws:
    
    PoolingException - when unable to create a resource
  - createResourceAndAddToPool
```
public void createResourceAndAddToPool()
                                throws PoolingException
```
    Description copied from interface: ResourceHandler
    
    create a new resource and add it to pool (using default resource-allocator)
    
    Specified by:
    
    createResourceAndAddToPool in interface ResourceHandler
    
    Throws:
    
    PoolingException - when unable to create a resource
  - getInvalidConnections
```
public Set getInvalidConnections(Set connections)
                          throws javax.resource.ResourceException
```
    Description copied from interface: ResourceHandler
    
    gets the invalid connections from the given connections set
    
    Specified by:
    
    getInvalidConnections in interface ResourceHandler
    
    Parameters:
    
    connections - that need to be validated
    
    Returns:
    
    invalid connections set
    
    Throws:
    
    javax.resource.ResourceException - when unable to validate
  - invalidConnectionDetected
```
public void invalidConnectionDetected(ResourceHandle h)
```
    Description copied from interface: ResourceHandler
    
    callback method to handle the case of invalid connection detected
    
    Specified by:
    
    invalidConnectionDetected in interface ResourceHandler
    
    Parameters:
    
    h - connection that is invalid
  - resizePool
```
public void resizePool(boolean forced)
```
    Specified by:
    
    resizePool in interface ResourcePool
  - notifyWaitingThreads
```
protected void notifyWaitingThreads()
```
  - emptyPool
```
public void emptyPool()
```
    Specified by:
    
    emptyPool in interface ResourcePool
  - emptyFreeConnectionsInPool
```
public void emptyFreeConnectionsInPool()
```
    Specified by:
    
    emptyFreeConnectionsInPool in interface ResourcePool
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - blockRequests
```
public void blockRequests(long waitTimeout)
```
    Description copied from interface: ResourcePool
    
    block any new requests to the pool Used for transparent dynamic reconfiguration of the pool
    
    Specified by:
    
    blockRequests in interface ResourcePool
    
    Parameters:
    
    waitTimeout - time for which the new requests will wait
  - getPoolWaitQueue
```
public PoolWaitQueue getPoolWaitQueue()
```
    Description copied from interface: ResourcePool
    
    returns pool-wait-queue
    
    Specified by:
    
    getPoolWaitQueue in interface ResourcePool
    
    Returns:
    
    wait-queue
  - getReconfigWaitQueue
```
public PoolWaitQueue getReconfigWaitQueue()
```
    Description copied from interface: ResourcePool
    
    returns wait-queue used during transparent dynamic reconfiguration
    
    Specified by:
    
    getReconfigWaitQueue in interface ResourcePool
    
    Returns:
    
    PoolWaitQueue
  - getReconfigWaitTime
```
public long getReconfigWaitTime()
```
    Description copied from interface: ResourcePool
    
    returns the reconfig-wait-time
    
    Specified by:
    
    getReconfigWaitTime in interface ResourcePool
    
    Returns:
    
    long
  - flushConnectionPool
```
public boolean flushConnectionPool()
                            throws PoolingException
```
    Reinitialize connections established in the connection pool and bring the pool to steady pool size.
    
    Specified by:
    
    flushConnectionPool in interface ResourcePool
    
    Returns:
    
    boolean indicating whether flush operation was successful or not
    
    Throws:
    
    PoolingException
  - reconfigurePool
```
public void reconfigurePool(ConnectorConnectionPool poolResource)
                     throws PoolingException
```
    Reconfigure the Pool's properties. The reconfigConnectorConnectionPool method in the ConnectorRuntime will use this method (through PoolManager) if it needs to just change pool properties and not recreate the pool
    
    Specified by:
    
    reconfigurePool in interface ResourcePool
    
    Parameters:
    
    poolResource - - the ConnectorConnectionPool JavaBean that holds the new pool properties
    
    Throws:
    
    PoolingException - if the pool resizing fails
  - reconfigureSteadyPoolSize
```
protected void reconfigureSteadyPoolSize(int oldSteadyPoolSize,
                                         int newSteadyPoolSize)
                                  throws PoolingException
```
    Throws:
    
    PoolingException
  - switchOnMatching
```
public void switchOnMatching()
```
    Switch on matching of connections in the pool.
    
    Specified by:
    
    switchOnMatching in interface ResourcePool
  - getPoolInfo
```
public PoolInfo getPoolInfo()
```
    query the name of this pool. Required by monitoring
    
    Specified by:
    
    getPoolInfo in interface ResourcePool
    
    Returns:
    
    the name of this pool
  - cancelResizerTask
```
public void cancelResizerTask()
```
    Specified by:
    
    cancelResizerTask in interface ResourcePool
  - dumpPoolStatus
```
public void dumpPoolStatus()
```
    This method can be used for debugging purposes
  - getMaxPoolSize
```
public int getMaxPoolSize()
```
    Description copied from interface: ResourcePool
    
    Gets the max-pool-size attribute of this pool. Envisaged to be used by the Self management framework to query the pool size attribute for tweaking it using the setMaxPoolSize method
    
    Specified by:
    
    getMaxPoolSize in interface PoolProperties
    
    Specified by:
    
    getMaxPoolSize in interface ResourcePool
    
    Returns:
    
    max-pool-size value for this pool
    
    See Also:
    
    setMaxPoolSize
  - getResizeQuantity
```
public int getResizeQuantity()
```
    Description copied from interface: PoolProperties
    
    gets the resize quantity of the pool
    
    Specified by:
    
    getResizeQuantity in interface PoolProperties
    
    Returns:
    
    resize quantity
  - getIdleTimeout
```
public long getIdleTimeout()
```
    Description copied from interface: PoolProperties
    
    gets the idle connection timeout value
    
    Specified by:
    
    getIdleTimeout in interface PoolProperties
    
    Returns:
    
    idle timeout value
  - getWaitQueueLength
```
public int getWaitQueueLength()
```
    Description copied from interface: PoolProperties
    
    gets the current wait queue length
    
    Specified by:
    
    getWaitQueueLength in interface PoolProperties
    
    Returns:
    
    wait queue length
  - getSteadyPoolSize
```
public int getSteadyPoolSize()
```
    Description copied from interface: ResourcePool
    
    Gets the steady-pool-size attribute of this pool. Envisaged to be used by the Self management framework to query the pool size attribute for tweaking it using the setSteadyPoolSize method
    
    Specified by:
    
    getSteadyPoolSize in interface PoolProperties
    
    Specified by:
    
    getSteadyPoolSize in interface ResourcePool
    
    Returns:
    
    steady-pool-size value for this pool
    
    See Also:
    
    setSteadyPoolSize
  - setMaxPoolSize
```
public void setMaxPoolSize(int size)
```
    Description copied from interface: ResourcePool
    
    Sets the max-pool-size value for this pool. This attribute is expected to be set by the self-management framework for an optimum max-pool-size. The corresponding accessor gets this value.
    
    Specified by:
    
    setMaxPoolSize in interface ResourcePool
    
    Parameters:
    
    size - - The new max-pool-size value
    
    See Also:
    
    getMaxPoolSize
  - setSteadyPoolSize
```
public void setSteadyPoolSize(int size)
```
    Description copied from interface: ResourcePool
    
    Sets the steady-pool-size value for this pool. This attribute is expected to be set by the self-management framework for an optimum steady-pool-size. The corresponding accessor gets this value.
    
    Specified by:
    
    setSteadyPoolSize in interface ResourcePool
    
    Parameters:
    
    size - - The new steady-pool-size value
    
    See Also:
    
    getSteadyPoolSize
  - setSelfManaged
```
public void setSelfManaged(boolean selfManaged)
```
    Description copied from interface: ResourcePool
    
    Sets/Resets the flag indicating if this pool is self managed. This method would be typically called by the self management framework to indicate to the world (and this pool) that this pool is self managed. Its very important that the self mgmt framework properly sets this flag to control the dynamic reconfig behavior of this pool. If this flag is set to true, all dynamic reconfigs affecting the max/steady pool size of this pool will be ignored.
    
    Specified by:
    
    setSelfManaged in interface ResourcePool
    
    Parameters:
    
    selfManaged - - true to switch on self management, false otherwise
  - isSelfManaged
```
protected boolean isSelfManaged()
```
  - potentialConnectionLeakFound
```
public void potentialConnectionLeakFound()
```
    Description copied from interface: ConnectionLeakListener
    
    listener method to handle in the event of connection leak detected
    
    Specified by:
    
    potentialConnectionLeakFound in interface ConnectionLeakListener
  - printConnectionLeakTrace
```
public void printConnectionLeakTrace(StringBuffer stackTrace)
```
    Description copied from interface: ConnectionLeakListener
    
    to print the stack trace of the caller of getConnection
    
    Specified by:
    
    printConnectionLeakTrace in interface ConnectionLeakListener
    
    Parameters:
    
    stackTrace - Stack trace of the caller
  - reclaimConnection
```
public void reclaimConnection(ResourceHandle handle)
```
    Description copied from interface: ConnectionLeakListener
    
    reclaim the leaked connection
    
    Specified by:
    
    reclaimConnection in interface ConnectionLeakListener
    
    Parameters:
    
    handle - Resource to be reclaimed
  - getPoolStatus
```
public PoolStatus getPoolStatus()
```
    Get Connection Pool status by computing the free/used values of the connections in the pool. Computations are based on whether the pool is initialized or not when this method is invoked.
    
    Specified by:
    
    getPoolStatus in interface ResourcePool
    
    Returns:
    
    PoolStatus object

Class ConnectionPool

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

localStrings

_logger

maxPoolSize

steadyPoolSize

resizeQuantity

maxWaitTime

idletime

failAllConnections

matchConnections

validation

preferValidateOverRecreate

resizerTask

poolInitialized

timer

connectionCreationRetry_

connectionCreationRetryAttempts_

conCreationRetryInterval_

validateAtmostPeriodInMilliSeconds_

maxConnectionUsage_

resourceSelectionStrategyClass

poolLifeCycleListener

gateway

resourceGatewayClass

leakDetector

ds

dataStructureType

dataStructureParameters

waitQueue

reconfigWaitQueue

poolWaitQueueClass

poolInfo

allocator

Constructor Detail

ConnectionPool

Method Detail

initializePoolWaitQueue

initializePoolDataStructure

initializeResourceSelectionStrategy

getPoolConfigurationFromJndi

initPool

initializeResizer

addResource

setResourceStateToFree

setResourceStateToBusy

getResource

prefetch

internalGetResource

getUnenlistedResource

isConnectionValid

matchConnection

getResourceFromPool

createSingleResourceAndAdjustPool

createSingleResource

setPoolLifeCycleListener

removePoolLifeCycleListener

deleteResource

resourceClosed

performMaxConnectionUsageOperation

freeUnenlistedResource

freeResource

cleanupResource

resourceErrorOccurred

resourceEnlisted

transactionCompleted

isResourceUnused

createResource

createResourceAndAddToPool

getInvalidConnections

invalidConnectionDetected

resizePool

notifyWaitingThreads

emptyPool

emptyFreeConnectionsInPool

toString