ConnectionPool (Oracle Communications Billing and Revenue Management PCM Java API Reference)

java.lang.Object
- com.portal.pfc.infranet.connpool.ConnectionPool

All Implemented Interfaces:

ConnectionPoolMBean
```
public class ConnectionPool
extends java.lang.Object
implements ConnectionPoolMBean
```
This provides encapsulation for many connections (connection pool) for a end-client (webkit, cdk). In other words this manages the multiple CM connections. This is modeled after PortalConnectionPool in CDK and roughly compares to PPooledConnectionClientServices in the BAS world. This class internally has a delegate to ConnectionFactory object which really builds the objects we need.

There are a couple of different timeouts that are worth mentioning: the max idle timeout determines how long a connection can be idle in the pool before it is closed; the timeout determines how long a caller will wait for a connection to be available in the pool (assuming heavy load).

The following properties can be set in Infranet.properties to control aspects of this connection pool:
- infranet.connectionpool.maxsize - max connections in the pool
- infranet.connectionpool.minsize - min connections in the pool
- infranet.connectionpool.timeout - time caller waits for a connection
- infranet.connectionpool.maxidletime - time before an idle connection is closed
- infranet.connectionpool.maxrequestlistsize - maximum requests allowed in the waiting list
See Also:

ConnectionFactory

Constructor Summary

Constructors
Constructor and Description
`ConnectionPool(ConnectionFactory cf)` Default connection pool constructor.
`ConnectionPool(ConnectionFactory cf, FList connFL)` Constructor that takes an FList containing login params.
`ConnectionPool(ConnectionFactory cf, java.util.Properties p)` Constructor that reads in Connectionpool-specific properties info from a properties object
`ConnectionPool(ConnectionFactory cf, java.util.Properties p, int timeOut)` Constructor that reads in Connectionpool-specific properties info from a properties object.
`ConnectionPool(java.lang.String host, java.lang.String port, java.lang.String user, java.lang.String password, java.lang.String service)` Constructor that takes a set of connection related properties.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addToFreeConnection(PortalContext connection, long lastUsedTime, java.lang.String descr)`
`void`	`closeConnection(PortalContext connection, boolean bDecCntFlag)`
`protected void`	`closeIdleConnections()` Closes any idle connections in the free-connection list.
`protected java.lang.Object[]`	`createConnections(int size)` Creates size number of connections and returns
`static void`	`createInstance(ConnectionFactory cf)` A helper singleton that wraps the single-argument constructor
`static void`	`createInstance(ConnectionFactory cf, FList fl)` A helper singleton that wraps the 2-argument constructor
`static void`	`createInstance(ConnectionFactory cf, java.util.Properties p)` A helper singleton that wraps the (connection factory, properties) constructor
`PortalContext`	`getConnection()` Returns an instance of connection.
`ConnectionFactory`	`getConnectionFactory()` returns the current connection factory.
`long`	`getConnectionIdleTime()`
`long`	`getConnectionTimeOut()`
`long`	`getConnPoolTimeout()`
`int`	`getCurrentConnectionCount()`
`int`	`getCurrentUsedConnections()`
`long`	`getFailedConnRequest()`
`int`	`getFreeConnections()`
`int`	`getHighestCurConnCount()`
`int`	`getHighestFree()`
`int`	`getHighestRequestListSize()`
`long`	`getHighFailedConnRequest()`
`int`	`getHighFreeCons()`
`int`	`getHighPendingRequests()`
`int`	`getHighTotalCons()`
`int`	`getHighUsedConnections()`
`long`	`getIdleTime()`
`static ConnectionPool`	`getInstance()` A helper -static call to create an instance of the pool a la singleton This creates a static instance of Connection Pool and returns it to the calling application.
`int`	`getLowestHeadroom()` How close to queueing did we get? High headroom means that load not high enough to warrant qeueing Zero Headroom means that queuing started
`int`	`getMaxConnections()`
`int`	`getMaxPoolSize()`
`int`	`getMaxRequestListSize()`
`int`	`getMinConnections()`
`int`	`getMinPoolSize()`
`int`	`getNumberOfFreeConnections()`
`int`	`getNumberOfPendingRequests()`
`long`	`getNumFailedRequest()`
`long`	`getNumHighFailedRequest()`
`int`	`getNumHighUsedConnections()`
`int`	`getPendingRequests()`
`long`	`getReconnectFrequency()`
`long`	`getReConnFrequency()`
`int`	`getRequestQSize()`
`long`	`getTestConnectionFrequency()`
`long`	`getTestFrequency()`
`int`	`getTotalConnections()`
`int`	`getUsedConnections()`
`protected void`	`init(java.lang.String connectionURL)` Reads in all the property settings in the property file.
`protected boolean`	`isIdleConnection(com.portal.pfc.infranet.connpool.ConnectionPool.TimedConnection tc)`
`void`	`ReConnectAll()`
`protected void`	`reEstablishAllConnections()`
`void`	`releaseBadConnection(PortalContext pc)` Close the bad connections TCP/IP socket, and decreasing the connection pool size.
`void`	`releaseConnection(PortalContext connection)` This method does the following: - Checks to see if there are any threads waiting, if not the connection is returned to the free pool and closeIdleConnections is called.
`void`	`resetFailCount()`
`void`	`resetHighestStats()` Reset pool health highest stats.
`void`	`setConnectionIdleTime(long newIdleTime)`
`void`	`setConnectionTimeOut(long poolTimeout)`
`void`	`setConnPoolTimeout(long poolTimeout)`
`void`	`setIdleTime(long newIdleTime)`
`void`	`setMaxConnections(int maxConns)`
`void`	`setMaxPoolSize(int maxPoolSize)`
`void`	`setMaxRequestListSize(int reqQSize)`
`void`	`setMinConnections(int minConns)`
`void`	`setMinPoolSize(int minPoolSize)`
`void`	`setReconnectFrequency(long reconnFreq)`
`void`	`setReConnFrequency(long reconFreq)`
`void`	`setRequestQSize(int reqSize)`
`void`	`setTestConnectionFrequency(long testFreq)`
`void`	`setTestFrequency(long testFreq)`
`void`	`testFreeConnections()`

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

- Constructor Detail
  - ConnectionPool
```
public ConnectionPool(ConnectionFactory cf)
               throws EBufException
