com.avaje.ebeaninternal.server.lib.sql

Class DataSourcePool

java.lang.Object

com.avaje.ebeaninternal.server.lib.sql.DataSourcePool

All Implemented Interfaces:

Wrapper, CommonDataSource, DataSource

public class DataSourcePool
extends Object
implements DataSource

A robust DataSource.

• Manages the number of connections closing connections that have been idle for some time.
• Notifies when the datasource goes down and comes back up.
• Checks for expected downtime which is useful for schedule db backups.
• Provides PreparedStatement caching
• Knows the busy connections
• Traces connections that have been leaked

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	DataSourcePool.Status

Constructor Summary

Constructors

Constructor and Description
DataSourcePool(DataSourceAlert notify, String name, DataSourceConfig params)

Method Summary

Methods

Modifier and Type	Method and Description
void	checkDataSource() Check the dataSource is up.
void	closeBusyConnections(long leakTimeMinutes) Close any busy connections that have not been used for some time.
protected PooledConnection	createConnectionForQueue(int connId) Grow the pool by creating a new connection.
Connection	createUnpooledConnection() Create a Connection that will not be part of the connection pool.
void	deregisterDriver() Deregister the JDBC driver.
void	dumpBusyConnectionInformation() Dumps the busy connection information to the logs.
boolean	getAutoCommit() Return the default autoCommit setting Connections in this pool will use.
String	getBusyConnectionInformation() Returns information describing connections that are currently being used.
Connection	getConnection() Return a pooled connection.
Connection	getConnection(String username, String password) Not implemented and shouldn't be used.
int	getHeartbeatFreqSecs() Return the heartbeat frequency in seconds.
Runnable	getHeartbeatRunnable() Returns the Runnable used to check the dataSource using a heartbeat query.
long	getLeakTimeMinutes() Return the number of minutes after which a busy connection could be considered leaked from the connection pool.
int	getLoginTimeout() Not implemented and shouldn't be used.
PrintWriter	getLogWriter() Returns null.
long	getMaxAgeMillis() Return the maximum age a connection is allowed to be before it is trimmed out of the pool.
int	getMaxInactiveMillis() Return the time after which inactive connections are trimmed.
int	getMaxSize() Return the max size this pool can grow to.
int	getMaxStackTraceSize() Return the max size of stack traces used when trying to find connection pool leaks.
int	getMinSize() Return the min size this pool should maintain.
String	getName() Return the dataSource name.
Logger	getParentLogger()
PooledConnection	getPooledConnection() Get a connection from the pool.
int	getPstmtCacheSize() Return the preparedStatement cache size.
DataSourcePoolStatistics	getStatistics(boolean reset) Return the aggregated load statistics collected on all the connections in the pool.
DataSourcePool.Status	getStatus(boolean reset) Return the current status of the connection pool.
int	getTransactionIsolation() Return the default transaction isolation level connections in this pool should have.
int	getWaitTimeoutMillis() Return the time in millis that threads will wait when the pool has hit the max size.
int	getWarningSize() Return the warning size.
boolean	isCaptureStackTrace() Return true if the connection pool is currently capturing the StackTrace when connections are 'got' from the pool.
boolean	isDataSourceUp() Returns false when the dataSource is down.
boolean	isWrapperFor(Class<?> arg0) Returns false.
protected void	notifyWarning(String msg) Called when the pool hits the warning level.
protected void	reportClosingConnection(PooledConnection pooledConnection) Collect statistics of a connection that is fully closing
void	reset() Close all the connections in the pool.
protected void	returnConnection(PooledConnection pooledConnection) Called by the PooledConnection themselves, returning themselves to the pool when they have been finished with.
protected void	returnConnectionForceClose(PooledConnection pooledConnection) This is a bad connection and must be removed from the pool's busy list and fully closed.
void	setCaptureStackTrace(boolean captureStackTrace) Set this to true means that the StackElements are captured every time a connection is retrieved from the pool.
void	setLeakTimeMinutes(long leakTimeMinutes) For detecting and closing leaked connections.
void	setLoginTimeout(int seconds) Not implemented and shouldn't be used.
void	setLogWriter(PrintWriter writer) Not implemented.
void	setMaxSize(int max) Set a new maximum size.
void	setMinSize(int min) Set the min size this pool should maintain.
void	setPstmtCacheSize(int pstmtCacheSize) Set the preparedStatement cache size.
void	setWarningSize(int warningSize) Set a new maximum size.
void	shutdown(boolean deregisterDriver) This will close all the free connections, and then go into a wait loop, waiting for the busy connections to be freed.
void	testAlert() Send a message to the DataSourceAlertListener to test it.
<T> T	unwrap(Class<T> arg0) Not Implemented.
protected boolean	validateConnection(PooledConnection conn) Make sure the connection is still ok to use.

