X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=test%2Fenterprise%2Fsrc%2Fmain%2Fjava%2Forg%2Fwamblee%2Fsupport%2Fpersistence%2FAbstractDatabase.java;h=12c82c41177b7fe9f66d239d1d642d4218c0a1b9;hb=ec9582b50e9c74b08b14c79d7d16de5d0fc2851e;hp=59f3d7762ce4967aed99422160d42bf682a9dda9;hpb=2207a1e695ce23e79678c232cff2ceb84ebaa801;p=utils diff --git a/test/enterprise/src/main/java/org/wamblee/support/persistence/AbstractDatabase.java b/test/enterprise/src/main/java/org/wamblee/support/persistence/AbstractDatabase.java index 59f3d776..12c82c41 100644 --- a/test/enterprise/src/main/java/org/wamblee/support/persistence/AbstractDatabase.java +++ b/test/enterprise/src/main/java/org/wamblee/support/persistence/AbstractDatabase.java @@ -1,78 +1,164 @@ +/* + * Copyright 2005-2010 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package org.wamblee.support.persistence; +import java.util.logging.Level; +import java.util.logging.Logger; + import javax.sql.DataSource; +import junit.framework.Assert; + import org.apache.commons.dbcp.ConnectionFactory; import org.apache.commons.dbcp.DriverManagerConnectionFactory; import org.apache.commons.dbcp.PoolableConnectionFactory; import org.apache.commons.dbcp.PoolingDataSource; import org.apache.commons.pool.impl.GenericObjectPool; +/** + * Abstract database class providing the creation of the datasource, + * preventing duplicate starts of the same database, and checking + * for connection leaks when the database is stopped. + * + * @author Erik Brakkee + * + */ public abstract class AbstractDatabase implements Database { - private static final int CONNECTION_POOL_SIZE = 16; - - private DataSource itsDataSource; - - private boolean started; - - protected AbstractDatabase() { - started = false; - } - - protected abstract void doStart(); - - protected abstract void doStop(); - - /** - * This method must be called from the start method. - */ - protected final void createDataSource() { - GenericObjectPool connectionPool = new GenericObjectPool(null); - connectionPool.setMaxActive(CONNECTION_POOL_SIZE); - ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(getJdbcUrl(), getUsername(), getPassword()); - // The following line must be kept in although it does not appear to be used, the constructor regsiters the - // constructed object at the connection pool. - PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,connectionPool,null,null,false,true); - itsDataSource = new PoolingDataSource(connectionPool); - } - - - /// BELOW THIS LINE IS NOT OF INTEREST TO SUBCLASSES. - - public final DataSource start() { - if ( started ) { - throw new RuntimeException("Database already started"); - } - started = true; - doStart(); - return getDatasource(); - } - - public final void stop() { - if ( ! started ) { - return; // nothing to do. - } - started = false; - doStop(); - } - - private final DataSource getDatasource() { - if ( !started) { - throw new RuntimeException("Database is not started!"); - } - return itsDataSource; - } - - protected String getProperty(String aName) { - String value = System.getProperty(aName); - if ( value != null ) { - return value; - } - value = System.getenv(aName); - if ( value != null ) { - return value; - } - throw new RuntimeException("This class expects the '" + aName + "' property to be set"); - } + + /** + * Set this system property to a non-null value to ignore connection leaks + * when {@link #stop()} is called. + */ + private static final String IGNORE_CONNECTION_LEAK_PROPERTY = "org.wamblee.database.ignoreconnectionleaks"; + + private static final Logger LOGGER = Logger + .getLogger(AbstractDatabase.class.getName()); + + private static final int CONNECTION_POOL_SIZE = 16; + + private DataSource itsDataSource; + + private GenericObjectPool connectionPool; + + private boolean started; + + /** + * Constructs the database. + */ + protected AbstractDatabase() { + started = false; + } + + /** + * To be implemented by subclasses to start the database. + */ + protected abstract void doStart(); + + /** + * To be implemented by subclasses to stop the database. + */ + protected abstract void doStop(); + + /** + * This method must be called from the start method. + */ + protected final void createDataSource() { + connectionPool = new GenericObjectPool(null); + connectionPool.setMaxActive(CONNECTION_POOL_SIZE); + ConnectionFactory connectionFactory = new DriverManagerConnectionFactory( + getJdbcUrl(), getUsername(), getPassword()); + // The following line must be kept in although it does not appear to be + // used, the constructor regsiters the + // constructed object at the connection pool. + PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory( + connectionFactory, connectionPool, null, null, false, true); + ingoredVariable(poolableConnectionFactory); + itsDataSource = new PoolingDataSource(connectionPool); + } + + @Override + public int getActiveConnections() { + return connectionPool.getNumActive(); + } + + private static void ingoredVariable(PoolableConnectionFactory aFactory) { + // Empty + } + + // / BELOW THIS LINE IS NOT OF INTEREST TO SUBCLASSES. + + /** + * Starts the database. + */ + public final DataSource start() { + if (started) { + throw new RuntimeException("Database already started"); + } + started = true; + doStart(); + return getDatasource(); + } + + /** + * Stops the database and tests for connection leaks. + * In cast the system property with the name given by {@link #IGNORE_CONNECTION_LEAK_PROPERTY} + * is set then the connection leaks are not checked. + */ + public final void stop() { + if (!started) { + return; // nothing to do. + } + started = false; + try { + if (connectionPool.getNumActive() > 0) { + String msg = "JDBC connection pool still has " + + connectionPool.getNumActive() + + " active connection(s), this is a potential resource leak in the code\n"; + // backdoor to ignore connection leaks. Use this system property only if you + // can safely ignore the connection leaks. + if (System.getProperty(IGNORE_CONNECTION_LEAK_PROPERTY) == null) { + Assert.fail(msg); + } + } + connectionPool.close(); + connectionPool.close(); + } catch (Exception e) { + LOGGER.log(Level.WARNING, "Could not close pool", e); + } + doStop(); + } + + private final DataSource getDatasource() { + if (!started) { + throw new RuntimeException("Database is not started!"); + } + return itsDataSource; + } + + protected String getProperty(String aName) { + String value = System.getProperty(aName); + if (value != null) { + return value; + } + value = System.getenv(aName); + if (value != null) { + return value; + } + throw new RuntimeException("This class expects the '" + aName + + "' property to be set"); + } }