package org.apache.jcs.auxiliary.disk.jdbc;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
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.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool;
/**
* This class provides access to the connection pool. It ensures that the various resources that
* need to access the tables will be able to use the same pool.
* <p>
* @author Aaron Smuts
*/
public class JDBCDiskCachePoolAccess
{
/** The logger. */
private final static Log log = LogFactory.getLog( JDBCDiskCachePoolAccess.class );
/** The defualt Pool Name to which the connetion pool will be keyed. */
public static final String DEFAULT_POOL_NAME = "jcs";
/** The name of the pool. */
private String poolName = DEFAULT_POOL_NAME;
/** default jdbc driver. */
private static final String DRIVER_NAME = "jdbc:apache:commons:dbcp:";
// WE SHOULD HAVE A DIFFERENT POOL FOR EACH DB NO REGION
// THE SAME TABLE CAN BE USED BY MULTIPLE REGIONS
// this.setPoolName( jdbcDiskCacheAttributes.getCacheName() );
/**
* Configures the pool name to use for the pool access.
* <p>
* This pool name should be unique to the database. It is used as part of the URL each time we
* lookup a conection from the driver manager.
* <p>
* @param poolName
* @param driverName
*/
public JDBCDiskCachePoolAccess( String poolName )
{
// we can default to jcs if there is only one database in use.
if ( poolName != null )
{
setPoolName( poolName );
}
else
{
if ( log.isInfoEnabled() )
{
log.info( "The pool name supplied was null. Using default instead." );
}
}
}
/**
* Gets a connection from the pool.
* <p>
* @return Connection
* @throws SQLException
*/
public Connection getConnection()
throws SQLException
{
Connection con;
try
{
con = DriverManager.getConnection( getPoolUrl() );
}
catch ( SQLException e )
{
log.error( "Problem getting conenction.", e );
throw e;
}
return con;
}
/**
* How many are idle in the pool.
* <p>
* @return number idle
*/
public int getNumIdleInPool()
{
int numIdle = 0;
try
{
PoolingDriver driver = (PoolingDriver) DriverManager.getDriver( DRIVER_NAME );
ObjectPool connectionPool = driver.getConnectionPool( this.getPoolName() );
if ( log.isDebugEnabled() )
{
log.debug( connectionPool );
}
numIdle = connectionPool.getNumIdle();
}
catch ( Exception e )
{
log.error( e );
}
return numIdle;
}
/**
* How many are active in the pool.
* <p>
* @return number active
*/
public int getNumActiveInPool()
{
int numActive = 0;
try
{
PoolingDriver driver = (PoolingDriver) DriverManager.getDriver( DRIVER_NAME );
ObjectPool connectionPool = driver.getConnectionPool( this.getPoolName() );
if ( log.isDebugEnabled() )
{
log.debug( connectionPool );
}
numActive = connectionPool.getNumActive();
}
catch ( Exception e )
{
log.error( e );
}
return numActive;
}
/**
* @throws Exception
*/
public void shutdownDriver()
throws Exception
{
PoolingDriver driver = (PoolingDriver) DriverManager.getDriver( DRIVER_NAME );
driver.closePool( this.getPoolName() );
}
/**
* @return Returns the poolUrl.
*/
public String getPoolUrl()
{
return DRIVER_NAME + this.getPoolName();
}
/**
* @param poolName The poolName to set.
*/
public void setPoolName( String poolName )
{
this.poolName = poolName;
}
/**
* @return Returns the poolName.
*/
public String getPoolName()
{
return poolName;
}
/**
* @param connectURI
* @param userName
* @param password
* @param maxActive max connetions
* @throws Exception
*/
public void setupDriver( String connectURI, String userName, String password, int maxActive )
throws Exception
{
// First, we'll need a ObjectPool that serves as the
// actual pool of connections.
// We'll use a GenericObjectPool instance, although
// any ObjectPool implementation will suffice.
ObjectPool connectionPool = new GenericObjectPool( null, maxActive );
// TODO make configurable
// By dfault the size is 8!!!!!!!
( (GenericObjectPool) connectionPool ).setMaxIdle( -1 );
// Next, we'll create a ConnectionFactory that the
// pool will use to create Connections.
// We'll use the DriverManagerConnectionFactory,
// using the connect string passed in the command line
// arguments.
// Properties props = new Properties();
// props.setProperty( "user", userName );
// props.setProperty( "password", password );
ConnectionFactory connectionFactory = new DriverManagerConnectionFactory( connectURI, userName, password );
// Now we'll create the PoolableConnectionFactory, which wraps
// the "real" Connections created by the ConnectionFactory with
// the classes that implement the pooling functionality.
// PoolableConnectionFactory poolableConnectionFactory =
new PoolableConnectionFactory( connectionFactory, connectionPool, null, null, false, true );
// Finally, we create the PoolingDriver itself...
Class.forName( "org.apache.commons.dbcp.PoolingDriver" );
PoolingDriver driver = (PoolingDriver) DriverManager.getDriver( DRIVER_NAME );
// ...and register our pool with it.
driver.registerPool( this.getPoolName(), connectionPool );
// Now we can just use the connect string
// "jdbc:apache:commons:dbcp:jcs"
// to access our pool of Connections.
}
/**
* @throws Exception
*/
public void logDriverStats()
throws Exception
{
PoolingDriver driver = (PoolingDriver) DriverManager.getDriver( DRIVER_NAME );
ObjectPool connectionPool = driver.getConnectionPool( this.getPoolName() );
if ( connectionPool != null )
{
if ( log.isDebugEnabled() )
{
log.debug( connectionPool );
}
if ( log.isInfoEnabled() )
{
log.info( "NumActive: " + getNumActiveInPool() );
log.info( "NumIdle: " + getNumIdleInPool() );
}
}
else
{
log.warn( "Could not find pool." );
}
}
}