Methods inherited from class java.lang.Object

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

Constructor Detail

DataSourcePool

public DataSourcePool(DataSourceAlert notify,
              String name,
              DataSourceConfig params)

Method Detail

getParentLogger

public Logger getParentLogger()
                       throws SQLFeatureNotSupportedException

Specified by:

getParentLogger in interface CommonDataSource

Throws:

SQLFeatureNotSupportedException

isWrapperFor

public boolean isWrapperFor(Class<?> arg0)
                     throws SQLException

Returns false.

Specified by:

isWrapperFor in interface Wrapper

Throws:

SQLException

unwrap

public <T> T unwrap(Class<T> arg0)
         throws SQLException

Not Implemented.

Specified by:

unwrap in interface Wrapper

Throws:

SQLException

getName

public String getName()

Return the dataSource name.

getMaxStackTraceSize

public int getMaxStackTraceSize()

Return the max size of stack traces used when trying to find connection pool leaks.

This is only used when isCaptureStackTrace() is true.

isDataSourceUp

public boolean isDataSourceUp()

Returns false when the dataSource is down.

notifyWarning

protected void notifyWarning(String msg)

Called when the pool hits the warning level.

getHeartbeatFreqSecs

public int getHeartbeatFreqSecs()

Return the heartbeat frequency in seconds.

This is the frequency that the heartbeat runnable should be run.

getHeartbeatRunnable

public Runnable getHeartbeatRunnable()

Returns the Runnable used to check the dataSource using a heartbeat query.

checkDataSource

public void checkDataSource()

Check the dataSource is up. Trim connections.

This is called by the HeartbeatRunnable which should be scheduled to run periodically (every heartbeatFreqSecs seconds actually).

createUnpooledConnection

public Connection createUnpooledConnection()
                                    throws SQLException

Create a Connection that will not be part of the connection pool.

When this connection is closed it will not go back into the pool.

If withDefaults is true then the Connection will have the autoCommit and transaction isolation set to the defaults for the pool.

Throws:

SQLException

setMaxSize

public void setMaxSize(int max)

Set a new maximum size. The pool should respect this new maximum immediately and not require a restart. You may want to increase the maxConnections if the pool gets large and hits the warning level.

getMaxSize

public int getMaxSize()

Return the max size this pool can grow to.

setMinSize

public void setMinSize(int min)

Set the min size this pool should maintain.

getMinSize

public int getMinSize()

Return the min size this pool should maintain.

setWarningSize

public void setWarningSize(int warningSize)

Set a new maximum size. The pool should respect this new maximum immediately and not require a restart. You may want to increase the maxConnections if the pool gets large and hits the warning and or alert levels.

getWarningSize

public int getWarningSize()

Return the warning size. When the pool hits this size it can send a notify message to an administrator.

getWaitTimeoutMillis

public int getWaitTimeoutMillis()

Return the time in millis that threads will wait when the pool has hit the max size. These threads wait for connections to be returned by the busy connections.

getMaxInactiveMillis

public int getMaxInactiveMillis()

Return the time after which inactive connections are trimmed.

getMaxAgeMillis

public long getMaxAgeMillis()

Return the maximum age a connection is allowed to be before it is trimmed out of the pool. This value can be 0 which means there is no maximum age.

validateConnection

protected boolean validateConnection(PooledConnection conn)

Make sure the connection is still ok to use. If not then remove it from the pool.

returnConnection

protected void returnConnection(PooledConnection pooledConnection)

Called by the PooledConnection themselves, returning themselves to the pool when they have been finished with.

Note that connections may not be added back to the pool if returnToPool is false or if they where created before the recycleTime. In both of these cases the connection is fully closed and not pooled.

Parameters:

pooledConnection - the returning connection

returnConnectionForceClose

protected void returnConnectionForceClose(PooledConnection pooledConnection)

This is a bad connection and must be removed from the pool's busy list and fully closed.

reportClosingConnection

protected void reportClosingConnection(PooledConnection pooledConnection)

Collect statistics of a connection that is fully closing

getBusyConnectionInformation

public String getBusyConnectionInformation()

Returns information describing connections that are currently being used.

dumpBusyConnectionInformation

public void dumpBusyConnectionInformation()

