/*
* This library is part of OpenCms -
* the Open Source Content Management System
*
* Copyright (c) Alkacon Software GmbH (http://www.alkacon.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* For further information about Alkacon Software GmbH, please see the
* company website: http://www.alkacon.com
*
* For further information about OpenCms, please see the
* project website: http://www.opencms.org
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package org.opencms.db;
import org.opencms.configuration.CmsParameterConfiguration;
import org.opencms.main.CmsLog;
import org.opencms.util.CmsStringUtil;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.dbcp.ConnectionFactory;
import org.apache.commons.dbcp.DriverManagerConnectionFactory;
import org.apache.commons.dbcp.PoolableConnectionFactory;
import org.apache.commons.dbcp.PoolingDriver;
import org.apache.commons.pool.impl.GenericKeyedObjectPool;
import org.apache.commons.pool.impl.GenericKeyedObjectPoolFactory;
import org.apache.commons.pool.impl.GenericObjectPool;
/**
* Various methods to create DBCP pools.<p>
*
* Only JDBC Driver based pools are supported currently. JNDI DataSource
* based pools might be added probably later.<p>
*
* <b>Please note:</b> This class is subject to change in later versions.
* To obtain information about the connections, please use the
* {@link org.opencms.db.CmsSqlManager}.<p>
*
* @since 6.0.0
*/
public final class CmsDbPool {
/** This prefix is required to make the JDBC DriverManager return pooled DBCP connections. */
public static final String DBCP_JDBC_URL_PREFIX = "jdbc:apache:commons:dbcp:";
/** Key for number of connection attempts. */
public static final String KEY_CONNECT_ATTEMTS = "connects";
/** Key for connection waiting. */
public static final String KEY_CONNECT_WAITS = "wait";
/** Prefix for database keys. */
public static final String KEY_DATABASE = "db.";
/** Key for the database name. */
public static final String KEY_DATABASE_NAME = KEY_DATABASE + "name";
/** Key for the pool id. */
public static final String KEY_DATABASE_POOL = KEY_DATABASE + "pool";
/** Key for statement pooling. */
public static final String KEY_DATABASE_STATEMENTS = KEY_DATABASE + "statements";
/** Key for the entity manager pool size. */
public static final String KEY_ENTITY_MANAGER_POOL_SIZE = "entityMangerPoolSize";
/** Key for jdbc driver. */
public static final String KEY_JDBC_DRIVER = "jdbcDriver";
/** Key for jdbc url. */
public static final String KEY_JDBC_URL = "jdbcUrl";
/** Key for jdbc url params. */
public static final String KEY_JDBC_URL_PARAMS = KEY_JDBC_URL + ".params";
/** Key for maximum active connections. */
public static final String KEY_MAX_ACTIVE = "maxActive";
/** Key for maximum idle connections. */
public static final String KEY_MAX_IDLE = "maxIdle";
/** Key for maximum wait time. */
public static final String KEY_MAX_WAIT = "maxWait";
/** Key for minimum idle time before a connection is subject to an eviction test. */
public static final String KEY_MIN_EVICTABLE_IDLE_TIME = "minEvictableIdleTime";
/** Key for minimum number of connections kept open. */
public static final String KEY_MIN_IDLE = "minIdle";
/** Key for number of tested connections per run. */
public static final String KEY_NUM_TESTS_PER_EVICTION_RUN = "numTestsPerEvictionRun";
/** Key for database password. */
public static final String KEY_PASSWORD = "password";
/** Key for default. */
public static final String KEY_POOL_DEFAULT = "default";
/** Key for pool url. */
public static final String KEY_POOL_URL = "poolUrl";
/** Key for pool user. */
public static final String KEY_POOL_USER = "user";
/** Key for vfs pool. */
public static final String KEY_POOL_VFS = "vfs";
/** Key for pooling flag. */
public static final String KEY_POOLING = "pooling";
/** Key for test on borrow flag. */
public static final String KEY_TEST_ON_BORROW = "testOnBorrow";
/** Key for test query. */
public static final String KEY_TEST_QUERY = "testQuery";
/** Key for test while idle flag. */
public static final String KEY_TEST_WHILE_IDLE = "testWhileIdle";
/** Key for time between two eviction runs. */
public static final String KEY_TIME_BETWEEN_EVICTION_RUNS = "timeBetweenEvictionRuns";
/** Key for user name. */
public static final String KEY_USERNAME = "user";
/** Key for "when pool exhausted" action. */
public static final String KEY_WHEN_EXHAUSTED_ACTION = "whenExhaustedAction";
/** The name of the opencms default pool. */
public static final String OPENCMS_DEFAULT_POOL_NAME = "default";
/** The default OpenCms JDBC pool URL. */
public static final String OPENCMS_DEFAULT_POOL_URL = "opencms:default";
/** The prefix used for opencms JDBC pools. */
public static final String OPENCMS_URL_PREFIX = "opencms:";
/**
* Default constructor.<p>
*
* Nobody is allowed to create an instance of this class!
*/
private CmsDbPool() {
super();
}
/**
* Creates a JDBC DriverManager based DBCP connection pool.<p>
*
* @param config the configuration (opencms.properties)
* @param key the key of the database pool in the configuration
* @return String the URL to access the created DBCP pool
* @throws Exception if the pool could not be initialized
*/
public static PoolingDriver createDriverManagerConnectionPool(CmsParameterConfiguration config, String key)
throws Exception {
// read the values of the pool configuration specified by the given key
String jdbcDriver = config.get(KEY_DATABASE_POOL + '.' + key + '.' + KEY_JDBC_DRIVER);
String jdbcUrl = config.get(KEY_DATABASE_POOL + '.' + key + '.' + KEY_JDBC_URL);
String jdbcUrlParams = config.get(KEY_DATABASE_POOL + '.' + key + '.' + KEY_JDBC_URL_PARAMS);
int maxActive = config.getInteger(KEY_DATABASE_POOL + '.' + key + '.' + KEY_MAX_ACTIVE, 10);
int maxWait = config.getInteger(KEY_DATABASE_POOL + '.' + key + '.' + KEY_MAX_WAIT, 2000);
int maxIdle = config.getInteger(KEY_DATABASE_POOL + '.' + key + '.' + KEY_MAX_IDLE, 5);
int minEvictableIdleTime = config.getInteger(
KEY_DATABASE_POOL + '.' + key + '.' + KEY_MIN_EVICTABLE_IDLE_TIME,
1800000);
int minIdle = config.getInteger(KEY_DATABASE_POOL + '.' + key + '.' + KEY_MIN_IDLE, 0);
int numTestsPerEvictionRun = config.getInteger(KEY_DATABASE_POOL
+ '.'
+ key
+ '.'
+ KEY_NUM_TESTS_PER_EVICTION_RUN, 3);
int timeBetweenEvictionRuns = config.getInteger(KEY_DATABASE_POOL
+ '.'
+ key
+ '.'
+ KEY_TIME_BETWEEN_EVICTION_RUNS, 3600000);
String testQuery = config.get(KEY_DATABASE_POOL + '.' + key + '.' + KEY_TEST_QUERY);
String username = config.get(KEY_DATABASE_POOL + '.' + key + '.' + KEY_USERNAME);
String password = config.get(KEY_DATABASE_POOL + '.' + key + '.' + KEY_PASSWORD);
String poolUrl = config.get(KEY_DATABASE_POOL + '.' + key + '.' + KEY_POOL_URL);
String whenExhaustedActionValue = config.get(
KEY_DATABASE_POOL + '.' + key + '.' + KEY_WHEN_EXHAUSTED_ACTION).trim();
byte whenExhaustedAction = 0;
boolean testOnBorrow = Boolean.valueOf(
config.getString(KEY_DATABASE_POOL + '.' + key + '.' + KEY_TEST_ON_BORROW, "false").trim()).booleanValue();
boolean testWhileIdle = Boolean.valueOf(
config.getString(KEY_DATABASE_POOL + '.' + key + '.' + KEY_TEST_WHILE_IDLE, "false").trim()).booleanValue();
if ("block".equalsIgnoreCase(whenExhaustedActionValue)) {
whenExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_BLOCK;
} else if ("fail".equalsIgnoreCase(whenExhaustedActionValue)) {
whenExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_FAIL;
} else if ("grow".equalsIgnoreCase(whenExhaustedActionValue)) {
whenExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_GROW;
} else {
whenExhaustedAction = GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION;
}
if ("".equals(testQuery)) {
testQuery = null;
}
if (username == null) {
username = "";
}
if (password == null) {
password = "";
}
// read the values of the statement pool configuration specified by the given key
boolean poolingStmts = Boolean.valueOf(
config.getString(KEY_DATABASE_STATEMENTS + '.' + key + '.' + KEY_POOLING, CmsStringUtil.TRUE).trim()).booleanValue();
int maxActiveStmts = config.getInteger(KEY_DATABASE_STATEMENTS + '.' + key + '.' + KEY_MAX_ACTIVE, 25);
int maxWaitStmts = config.getInteger(KEY_DATABASE_STATEMENTS + '.' + key + '.' + KEY_MAX_WAIT, 250);
int maxIdleStmts = config.getInteger(KEY_DATABASE_STATEMENTS + '.' + key + '.' + KEY_MAX_IDLE, 15);
String whenStmtsExhaustedActionValue = config.get(KEY_DATABASE_STATEMENTS
+ '.'
+ key
+ '.'
+ KEY_WHEN_EXHAUSTED_ACTION);
byte whenStmtsExhaustedAction = GenericKeyedObjectPool.WHEN_EXHAUSTED_GROW;
if (whenStmtsExhaustedActionValue != null) {
whenStmtsExhaustedActionValue = whenStmtsExhaustedActionValue.trim();
whenStmtsExhaustedAction = ("block".equalsIgnoreCase(whenStmtsExhaustedActionValue))
? GenericKeyedObjectPool.WHEN_EXHAUSTED_BLOCK
: ("fail".equalsIgnoreCase(whenStmtsExhaustedActionValue))
? GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL
: GenericKeyedObjectPool.WHEN_EXHAUSTED_GROW;
}
int connectionAttempts = config.getInteger(KEY_DATABASE_POOL + '.' + key + '.' + KEY_CONNECT_ATTEMTS, 10);
int connetionsWait = config.getInteger(KEY_DATABASE_POOL + '.' + key + '.' + KEY_CONNECT_WAITS, 5000);
// create an instance of the JDBC driver
Class.forName(jdbcDriver).newInstance();
// initialize a keyed object pool to store connections
GenericObjectPool connectionPool = new GenericObjectPool(null);
/* Abandoned pool configuration:
*
* In case the systems encounters "pool exhaustion" (runs out of connections),
* comment the above line with "new GenericObjectPool(null)" and uncomment the
* 5 lines below. This will generate an "abandoned pool" configuration that logs
* abandoned connections to the System.out. Unfortunatly this code is deprecated,
* so to avoid code warnings it's also disabled here.
* Tested with commons-pool v 1.2.
*/
// AbandonedConfig abandonedConfig = new AbandonedConfig();
// abandonedConfig.setLogAbandoned(true);
// abandonedConfig.setRemoveAbandoned(true);
// abandonedConfig.setRemoveAbandonedTimeout(5);
// GenericObjectPool connectionPool = new AbandonedObjectPool(null, abandonedConfig);
// initialize an object pool to store connections
connectionPool.setMaxActive(maxActive);
connectionPool.setMaxIdle(maxIdle);
connectionPool.setMinIdle(minIdle);
connectionPool.setMaxWait(maxWait);
connectionPool.setWhenExhaustedAction(whenExhaustedAction);
if (testQuery != null) {
connectionPool.setTestOnBorrow(testOnBorrow);
connectionPool.setTestWhileIdle(testWhileIdle);
connectionPool.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRuns);
connectionPool.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
connectionPool.setMinEvictableIdleTimeMillis(minEvictableIdleTime);
}
// initialize a connection factory to make the DriverManager taking connections from the pool
if (jdbcUrlParams != null) {
jdbcUrl += jdbcUrlParams;
}
ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(jdbcUrl, username, password);
// Set up statement pool, if desired
GenericKeyedObjectPoolFactory statementFactory = null;
if (poolingStmts) {
statementFactory = new GenericKeyedObjectPoolFactory(
null,
maxActiveStmts,
whenStmtsExhaustedAction,
maxWaitStmts,
maxIdleStmts);
}
// initialize a factory to obtain pooled connections and prepared statements
new PoolableConnectionFactory(connectionFactory, connectionPool, statementFactory, testQuery, false, true);
// initialize a new pooling driver using the pool
PoolingDriver driver = new PoolingDriver();
driver.registerPool(poolUrl, connectionPool);
Connection con = null;
boolean connect = false;
int connectionTests = 0;
// try to connect once to the database to ensure it can be connected to at all
// if the conection cannot be established, multiple attempts will be done to connect
// just in cast the database was not fast enough to start before OpenCms was started
do {
try {
// try to connect
con = connectionFactory.createConnection();
connect = true;
} catch (Exception e) {
// connection failed, increase attempts, sleept for some seconds and log a message
connectionTests++;
if (CmsLog.INIT.isInfoEnabled()) {
CmsLog.INIT.info(Messages.get().getBundle().key(
Messages.INIT_WAIT_FOR_DB_4,
new Object[] {poolUrl, jdbcUrl, new Integer(connectionTests), new Integer(connetionsWait)}));
}
Thread.sleep(connetionsWait);
} finally {
if (con != null) {
con.close();
}
}
} while (!connect && (connectionTests < connectionAttempts));
if (CmsLog.INIT.isInfoEnabled()) {
CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_JDBC_POOL_2, poolUrl, jdbcUrl));
}
return driver;
}
/**
* Returns the database pool name for a given configuration key.<p>
*
* @param configuration the configuration
* @param key a db pool configuration key
* @return the database pool name
*/
public static String getDbPoolName(CmsParameterConfiguration configuration, String key) {
return configuration.get(KEY_DATABASE_POOL + '.' + key + '.' + KEY_POOL_URL);
}
/**
* Returns a list of available database pool names.<p>
*
* @param configuration the configuration to read the pool names from
*
* @return a list of database pool names
*/
public static List<String> getDbPoolUrls(CmsParameterConfiguration configuration) {
List<String> dbPoolNames = new ArrayList<String>();
List<String> driverPoolNames = configuration.getList(CmsDriverManager.CONFIGURATION_DB + ".pools");
for (String driverPoolName : driverPoolNames) {
dbPoolNames.add(getDbPoolName(configuration, driverPoolName));
}
return dbPoolNames;
}
/**
* Returns the name of the default database connection pool.<p>
*
* @return the name of the default database connection pool
*/
public static String getDefaultDbPoolName() {
return OPENCMS_DEFAULT_POOL_NAME;
}
}