org.eclipse.persistence.sessions.server

Class ConnectionPool

java.lang.Object

org.eclipse.persistence.sessions.server.ConnectionPool

Direct Known Subclasses:

ExternalConnectionPool, ReadConnectionPool

public class ConnectionPool
extends java.lang.Object

Purpose: Used to specify how connection should be pooled in a server session.

See Also:

ServerSession

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	checkConnections
protected java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor>	connectionsAvailable
protected java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor>	connectionsUsed
static long	DEAD_CHECK_TIME
protected long	deadCheckTime
protected java.util.List<java.lang.String>	failoverConnectionPools
static int	INITIAL_CONNECTIONS
protected int	initialNumberOfConnections
protected boolean	isConnected
protected boolean	isDead
protected Login	login
static int	MAX_CONNECTIONS
protected int	maxNumberOfConnections
static int	MIN_CONNECTIONS
protected int	minNumberOfConnections
protected static java.lang.String	MONITOR_HEADER
protected java.lang.String	name
protected ServerSession	owner
protected long	timeOfDeath
static int	WAIT_TIMEOUT
protected int	waitTimeout

Constructor Summary

Constructors

Constructor and Description
ConnectionPool() PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
ConnectionPool(java.lang.String name, Login login, int initialNumberOfConnections, int minNumberOfConnections, int maxNumberOfConnections, ServerSession owner) PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
ConnectionPool(java.lang.String name, Login login, int minNumberOfConnections, int maxNumberOfConnections, ServerSession owner) PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
ConnectionPool(java.lang.String name, Login login, ServerSession owner) PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.

Method Summary

Modifier and Type	Method and Description
org.eclipse.persistence.internal.databaseaccess.Accessor	acquireConnection() INTERNAL: Wait until a connection is available and allocate the connection for the client.
boolean	addFailoverConnectionPool(java.lang.String poolName) PUBLIC: Add the connection pool to used if this pool database goes down.
protected org.eclipse.persistence.internal.databaseaccess.Accessor	buildConnection() INTERNAL: Create a new connection, accessors are used as connections.
org.eclipse.persistence.internal.databaseaccess.Accessor	failover() INTERNAL: The connection pool is dead fail over to the fail-over pool.
java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor>	getConnectionsAvailable() INTERNAL: returns the connections currently available for use in the pool
protected java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor>	getConnectionsUsed() Return a list of the connections that are being used.
java.util.List<java.lang.String>	getFailoverConnectionPools() PUBLIC: Return the list of connection pools to used if this pool database goes down.
int	getInitialNumberOfConnections() PUBLIC: Return the initial number of connections allowed.
Login	getLogin() PUBLIC: Return the login used to create connections.
int	getMaxNumberOfConnections() PUBLIC: Return the maximum number of connections allowed.
int	getMinNumberOfConnections() PUBLIC: Return the minimum number of connections.
java.lang.String	getName() PUBLIC: Return the name of this pool.
protected ServerSession	getOwner() Return the ServerSession that is the owner of this connection pool.
int	getTotalNumberOfConnections() INTERNAL: Return the total number of connections currently in use.
int	getWaitTimeout() PUBLIC: Return the time in milliseconds to wait for a available connection.
boolean	hasConnectionAvailable() INTERNAL: Wait until a connection is avaiable and allocate the connection for the client.
boolean	isConnected() INTERNAL: Return if this pool has been connected to the database.
boolean	isDead() ADVANCED: Return if the connection pool's database is down, and failover should be used.
boolean	isThereConflictBetweenLoginAndType() INTERNAL: Checks for a conflict between pool's type and pool's login
void	releaseConnection(org.eclipse.persistence.internal.databaseaccess.Accessor connection) INTERNAL: Add the connection as single that a new connection is available.
void	resetConnections() INTERNAL: Reset the connections on shutDown and when the pool is started.
void	setCheckConnections() INTERNAL: This method is called to indicate that all available connections should be checked.
protected void	setConnectionsAvailable(java.util.Vector connectionsAvailable) INTERNAL: Set this list of connections available
protected void	setConnectionsUsed(java.util.Vector connectionsUsed) INTERNAL: Set the list of connections being used.
void	setFailoverConnectionPools(java.util.List<java.lang.String> failoverConnectionPools) PUBLIC: Set the list of connection pools to used if this pool database goes down.
void	setInitialNumberOfConnections(int initialNumberOfConnections) PUBLIC: Set the initial number of connections allowed.
void	setIsConnected(boolean isConnected) INTERNAL: Set if this pool has been connected to the database.
void	setIsDead(boolean isDead) ADVANCED: Set if the connection pool's database is down, and failover should be used.
void	setLogin(Login login) PUBLIC: Set the login used to create connections.
void	setMaxNumberOfConnections(int maxNumberOfConnections) PUBLIC: Set the maximum number of connections allowed.
void	setMinNumberOfConnections(int minNumberOfConnections) PUBLIC: Set the minimum number of connections.
void	setName(java.lang.String name) PUBLIC: Set the name of this pool.
protected void	setOwner(ServerSession owner) Set the ServerSession that owns this connection pool
void	setWaitTimeout(int waitTimeout) PUBLIC: Set the time in milliseconds to wait for an available connection.
void	shutDown() INTERNAL: Disconnect all connections.
void	startUp() INTERNAL: Allocate the minimum connections.
java.lang.String	toString() INTERNAL: return a string representation of this connection pool