```
    Default connection pool constructor. This would read the property file (infranet.properties) entries using the classloader.
    
    Parameters:
    
    cf - ConnectionFactory type to be set
    
    Throws:
    
    EBufException
  - ConnectionPool
```
public ConnectionPool(ConnectionFactory cf,
                      java.util.Properties p)
               throws EBufException
```
    Constructor that reads in Connectionpool-specific properties info from a properties object
    
    Parameters:
    
    cf - ConnectionFactory type to be used
    
    p - Properties object
    
    Throws:
    
    EBufException
  - ConnectionPool
```
public ConnectionPool(ConnectionFactory cf,
                      FList connFL)
               throws EBufException
```
    Constructor that takes an FList containing login params.
    
    Parameters:
    
    cf - ConnectionFactory type to be used
    
    connFL - connection FList
    
    Throws:
    
    EBufException
  - ConnectionPool
```
public ConnectionPool(java.lang.String host,
                      java.lang.String port,
                      java.lang.String user,
                      java.lang.String password,
                      java.lang.String service)
               throws EBufException
```
    Constructor that takes a set of connection related properties. The properties reflect the elements needed to construct a pcp-like login uri.
    
    Parameters:
    
    host -
    
    port -
    
    user -
    
    password -
    
    service -
    
    Throws:
    
    EBufException
  - ConnectionPool
```
public ConnectionPool(ConnectionFactory cf,
                      java.util.Properties p,
                      int timeOut)
               throws EBufException