Dumps the busy connection information to the logs.

This includes the stackTrace elements if they are being captured. This is useful when needing to look a potential connection pool leaks.

closeBusyConnections

public void closeBusyConnections(long leakTimeMinutes)

Close any busy connections that have not been used for some time.

These connections are considered to have leaked from the connection pool.

Connection leaks occur when code doesn't ensure that connections are closed() after they have been finished with. There should be an appropriate try catch finally block to ensure connections are always closed and put back into the pool.

createConnectionForQueue

protected PooledConnection createConnectionForQueue(int connId)
                                             throws SQLException

Grow the pool by creating a new connection. The connection can either be added to the available list, or returned.

This method is protected by synchronization in calling methods.

Throws:

SQLException

reset

public void reset()

Close all the connections in the pool.

• Checks that the database is up.
• Resets the Alert level.
• Closes busy connections that have not been used for some time (aka leaks).
• This closes all the currently available connections.
• Busy connections are closed when they are returned to the pool.

getConnection

public Connection getConnection()
                         throws SQLException

Return a pooled connection.

Specified by:

getConnection in interface DataSource

Throws:

SQLException

getPooledConnection

public PooledConnection getPooledConnection()
                                     throws SQLException

Get a connection from the pool.

This will grow the pool if all the current connections are busy. This will go into a wait if the pool has hit its maximum size.

Throws:

SQLException

testAlert

public void testAlert()

Send a message to the DataSourceAlertListener to test it. This is so that you can make sure the alerter is configured correctly etc.

shutdown

public void shutdown(boolean deregisterDriver)

This will close all the free connections, and then go into a wait loop, waiting for the busy connections to be freed.

The DataSources's should be shutdown AFTER thread pools. Leaked Connections are not waited on, as that would hang the server.

getAutoCommit

public boolean getAutoCommit()

Return the default autoCommit setting Connections in this pool will use.

Returns:

true if the pool defaults autoCommit to true

getTransactionIsolation

public int getTransactionIsolation()

Return the default transaction isolation level connections in this pool should have.

Returns:

the default transaction isolation level

isCaptureStackTrace

public boolean isCaptureStackTrace()

Return true if the connection pool is currently capturing the StackTrace when connections are 'got' from the pool.

This is set to true to help diagnose connection pool leaks.

setCaptureStackTrace

public void setCaptureStackTrace(boolean captureStackTrace)

Set this to true means that the StackElements are captured every time a connection is retrieved from the pool. This can be used to identify connection pool leaks.

getConnection

public Connection getConnection(String username,
                       String password)
                         throws SQLException

Not implemented and shouldn't be used.

Specified by:

getConnection in interface DataSource

Throws:

SQLException

getLoginTimeout

public int getLoginTimeout()
                    throws SQLException

Not implemented and shouldn't be used.

Specified by:

getLoginTimeout in interface CommonDataSource

Throws:

SQLException

setLoginTimeout

public void setLoginTimeout(int seconds)
                     throws SQLException

Not implemented and shouldn't be used.

Specified by:

setLoginTimeout in interface CommonDataSource

Throws:

SQLException

getLogWriter

public PrintWriter getLogWriter()

Returns null.

Specified by:

getLogWriter in interface CommonDataSource

setLogWriter

public void setLogWriter(PrintWriter writer)
                  throws SQLException

Not implemented.

Specified by:

setLogWriter in interface CommonDataSource

Throws:

SQLException

setLeakTimeMinutes

public void setLeakTimeMinutes(long leakTimeMinutes)

For detecting and closing leaked connections. Connections that have been busy for more than leakTimeMinutes are considered leaks and will be closed on a reset().

If you want to use a connection for that longer then you should consider creating an unpooled connection or setting longRunning to true on that connection.

getLeakTimeMinutes

public long getLeakTimeMinutes()

Return the number of minutes after which a busy connection could be considered leaked from the connection pool.

getPstmtCacheSize

public int getPstmtCacheSize()

Return the preparedStatement cache size.

setPstmtCacheSize

public void setPstmtCacheSize(int pstmtCacheSize)

Set the preparedStatement cache size.

getStatus

public DataSourcePool.Status getStatus(boolean reset)

Return the current status of the connection pool.

If you pass reset = true then the counters such as hitCount, waitCount and highWaterMark are reset.

getStatistics

public DataSourcePoolStatistics getStatistics(boolean reset)

Return the aggregated load statistics collected on all the connections in the pool.

deregisterDriver

public void deregisterDriver()

Deregister the JDBC driver.