/** Creates a Pooled connection and adds it to the connection pool. */
private void installConnection() throws EmanagerDatabaseException {
logger.debug("enter");
PooledConnection connection;
try {
connection = poolDataSource.getPooledConnection();
connection.addConnectionEventListener(this);
connection.getConnection().setAutoCommit(false);
synchronized (connectionPool) {
connectionPool.add(connection);
logger.debug("Database connection added.");
}
} catch (SQLException ex) {
logger.fatal("exception caught while obtaining database " + "connection: ex = " + ex);
SQLException ex1 = ex.getNextException();
while (ex1 != null) {
logger.fatal("chained sql exception ex1 = " + ex1);
SQLException nextEx = ex1.getNextException();
ex1 = nextEx;
}
String logString;
EmanagerDatabaseException ede;
logString =
EmanagerDatabaseStatusCode.DatabaseConnectionFailure.getStatusCodeDescription()
+ ex.getMessage();
logger.fatal(logString);
ede =
new EmanagerDatabaseException(
EmanagerDatabaseStatusCode.DatabaseConnectionFailure, logString);
throw ede;
}
}
/**
* @param arg0
* @roseuid 3F4E5F400123
*/
public void connectionClosed(ConnectionEvent event) {
logger.debug("Enter: " + event.getSource());
synchronized (connectionPool) {
if (!SHUTTING_DOWN) {
if (connectionPool.size() < connectionPoolSize) {
logger.debug("Reading Connection: " + event.getSource());
connectionPool.add(event.getSource());
}
}
}
}
/**
* @param arg0
* @roseuid 3F4E5F40012D
*/
public void connectionErrorOccurred(ConnectionEvent event) {
logger.debug("Connection Error " + event.getSQLException().getMessage());
synchronized (connectionPool) {
if (connectionPool.size() <= connectionPoolSize) {
connectionPool.remove(event.getSource());
if (!SHUTTING_DOWN) {
try {
installConnection();
} catch (EmanagerDatabaseException e) {
// noop. can't throw an exception here, so we'll ignore.
// It will surface later.
}
}
}
}
}
private void initializeDatabaseContext() throws EmanagerDatabaseException {
logger.debug("Enter");
Properties properties;
SybConnectionPoolDataSource poolDataSource;
properties = new Properties();
poolDataSource = new com.sybase.jdbc2.jdbc.SybConnectionPoolDataSource();
poolDataSource.setUser(userAccount);
poolDataSource.setPassword(password);
poolDataSource.setDatabaseName(databaseName);
poolDataSource.setServerName(databaseHost);
poolDataSource.setPortNumber(connectionPort);
poolDataSource.setDescription(connectionPoolDescription);
properties.put("user", userAccount);
properties.put("password", password);
properties.put("APPLICATIONNAME", clientAppName);
// fix
// hopefully these have defaults
// properties.put("USE_METADATA", userMetaData);
// properties.put("REPEAT_READ", useRepeatRead);
// properties.put("CHARSET_CONVERTER_CLASS", charsetConverter);
properties.put("server", "jdbc:sybase:Tds:" + databaseHost + ":" + connectionPort);
try {
poolDataSource.setConnectionProperties(properties);
// jndiContext.bind("jdbc/protoDB", poolDataSource);
jndiContext.bind(JNDIContextName, poolDataSource);
} catch (Exception ex) {
String logString;
EmanagerDatabaseException ede;
logString =
EmanagerDatabaseStatusCode.UnableToBindJNDIContext.getStatusCodeDescription()
+ ex.getMessage();
logger.fatal(logString);
ede =
new EmanagerDatabaseException(
EmanagerDatabaseStatusCode.UnableToBindJNDIContext, logString);
throw ede;
}
}
/** @roseuid 3F3A89D40175 */
public void shutdown() {
logger.debug("Enter");
Iterator iter;
PooledConnection pooledConnection;
SHUTTING_DOWN = true;
iter = connectionPool.iterator();
while (iter.hasNext()) {
pooledConnection = (PooledConnection) iter.next();
try {
if (!pooledConnection.getConnection().isClosed()) {
pooledConnection.getConnection().close();
}
} catch (Exception ex) {
// We don't care what happens here, we're on the way out!
}
}
connectionPool.clear();
}
/**
* The constructor obtains a ConnectionPoolDataSource reference via JNDI. This datasource is used
* when new database connections need to be established and maintained in some container (pool).
*/
public void initializeConnectionPoolConnections() throws EmanagerDatabaseException {
logger.debug("enter");
try {
poolDataSource = (ConnectionPoolDataSource) jndiContext.lookup(JNDIContextName);
} catch (Exception ex) {
String logString;
EmanagerDatabaseException ede;
logString =
EmanagerDatabaseStatusCode.DatabaseJNDILookupFailure.getStatusCodeDescription()
+ ex.getMessage();
logger.fatal(logString);
ede =
new EmanagerDatabaseException(
EmanagerDatabaseStatusCode.DatabaseJNDILookupFailure, logString);
throw ede;
}
for (int i = 0; i < connectionPoolSize; i++) {
installConnection();
}
}
protected boolean executeOnlyIf(Connection con, String q) throws SQLException {
if (q == null) return true;
Statement stmt = null;
try {
stmt = con.createStatement();
q = q.replace("$PREFIX", getPrefix());
LOG.debug(" Executing query " + q);
ResultSet rs = stmt.executeQuery(q);
rs.next();
boolean res = rs.getBoolean(1);
LOG.debug("Result: " + res);
return res;
} catch (SQLException sqe) {
LOG.error(sqe.getMessage() + " from " + q);
throw sqe;
} finally {
try {
if (stmt != null) {
stmt.close();
}
} catch (Exception g) {
}
}
}
public void run() {
Connection con = null;
Statement stmt = null;
try {
DataSource ds = getDataSource();
con = ds.getConnection();
if (executeOnlyIf(con, onlyIfQuery)) {
stmt = con.createStatement();
if (query != null) {
executeQuery(stmt, query);
} else if (update != null) {
executeUpdate(stmt, update);
} else {
throw new IllegalStateException("Both query and update properties are unset");
}
} else {
LOG.debug("Skipped because of " + onlyIfQuery);
}
} catch (RuntimeException e) {
throw e;
} catch (Throwable t) {
if (ignore.matcher(t.getMessage()).matches()) {
LOG.info("Ignoring " + t.getMessage());
} else {
throw new RuntimeException(t.getMessage(), t);
}
} finally {
try {
if (stmt != null) {
stmt.close();
}
} catch (Exception g) {
}
try {
if (con != null) {
con.close();
}
} catch (Exception g) {
}
}
}
/**
* @return Connection
* @roseuid 3F3A5FFD0338
*/
public Connection getConnection() throws EmanagerDatabaseException {
long connectionId;
Connection connection;
PooledConnection pooledConnection;
connection = null;
pooledConnection = null;
connectionId = InvalidConnectionId;
try {
synchronized (connectionPool) {
if (!connectionPool.isEmpty()) {
try {
boolean connectionClosed;
connectionClosed = false;
pooledConnection = (PooledConnection) connectionPool.remove(0);
connection = pooledConnection.getConnection();
connection.clearWarnings();
connectionId = getConnectionID(connection);
connectionClosed = connection.isClosed();
if (connectionId == InvalidConnectionId || connectionClosed == true) {
logger.debug("Pooled connection closed.");
connection = null;
}
} catch (SQLException sqe) {
logger.debug("Pooled connection closed.");
connection = null;
}
}
}
if (connection == null) {
logger.debug("Getting a new connection.");
pooledConnection = poolDataSource.getPooledConnection();
pooledConnection.addConnectionEventListener(this);
connection = pooledConnection.getConnection();
connection.clearWarnings();
connectionId = getConnectionID(connection);
}
} catch (SQLException sqe) {
String logString;
EmanagerDatabaseException ede;
logString =
EmanagerDatabaseStatusCode.UnableToGetPooledConnection.getStatusCodeDescription()
+ sqe.getMessage();
logger.error(logString);
ede =
new EmanagerDatabaseException(
EmanagerDatabaseStatusCode.UnableToGetPooledConnection, logString);
throw ede;
}
if (connectionId == InvalidConnectionId) {
EmanagerDatabaseException ede;
ede =
new EmanagerDatabaseException(
EmanagerDatabaseStatusCode.UnableToGetPooledConnection,
EmanagerDatabaseStatusCode.UnableToGetPooledConnection.getStatusCodeDescription());
throw ede;
}
logger.debug(
"\n*****************************"
+ "\nPooled Connection Init"
+ "\nCon ID:"
+ connectionId
+ "\nCon Object:"
+ pooledConnection
+ "\nPool Object:"
+ connection
+ "\n*****************************");
return connection;
}