```
    Constructor that reads in Connectionpool-specific properties info from a properties object. It takes a timeOut value in milliseconds for the opcode The timeout is set in the connection and it would be used for calling the opcode. The opcode may throw ERR_TIMEOUT error if the timeOut is exceeded for an opcode operation
    
    Parameters:
    
    cf -
    
    p -
    
    timeOut - value in milliseconds
    
    Throws:
    
    EBufException
- Method Detail
  - setMaxPoolSize
```
public void setMaxPoolSize(int maxPoolSize)
```
    Specified by:
    
    setMaxPoolSize in interface ConnectionPoolMBean
  - getMaxPoolSize
```
public int getMaxPoolSize()
```
    Specified by:
    
    getMaxPoolSize in interface ConnectionPoolMBean
  - setMinPoolSize
```
public void setMinPoolSize(int minPoolSize)
```
    Specified by:
    
    setMinPoolSize in interface ConnectionPoolMBean
  - getMinPoolSize
```
public int getMinPoolSize()
```
    Specified by:
    
    getMinPoolSize in interface ConnectionPoolMBean
  - getFreeConnections
```
public int getFreeConnections()
```
    Specified by:
    
    getFreeConnections in interface ConnectionPoolMBean
  - getUsedConnections
```
public int getUsedConnections()
```
    Specified by:
    
    getUsedConnections in interface ConnectionPoolMBean
  - getTotalConnections
```
public int getTotalConnections()
```
    Specified by:
    
    getTotalConnections in interface ConnectionPoolMBean
  - getConnPoolTimeout
```
public long getConnPoolTimeout()
```
    Specified by:
    
    getConnPoolTimeout in interface ConnectionPoolMBean
  - setConnPoolTimeout
```
public void setConnPoolTimeout(long poolTimeout)
```
    Specified by:
    
    setConnPoolTimeout in interface ConnectionPoolMBean
  - getIdleTime
```
public long getIdleTime()
```
    Specified by:
    
    getIdleTime in interface ConnectionPoolMBean
  - setIdleTime
```
public void setIdleTime(long newIdleTime)
```
    Specified by:
    
    setIdleTime in interface ConnectionPoolMBean
  - getRequestQSize
```
public int getRequestQSize()
```
    Specified by:
    
    getRequestQSize in interface ConnectionPoolMBean
  - setRequestQSize
```
public void setRequestQSize(int reqSize)
```
    Specified by:
    
    setRequestQSize in interface ConnectionPoolMBean
  - getPendingRequests
```
public int getPendingRequests()
```
    Specified by:
    
    getPendingRequests in interface ConnectionPoolMBean
  - getTestFrequency
```
public long getTestFrequency()
```
    Specified by:
    
    getTestFrequency in interface ConnectionPoolMBean
  - getReconnectFrequency
```
public long getReconnectFrequency()
```
    Specified by:
    
    getReconnectFrequency in interface ConnectionPoolMBean
  - getFailedConnRequest
```
public long getFailedConnRequest()
```
    Specified by:
    
    getFailedConnRequest in interface ConnectionPoolMBean
  - getHighFailedConnRequest
```
public long getHighFailedConnRequest()
```
    Specified by:
    
    getHighFailedConnRequest in interface ConnectionPoolMBean
  - getHighUsedConnections
```
public int getHighUsedConnections()
```
    Specified by:
    
    getHighUsedConnections in interface ConnectionPoolMBean
  - setTestFrequency
```
public void setTestFrequency(long testFreq)
```
    Specified by:
    
    setTestFrequency in interface ConnectionPoolMBean
  - setReconnectFrequency
```
public void setReconnectFrequency(long reconnFreq)
```
    Specified by:
    
    setReconnectFrequency in interface ConnectionPoolMBean
  - getHighFreeCons
```
public int getHighFreeCons()
```
    Specified by:
    
    getHighFreeCons in interface ConnectionPoolMBean
  - getHighTotalCons
```
public int getHighTotalCons()
```
    Specified by:
    
    getHighTotalCons in interface ConnectionPoolMBean
  - getHighPendingRequests
```
public int getHighPendingRequests()
```
    Specified by:
    
    getHighPendingRequests in interface ConnectionPoolMBean
  - ReConnectAll
```
public void ReConnectAll()
```
    Specified by:
    
    ReConnectAll in interface ConnectionPoolMBean
  - init
```
protected void init(java.lang.String connectionURL)
             throws EBufException
```
    Reads in all the property settings in the property file. Creates the FList encapsulating the login information Also creates min. number of connections with the login
    
    Parameters:
    
    connectionURL - pcp-type URL (pcp://...)
    
    Throws:
    
    EBufException
  - getConnection
```
public PortalContext getConnection()
                            throws DeterminateException