Methods inherited from class java.lang.Object

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

Field Detail

MONITOR_HEADER

protected static final java.lang.String MONITOR_HEADER

See Also:

Constant Field Values

isConnected

protected boolean isConnected

maxNumberOfConnections

protected int maxNumberOfConnections

minNumberOfConnections

protected int minNumberOfConnections

initialNumberOfConnections

protected int initialNumberOfConnections

waitTimeout

protected int waitTimeout

connectionsAvailable

protected java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor> connectionsAvailable

connectionsUsed

protected java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor> connectionsUsed

login

protected Login login

name

protected java.lang.String name

owner

protected ServerSession owner

checkConnections

protected volatile boolean checkConnections

timeOfDeath

protected volatile long timeOfDeath

deadCheckTime

protected volatile long deadCheckTime

isDead

protected volatile boolean isDead

failoverConnectionPools

protected java.util.List<java.lang.String> failoverConnectionPools

DEAD_CHECK_TIME

public static final long DEAD_CHECK_TIME

See Also:

Constant Field Values

MAX_CONNECTIONS

public static final int MAX_CONNECTIONS

See Also:

Constant Field Values

MIN_CONNECTIONS

public static final int MIN_CONNECTIONS

See Also:

Constant Field Values

INITIAL_CONNECTIONS

public static final int INITIAL_CONNECTIONS

See Also:

Constant Field Values

WAIT_TIMEOUT

public static final int WAIT_TIMEOUT

See Also:

Constant Field Values

Constructor Detail

ConnectionPool

public ConnectionPool()

PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.

ConnectionPool

public ConnectionPool(java.lang.String name,
                      Login login,
                      ServerSession owner)

PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.

ConnectionPool

public ConnectionPool(java.lang.String name,
                      Login login,
                      int minNumberOfConnections,
                      int maxNumberOfConnections,
                      ServerSession owner)

PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.

ConnectionPool

public ConnectionPool(java.lang.String name,
                      Login login,
                      int initialNumberOfConnections,
                      int minNumberOfConnections,
                      int maxNumberOfConnections,
                      ServerSession owner)

PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.

Method Detail

failover

public org.eclipse.persistence.internal.databaseaccess.Accessor failover()

INTERNAL: The connection pool is dead fail over to the fail-over pool.

acquireConnection

public org.eclipse.persistence.internal.databaseaccess.Accessor acquireConnection()
                                                                           throws ConcurrencyException

INTERNAL: Wait until a connection is available and allocate the connection for the client.

Throws:

ConcurrencyException

buildConnection

protected org.eclipse.persistence.internal.databaseaccess.Accessor buildConnection()

INTERNAL: Create a new connection, accessors are used as connections.

getConnectionsAvailable

public java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor> getConnectionsAvailable()

INTERNAL: returns the connections currently available for use in the pool

getConnectionsUsed

protected java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor> getConnectionsUsed()

Return a list of the connections that are being used.

Returns:

java.util.Vector

getLogin

public Login getLogin()

PUBLIC: Return the login used to create connections.

getMaxNumberOfConnections

public int getMaxNumberOfConnections()

PUBLIC: Return the maximum number of connections allowed. If all connections are in use, a new connection will be created until the maximum size is reach. Only the minimum number of connections will be pooled, if the pool is between the min and max size the connection will be disconnected when returned to the pool. Typically it is desirable to have the min and max connections the same to avoid connects and disconnects. When the max is reached clients must wait for a connection to become available.

getMinNumberOfConnections

public int getMinNumberOfConnections()

PUBLIC: Return the minimum number of connections. If all connections are in use, a new connection will be created until the maximum size is reach. Only the minimum number of connections will be pooled, if the pool is between the min and max size the connection will be disconnected when returned to the pool. Typically it is desirable to have the min and max connections the same to avoid connects and disconnects.

getName

public java.lang.String getName()

PUBLIC: Return the name of this pool. Pools are identified by name to allow multiple connection pools.

getOwner

protected ServerSession getOwner()

Return the ServerSession that is the owner of this connection pool.

Returns:

org.eclipse.persistence.sessions.server.ServerSession

getTotalNumberOfConnections

public int getTotalNumberOfConnections()

INTERNAL: Return the total number of connections currently in use.

hasConnectionAvailable

public boolean hasConnectionAvailable()

INTERNAL: Wait until a connection is avaiable and allocate the connection for the client.

isConnected

public boolean isConnected()

INTERNAL: Return if this pool has been connected to the database.

isThereConflictBetweenLoginAndType

public boolean isThereConflictBetweenLoginAndType()

INTERNAL: Checks for a conflict between pool's type and pool's login

releaseConnection

public void releaseConnection(org.eclipse.persistence.internal.databaseaccess.Accessor connection)
                       throws DatabaseException

INTERNAL: Add the connection as single that a new connection is available.

Throws:

DatabaseException

resetConnections

public void resetConnections()

INTERNAL: Reset the connections on shutDown and when the pool is started.

setCheckConnections

public void setCheckConnections()

INTERNAL: This method is called to indicate that all available connections should be checked.

setConnectionsAvailable

protected void setConnectionsAvailable(java.util.Vector connectionsAvailable)

INTERNAL: Set this list of connections available

Parameters:

connectionsAvailable -

setConnectionsUsed

protected void setConnectionsUsed(java.util.Vector connectionsUsed)

INTERNAL: Set the list of connections being used.

Parameters:

connectionsUsed -

setIsConnected

public void setIsConnected(boolean isConnected)

INTERNAL: Set if this pool has been connected to the database.

setLogin

public void setLogin(Login login)

PUBLIC: Set the login used to create connections.

getInitialNumberOfConnections

public int getInitialNumberOfConnections()

PUBLIC: Return the initial number of connections allowed. This is the number of connections connected on startup.

setInitialNumberOfConnections

public void setInitialNumberOfConnections(int initialNumberOfConnections)

PUBLIC: Set the initial number of connections allowed. This is the number of connections connected on startup. The default is 1.

setMaxNumberOfConnections

public void setMaxNumberOfConnections(int maxNumberOfConnections)

PUBLIC: Set the maximum number of connections allowed. If all connections are in use, a new connection will be created until the maximum size is reach. Only the minimum number of connections will be pooled, if the pool is between the min and max size the connection will be disconnected when returned to the pool. Typically it is desirable to have the min and max connections the same to avoid connects and disconnects. When the max is reached clients must wait for a connection to become available. The default is 32.

setMinNumberOfConnections

public void setMinNumberOfConnections(int minNumberOfConnections)

PUBLIC: Set the minimum number of connections. If all connections are in use, a new connection will be created until the maximum size is reach. Only the minimum number of connections will be pooled, if the pool is between the min and max size the connection will be disconnected when returned to the pool. Typically it is desirable to have the min and max connections the same to avoid connects and disconnects. The default is 32.

setName

public void setName(java.lang.String name)

PUBLIC: Set the name of this pool. Pools are identified by name to allow multiple connection pools.

setOwner

protected void setOwner(ServerSession owner)

Set the ServerSession that owns this connection pool

Parameters:

owner -

shutDown

public void shutDown()

INTERNAL: Disconnect all connections.

startUp

public void startUp()

INTERNAL: Allocate the minimum connections.

toString

public java.lang.String toString()

INTERNAL: return a string representation of this connection pool

Overrides:

toString in class java.lang.Object

getWaitTimeout

public int getWaitTimeout()

PUBLIC: Return the time in milliseconds to wait for a available connection. If the wait time is exceeded and exception will occur. The default is 180000 or 3 minutes. A value of 0 means wait forever.

setWaitTimeout

public void setWaitTimeout(int waitTimeout)

PUBLIC: Set the time in milliseconds to wait for an available connection. If the wait time is exceeded an exception will occur. The default is 180000 or 3 minutes. A value of 0 means wait forever.

isDead

public boolean isDead()

ADVANCED: Return if the connection pool's database is down, and failover should be used.

setIsDead

public void setIsDead(boolean isDead)

ADVANCED: Set if the connection pool's database is down, and failover should be used.

getFailoverConnectionPools

public java.util.List<java.lang.String> getFailoverConnectionPools()

PUBLIC: Return the list of connection pools to used if this pool database goes down. The failover pools should be a clustered, replicated or backuped database.

setFailoverConnectionPools

public void setFailoverConnectionPools(java.util.List<java.lang.String> failoverConnectionPools)

PUBLIC: Set the list of connection pools to used if this pool database goes down. The failover pools should be a clustered, replicated or backuped database.

addFailoverConnectionPool

public boolean addFailoverConnectionPool(java.lang.String poolName)

PUBLIC: Add the connection pool to used if this pool database goes down. The failover pools should be a clustered, replicated or backuped database.