```
    Returns an instance of connection. Depending on the context factory either a PortalContext or a subclass(viz. PCachedContext) is returned If no connection is available, the requesting thread "wait"s until a connection is released from another thread or, the connection times out. If the caller times out before obtaining a connection a DeterminateException will be thrown - check the messageID of that exception for a value of 1 if you wish to distinguish between this reason for failure and other potential errors.
    
    Returns:
    
    PortalContext
    
    Throws:
    
    DeterminateException
  - testFreeConnections
```
public void testFreeConnections()
```
  - releaseConnection
```
public void releaseConnection(PortalContext connection)
```
    This method does the following: - Checks to see if there are any threads waiting, if not the connection is returned to the free pool and closeIdleConnections is called. - If threads are waiting then verifyBadConnection(connection) method will be called to verify the connection. - Gets the first threads Timed Connection off the wait request queue. - Gives the TimedConnection to the request but only if the thread is still waiting. - If it is not still waiting then the request is removed from the queue and a NAP_CONNECTION_FAILED exception is thrown.
    
    Parameters:
    
    connection - PortalContext Object
  - addToFreeConnection
```
public void addToFreeConnection(PortalContext connection,
                                long lastUsedTime,
                                java.lang.String descr)
```
  - releaseBadConnection
```
public void releaseBadConnection(PortalContext pc)
```
    Close the bad connections TCP/IP socket, and decreasing the connection pool size.
    
    Parameters:
    
    pc - PortalContext object
  - closeConnection
```
public void closeConnection(PortalContext connection,
                            boolean bDecCntFlag)
```
  - getMaxRequestListSize
```
public int getMaxRequestListSize()
```
  - setMaxRequestListSize
```
public void setMaxRequestListSize(int reqQSize)
```
  - getInstance
```
public static ConnectionPool getInstance()
                                  throws EBufException
```
    A helper -static call to create an instance of the pool a la singleton This creates a static instance of Connection Pool and returns it to the calling application. If one is already created, return that one
    
    Returns:
    
    ConnectionPool instance
    
    Throws:
    
    EBufException
  - createInstance
```
public static void createInstance(ConnectionFactory cf)
                           throws EBufException
```
    A helper singleton that wraps the single-argument constructor
    
    Parameters:
    
    cf - ConnectionFactory type
    
    Throws:
    
    EBufException
  - createInstance
```
public static void createInstance(ConnectionFactory cf,
                                  FList fl)
                           throws EBufException
```
    A helper singleton that wraps the 2-argument constructor
    
    Parameters:
    
    cf - ConnectionFactory type
    
    fl - FList containing login info
    
    Throws:
    
    EBufException
  - createInstance
```
public static void createInstance(ConnectionFactory cf,
                                  java.util.Properties p)
                           throws EBufException
```
    A helper singleton that wraps the (connection factory, properties) constructor
    
    Parameters:
    
    cf - ConnectionFactory type
    
    p - Properties containing the login info and connection pool settings
    
    Throws:
    
    EBufException
  - getConnectionFactory
```
public ConnectionFactory getConnectionFactory()
```
    returns the current connection factory. This is a convenience method for the applications to know about the current connexion factory
    
    Returns:
    
    ConnectionFactory
  - createConnections
```
protected java.lang.Object[] createConnections(int size)
                                        throws EBufException,
                                               java.text.ParseException
```
    Creates size number of connections and returns
    
    Parameters:
    
    size - - number of connections to be created
    
    Returns:
    
    array of connections truly created
    
    Throws:
    
    EBufException
    
    java.text.ParseException
  - isIdleConnection
```
protected boolean isIdleConnection(com.portal.pfc.infranet.connpool.ConnectionPool.TimedConnection tc)
```
  - closeIdleConnections
```
protected void closeIdleConnections()
```
    Closes any idle connections in the free-connection list. This has the effect of "shrinking" the pool. Here only the "over-the-min-limit" connections are checked for idle-time. If any they are removed. The connections that are not "idle" are recycled back to the free-pool. The connections to be checked are removed from the front of the Q and added at the end of the Q.
  - reEstablishAllConnections
```
protected void reEstablishAllConnections()
```
  - resetHighestStats
```
public void resetHighestStats()
```
    Reset pool health highest stats.
  - resetFailCount
```
public void resetFailCount()
```
  - getCurrentConnectionCount
```
public int getCurrentConnectionCount()
```
    Returns:
    
    number of open connections currently managed by the pool.
  - getCurrentUsedConnections
```
public int getCurrentUsedConnections()
```
  - getNumberOfPendingRequests
```
public int getNumberOfPendingRequests()
```
    Returns:
    
    number of threads waiting for a connection
  - getNumberOfFreeConnections
```
public int getNumberOfFreeConnections()
```
    Returns:
    
    number of free connections in the pool
  - getConnectionIdleTime
```
public long getConnectionIdleTime()
```
  - setConnectionIdleTime
```
public void setConnectionIdleTime(long newIdleTime)
```
  - getTestConnectionFrequency
```
public long getTestConnectionFrequency()
```
  - getReConnFrequency
```
public long getReConnFrequency()
```
  - getNumFailedRequest
```
public long getNumFailedRequest()
```
  - getNumHighFailedRequest
```
public long getNumHighFailedRequest()
```
  - setTestConnectionFrequency
```
public void setTestConnectionFrequency(long testFreq)
```
  - setReConnFrequency
```
public void setReConnFrequency(long reconFreq)
```
  - getConnectionTimeOut
```
public long getConnectionTimeOut()
```
  - setConnectionTimeOut
```
public void setConnectionTimeOut(long poolTimeout)
```
  - getMaxConnections
```
public int getMaxConnections()
```
  - getMinConnections
```
public int getMinConnections()
```
  - setMaxConnections
```
public void setMaxConnections(int maxConns)
```
  - setMinConnections
```
public void setMinConnections(int minConns)
```
  - getHighestCurConnCount
```
public int getHighestCurConnCount()
```
    Returns:
    
    highest number of open connections that were managed by the pool.
  - getHighestFree
```
public int getHighestFree()
```
    Returns:
    
    highest number of free connections that were in the pool
  - getNumHighUsedConnections
```
public int getNumHighUsedConnections()
```
  - getHighestRequestListSize
```
public int getHighestRequestListSize()
```
    Returns:
    
    the highest number of threads blocked waiting for a connection
  - getLowestHeadroom
```
public int getLowestHeadroom()
```
    How close to queueing did we get? High headroom means that load not high enough to warrant qeueing Zero Headroom means that queuing started
    
    Returns:
    
    mLowestHeadroom

Class ConnectionPool

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ConnectionPool

ConnectionPool

ConnectionPool

ConnectionPool

ConnectionPool

Method Detail

setMaxPoolSize

getMaxPoolSize

setMinPoolSize

getMinPoolSize

getFreeConnections

getUsedConnections

getTotalConnections

getConnPoolTimeout

setConnPoolTimeout

getIdleTime

setIdleTime

getRequestQSize

setRequestQSize

getPendingRequests

getTestFrequency

getReconnectFrequency

getFailedConnRequest

getHighFailedConnRequest

getHighUsedConnections

setTestFrequency

setReconnectFrequency

getHighFreeCons

getHighTotalCons

getHighPendingRequests

ReConnectAll

init

getConnection

testFreeConnections

releaseConnection

addToFreeConnection

releaseBadConnection

closeConnection

getMaxRequestListSize

setMaxRequestListSize

getInstance

createInstance

createInstance

createInstance

getConnectionFactory

createConnections

isIdleConnection

closeIdleConnections

reEstablishAllConnections

resetHighestStats

resetFailCount

getCurrentConnectionCount

getCurrentUsedConnections

getNumberOfPendingRequests

getNumberOfFreeConnections

getConnectionIdleTime

setConnectionIdleTime

getTestConnectionFrequency

getReConnFrequency

getNumFailedRequest

getNumHighFailedRequest

setTestConnectionFrequency

setReConnFrequency

getConnectionTimeOut

setConnectionTimeOut

getMaxConnections

getMinConnections

setMaxConnections

setMinConnections

getHighestCurConnCount

getHighestFree

getNumHighUsedConnections

getHighestRequestListSize

getLowestHeadroom