Java tutorial
/* * 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. */ package com.frameworkset.commons.dbcp2.datasources; import java.io.IOException; import java.io.ObjectInputStream; import java.sql.Connection; import java.sql.SQLException; import java.util.HashMap; import java.util.Map; import java.util.NoSuchElementException; import javax.naming.NamingException; import javax.naming.Reference; import javax.naming.StringRefAddr; import javax.sql.ConnectionPoolDataSource; import com.frameworkset.commons.dbcp2.SwallowedExceptionLogger; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import com.frameworkset.commons.pool2.ObjectPool; import com.frameworkset.commons.pool2.impl.GenericObjectPool; /** * <p>A pooling <code>DataSource</code> appropriate for deployment within * J2EE environment. There are many configuration options, most of which are * defined in the parent class. This datasource uses individual pools per * user, and some properties can be set specifically for a given user, if the * deployment environment can support initialization of mapped properties. * So for example, a pool of admin or write-access Connections can be * guaranteed a certain number of connections, separate from a maximum * set for users with read-only connections.</p> * * <p>User passwords can be changed without re-initializing the datasource. * When a <code>getConnection(username, password)</code> request is processed * with a password that is different from those used to create connections in * the pool associated with <code>username</code>, an attempt is made to create * a new connection using the supplied password and if this succeeds, the * existing pool is cleared and a new pool is created for connections using the * new password.</p> * * @author John D. McNally * @version $Id: PerUserPoolDataSource.java 1649430 2015-01-04 21:29:32Z tn $ * @since 2.0 */ public class PerUserPoolDataSource extends InstanceKeyDataSource { private static final long serialVersionUID = 7872747993848065028L; private static final Log log = LogFactory.getLog(PerUserPoolDataSource.class); // Per user pool properties private Map<String, Boolean> perUserBlockWhenExhausted = null; private Map<String, String> perUserEvictionPolicyClassName = null; private Map<String, Boolean> perUserLifo = null; private Map<String, Integer> perUserMaxIdle = null; private Map<String, Integer> perUserMaxTotal = null; private Map<String, Long> perUserMaxWaitMillis = null; private Map<String, Long> perUserMinEvictableIdleTimeMillis = null; private Map<String, Integer> perUserMinIdle = null; private Map<String, Integer> perUserNumTestsPerEvictionRun = null; private Map<String, Long> perUserSoftMinEvictableIdleTimeMillis = null; private Map<String, Boolean> perUserTestOnCreate = null; private Map<String, Boolean> perUserTestOnBorrow = null; private Map<String, Boolean> perUserTestOnReturn = null; private Map<String, Boolean> perUserTestWhileIdle = null; private Map<String, Long> perUserTimeBetweenEvictionRunsMillis = null; // Per user connection properties private Map<String, Boolean> perUserDefaultAutoCommit = null; private Map<String, Integer> perUserDefaultTransactionIsolation = null; private Map<String, Boolean> perUserDefaultReadOnly = null; /** * Map to keep track of Pools for a given user */ private transient Map<PoolKey, PooledConnectionManager> managers = new HashMap<PoolKey, PooledConnectionManager>(); /** * Default no-arg constructor for Serialization */ public PerUserPoolDataSource() { } /** * Close pool(s) being maintained by this datasource. */ @Override public void close() { for (PooledConnectionManager manager : managers.values()) { try { ((CPDSConnectionFactory) manager).getPool().close(); } catch (Exception closePoolException) { //ignore and try to close others. } } InstanceKeyDataSourceFactory.removeInstance(getInstanceKey()); } // ------------------------------------------------------------------- // Properties /** * Gets the user specific value for * {@link GenericObjectPool#getBlockWhenExhausted()} for the * specified user's pool or the default if no user specific value is defined. */ public boolean getPerUserBlockWhenExhausted(String key) { Boolean value = null; if (perUserBlockWhenExhausted != null) { value = perUserBlockWhenExhausted.get(key); } if (value == null) { return getDefaultBlockWhenExhausted(); } return value.booleanValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getBlockWhenExhausted()} for the specified * user's pool. */ public void setPerUserBlockWhenExhausted(String username, Boolean value) { assertInitializationAllowed(); if (perUserBlockWhenExhausted == null) { perUserBlockWhenExhausted = new HashMap<String, Boolean>(); } perUserBlockWhenExhausted.put(username, value); } void setPerUserBlockWhenExhausted(Map<String, Boolean> userDefaultBlockWhenExhausted) { assertInitializationAllowed(); if (perUserBlockWhenExhausted == null) { perUserBlockWhenExhausted = new HashMap<String, Boolean>(); } else { perUserBlockWhenExhausted.clear(); } perUserBlockWhenExhausted.putAll(userDefaultBlockWhenExhausted); } /** * Gets the user specific value for * {@link GenericObjectPool#getEvictionPolicyClassName()} for the * specified user's pool or the default if no user specific value is defined. */ public String getPerUserEvictionPolicyClassName(String key) { String value = null; if (perUserEvictionPolicyClassName != null) { value = perUserEvictionPolicyClassName.get(key); } if (value == null) { return getDefaultEvictionPolicyClassName(); } return value; } /** * Sets a user specific value for * {@link GenericObjectPool#getEvictionPolicyClassName()} for the specified * user's pool. */ public void setPerUserEvictionPolicyClassName(String username, String value) { assertInitializationAllowed(); if (perUserEvictionPolicyClassName == null) { perUserEvictionPolicyClassName = new HashMap<String, String>(); } perUserEvictionPolicyClassName.put(username, value); } void setPerUserEvictionPolicyClassName(Map<String, String> userDefaultEvictionPolicyClassName) { assertInitializationAllowed(); if (perUserEvictionPolicyClassName == null) { perUserEvictionPolicyClassName = new HashMap<String, String>(); } else { perUserEvictionPolicyClassName.clear(); } perUserEvictionPolicyClassName.putAll(userDefaultEvictionPolicyClassName); } /** * Gets the user specific value for {@link GenericObjectPool#getLifo()} for * the specified user's pool or the default if no user specific value is * defined. */ public boolean getPerUserLifo(String key) { Boolean value = null; if (perUserLifo != null) { value = perUserLifo.get(key); } if (value == null) { return getDefaultLifo(); } return value.booleanValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getLifo()} for the specified * user's pool. */ public void setPerUserLifo(String username, Boolean value) { assertInitializationAllowed(); if (perUserLifo == null) { perUserLifo = new HashMap<String, Boolean>(); } perUserLifo.put(username, value); } void setPerUserLifo(Map<String, Boolean> userDefaultLifo) { assertInitializationAllowed(); if (perUserLifo == null) { perUserLifo = new HashMap<String, Boolean>(); } else { perUserLifo.clear(); } perUserLifo.putAll(userDefaultLifo); } /** * Gets the user specific value for * {@link GenericObjectPool#getMaxIdle()} for the * specified user's pool or the default if no user specific value is defined. */ public int getPerUserMaxIdle(String key) { Integer value = null; if (perUserMaxIdle != null) { value = perUserMaxIdle.get(key); } if (value == null) { return getDefaultMaxIdle(); } return value.intValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getMaxIdle()} for the specified * user's pool. */ public void setPerUserMaxIdle(String username, Integer value) { assertInitializationAllowed(); if (perUserMaxIdle == null) { perUserMaxIdle = new HashMap<String, Integer>(); } perUserMaxIdle.put(username, value); } void setPerUserMaxIdle(Map<String, Integer> userDefaultMaxIdle) { assertInitializationAllowed(); if (perUserMaxIdle == null) { perUserMaxIdle = new HashMap<String, Integer>(); } else { perUserMaxIdle.clear(); } perUserMaxIdle.putAll(userDefaultMaxIdle); } /** * Gets the user specific value for * {@link GenericObjectPool#getMaxTotal()} for the * specified user's pool or the default if no user specific value is defined. */ public int getPerUserMaxTotal(String key) { Integer value = null; if (perUserMaxTotal != null) { value = perUserMaxTotal.get(key); } if (value == null) { return getDefaultMaxTotal(); } return value.intValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getMaxTotal()} for the specified * user's pool. */ public void setPerUserMaxTotal(String username, Integer value) { assertInitializationAllowed(); if (perUserMaxTotal == null) { perUserMaxTotal = new HashMap<String, Integer>(); } perUserMaxTotal.put(username, value); } void setPerUserMaxTotal(Map<String, Integer> userDefaultMaxTotal) { assertInitializationAllowed(); if (perUserMaxTotal == null) { perUserMaxTotal = new HashMap<String, Integer>(); } else { perUserMaxTotal.clear(); } perUserMaxTotal.putAll(userDefaultMaxTotal); } /** * Gets the user specific value for * {@link GenericObjectPool#getMaxWaitMillis()} for the * specified user's pool or the default if no user specific value is defined. */ public long getPerUserMaxWaitMillis(String key) { Long value = null; if (perUserMaxWaitMillis != null) { value = perUserMaxWaitMillis.get(key); } if (value == null) { return getDefaultMaxWaitMillis(); } return value.longValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getMaxWaitMillis()} for the specified * user's pool. */ public void setPerUserMaxWaitMillis(String username, Long value) { assertInitializationAllowed(); if (perUserMaxWaitMillis == null) { perUserMaxWaitMillis = new HashMap<String, Long>(); } perUserMaxWaitMillis.put(username, value); } void setPerUserMaxWaitMillis(Map<String, Long> userDefaultMaxWaitMillis) { assertInitializationAllowed(); if (perUserMaxWaitMillis == null) { perUserMaxWaitMillis = new HashMap<String, Long>(); } else { perUserMaxWaitMillis.clear(); } perUserMaxWaitMillis.putAll(userDefaultMaxWaitMillis); } /** * Gets the user specific value for * {@link GenericObjectPool#getMinEvictableIdleTimeMillis()} for the * specified user's pool or the default if no user specific value is defined. */ public long getPerUserMinEvictableIdleTimeMillis(String key) { Long value = null; if (perUserMinEvictableIdleTimeMillis != null) { value = perUserMinEvictableIdleTimeMillis.get(key); } if (value == null) { return getDefaultMinEvictableIdleTimeMillis(); } return value.longValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getMinEvictableIdleTimeMillis()} for the * specified user's pool. */ public void setPerUserMinEvictableIdleTimeMillis(String username, Long value) { assertInitializationAllowed(); if (perUserMinEvictableIdleTimeMillis == null) { perUserMinEvictableIdleTimeMillis = new HashMap<String, Long>(); } perUserMinEvictableIdleTimeMillis.put(username, value); } void setPerUserMinEvictableIdleTimeMillis(Map<String, Long> userDefaultMinEvictableIdleTimeMillis) { assertInitializationAllowed(); if (perUserMinEvictableIdleTimeMillis == null) { perUserMinEvictableIdleTimeMillis = new HashMap<String, Long>(); } else { perUserMinEvictableIdleTimeMillis.clear(); } perUserMinEvictableIdleTimeMillis.putAll(userDefaultMinEvictableIdleTimeMillis); } /** * Gets the user specific value for * {@link GenericObjectPool#getMinIdle()} for the * specified user's pool or the default if no user specific value is defined. */ public int getPerUserMinIdle(String key) { Integer value = null; if (perUserMinIdle != null) { value = perUserMinIdle.get(key); } if (value == null) { return getDefaultMinIdle(); } return value.intValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getMinIdle()} for the specified * user's pool. */ public void setPerUserMinIdle(String username, Integer value) { assertInitializationAllowed(); if (perUserMinIdle == null) { perUserMinIdle = new HashMap<String, Integer>(); } perUserMinIdle.put(username, value); } void setPerUserMinIdle(Map<String, Integer> userDefaultMinIdle) { assertInitializationAllowed(); if (perUserMinIdle == null) { perUserMinIdle = new HashMap<String, Integer>(); } else { perUserMinIdle.clear(); } perUserMinIdle.putAll(userDefaultMinIdle); } /** * Gets the user specific value for * {@link GenericObjectPool#getNumTestsPerEvictionRun()} for the * specified user's pool or the default if no user specific value is defined. */ public int getPerUserNumTestsPerEvictionRun(String key) { Integer value = null; if (perUserNumTestsPerEvictionRun != null) { value = perUserNumTestsPerEvictionRun.get(key); } if (value == null) { return getDefaultNumTestsPerEvictionRun(); } return value.intValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getNumTestsPerEvictionRun()} for the specified * user's pool. */ public void setPerUserNumTestsPerEvictionRun(String username, Integer value) { assertInitializationAllowed(); if (perUserNumTestsPerEvictionRun == null) { perUserNumTestsPerEvictionRun = new HashMap<String, Integer>(); } perUserNumTestsPerEvictionRun.put(username, value); } void setPerUserNumTestsPerEvictionRun(Map<String, Integer> userDefaultNumTestsPerEvictionRun) { assertInitializationAllowed(); if (perUserNumTestsPerEvictionRun == null) { perUserNumTestsPerEvictionRun = new HashMap<String, Integer>(); } else { perUserNumTestsPerEvictionRun.clear(); } perUserNumTestsPerEvictionRun.putAll(userDefaultNumTestsPerEvictionRun); } /** * Gets the user specific value for * {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for the * specified user's pool or the default if no user specific value is defined. */ public long getPerUserSoftMinEvictableIdleTimeMillis(String key) { Long value = null; if (perUserSoftMinEvictableIdleTimeMillis != null) { value = perUserSoftMinEvictableIdleTimeMillis.get(key); } if (value == null) { return getDefaultSoftMinEvictableIdleTimeMillis(); } return value.longValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for the * specified user's pool. */ public void setPerUserSoftMinEvictableIdleTimeMillis(String username, Long value) { assertInitializationAllowed(); if (perUserSoftMinEvictableIdleTimeMillis == null) { perUserSoftMinEvictableIdleTimeMillis = new HashMap<String, Long>(); } perUserSoftMinEvictableIdleTimeMillis.put(username, value); } void setPerUserSoftMinEvictableIdleTimeMillis(Map<String, Long> userDefaultSoftMinEvictableIdleTimeMillis) { assertInitializationAllowed(); if (perUserSoftMinEvictableIdleTimeMillis == null) { perUserSoftMinEvictableIdleTimeMillis = new HashMap<String, Long>(); } else { perUserSoftMinEvictableIdleTimeMillis.clear(); } perUserSoftMinEvictableIdleTimeMillis.putAll(userDefaultSoftMinEvictableIdleTimeMillis); } /** * Gets the user specific value for * {@link GenericObjectPool#getTestOnCreate()} for the * specified user's pool or the default if no user specific value is defined. */ public boolean getPerUserTestOnCreate(String key) { Boolean value = null; if (perUserTestOnCreate != null) { value = perUserTestOnCreate.get(key); } if (value == null) { return getDefaultTestOnCreate(); } return value.booleanValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getTestOnCreate()} for the specified * user's pool. */ public void setPerUserTestOnCreate(String username, Boolean value) { assertInitializationAllowed(); if (perUserTestOnCreate == null) { perUserTestOnCreate = new HashMap<String, Boolean>(); } perUserTestOnCreate.put(username, value); } void setPerUserTestOnCreate(Map<String, Boolean> userDefaultTestOnCreate) { assertInitializationAllowed(); if (perUserTestOnCreate == null) { perUserTestOnCreate = new HashMap<String, Boolean>(); } else { perUserTestOnCreate.clear(); } perUserTestOnCreate.putAll(userDefaultTestOnCreate); } /** * Gets the user specific value for * {@link GenericObjectPool#getTestOnBorrow()} for the * specified user's pool or the default if no user specific value is defined. */ public boolean getPerUserTestOnBorrow(String key) { Boolean value = null; if (perUserTestOnBorrow != null) { value = perUserTestOnBorrow.get(key); } if (value == null) { return getDefaultTestOnBorrow(); } return value.booleanValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getTestOnBorrow()} for the specified * user's pool. */ public void setPerUserTestOnBorrow(String username, Boolean value) { assertInitializationAllowed(); if (perUserTestOnBorrow == null) { perUserTestOnBorrow = new HashMap<String, Boolean>(); } perUserTestOnBorrow.put(username, value); } void setPerUserTestOnBorrow(Map<String, Boolean> userDefaultTestOnBorrow) { assertInitializationAllowed(); if (perUserTestOnBorrow == null) { perUserTestOnBorrow = new HashMap<String, Boolean>(); } else { perUserTestOnBorrow.clear(); } perUserTestOnBorrow.putAll(userDefaultTestOnBorrow); } /** * Gets the user specific value for * {@link GenericObjectPool#getTestOnReturn()} for the * specified user's pool or the default if no user specific value is defined. */ public boolean getPerUserTestOnReturn(String key) { Boolean value = null; if (perUserTestOnReturn != null) { value = perUserTestOnReturn.get(key); } if (value == null) { return getDefaultTestOnReturn(); } return value.booleanValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getTestOnReturn()} for the specified * user's pool. */ public void setPerUserTestOnReturn(String username, Boolean value) { assertInitializationAllowed(); if (perUserTestOnReturn == null) { perUserTestOnReturn = new HashMap<String, Boolean>(); } perUserTestOnReturn.put(username, value); } void setPerUserTestOnReturn(Map<String, Boolean> userDefaultTestOnReturn) { assertInitializationAllowed(); if (perUserTestOnReturn == null) { perUserTestOnReturn = new HashMap<String, Boolean>(); } else { perUserTestOnReturn.clear(); } perUserTestOnReturn.putAll(userDefaultTestOnReturn); } /** * Gets the user specific value for * {@link GenericObjectPool#getTestWhileIdle()} for the * specified user's pool or the default if no user specific value is defined. */ public boolean getPerUserTestWhileIdle(String key) { Boolean value = null; if (perUserTestWhileIdle != null) { value = perUserTestWhileIdle.get(key); } if (value == null) { return getDefaultTestWhileIdle(); } return value.booleanValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getTestWhileIdle()} for the specified * user's pool. */ public void setPerUserTestWhileIdle(String username, Boolean value) { assertInitializationAllowed(); if (perUserTestWhileIdle == null) { perUserTestWhileIdle = new HashMap<String, Boolean>(); } perUserTestWhileIdle.put(username, value); } void setPerUserTestWhileIdle(Map<String, Boolean> userDefaultTestWhileIdle) { assertInitializationAllowed(); if (perUserTestWhileIdle == null) { perUserTestWhileIdle = new HashMap<String, Boolean>(); } else { perUserTestWhileIdle.clear(); } perUserTestWhileIdle.putAll(userDefaultTestWhileIdle); } /** * Gets the user specific value for * {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis()} for the * specified user's pool or the default if no user specific value is defined. */ public long getPerUserTimeBetweenEvictionRunsMillis(String key) { Long value = null; if (perUserTimeBetweenEvictionRunsMillis != null) { value = perUserTimeBetweenEvictionRunsMillis.get(key); } if (value == null) { return getDefaultTimeBetweenEvictionRunsMillis(); } return value.longValue(); } /** * Sets a user specific value for * {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis ()} for the specified * user's pool. */ public void setPerUserTimeBetweenEvictionRunsMillis(String username, Long value) { assertInitializationAllowed(); if (perUserTimeBetweenEvictionRunsMillis == null) { perUserTimeBetweenEvictionRunsMillis = new HashMap<String, Long>(); } perUserTimeBetweenEvictionRunsMillis.put(username, value); } void setPerUserTimeBetweenEvictionRunsMillis(Map<String, Long> userDefaultTimeBetweenEvictionRunsMillis) { assertInitializationAllowed(); if (perUserTimeBetweenEvictionRunsMillis == null) { perUserTimeBetweenEvictionRunsMillis = new HashMap<String, Long>(); } else { perUserTimeBetweenEvictionRunsMillis.clear(); } perUserTimeBetweenEvictionRunsMillis.putAll(userDefaultTimeBetweenEvictionRunsMillis); } /** * Gets the user specific default value for * {@link Connection#setAutoCommit(boolean)} for the specified user's pool. */ public Boolean getPerUserDefaultAutoCommit(String key) { Boolean value = null; if (perUserDefaultAutoCommit != null) { value = perUserDefaultAutoCommit.get(key); } return value; } /** * Sets a user specific default value for * {@link Connection#setAutoCommit(boolean)} for the specified user's pool. */ public void setPerUserDefaultAutoCommit(String username, Boolean value) { assertInitializationAllowed(); if (perUserDefaultAutoCommit == null) { perUserDefaultAutoCommit = new HashMap<String, Boolean>(); } perUserDefaultAutoCommit.put(username, value); } void setPerUserDefaultAutoCommit(Map<String, Boolean> userDefaultAutoCommit) { assertInitializationAllowed(); if (perUserDefaultAutoCommit == null) { perUserDefaultAutoCommit = new HashMap<String, Boolean>(); } else { perUserDefaultAutoCommit.clear(); } perUserDefaultAutoCommit.putAll(userDefaultAutoCommit); } /** * Gets the user specific default value for * {@link Connection#setReadOnly(boolean)} for the specified user's pool. */ public Boolean getPerUserDefaultReadOnly(String key) { Boolean value = null; if (perUserDefaultReadOnly != null) { value = perUserDefaultReadOnly.get(key); } return value; } /** * Sets a user specific default value for * {@link Connection#setReadOnly(boolean)} for the specified user's pool. */ public void setPerUserDefaultReadOnly(String username, Boolean value) { assertInitializationAllowed(); if (perUserDefaultReadOnly == null) { perUserDefaultReadOnly = new HashMap<String, Boolean>(); } perUserDefaultReadOnly.put(username, value); } void setPerUserDefaultReadOnly(Map<String, Boolean> userDefaultReadOnly) { assertInitializationAllowed(); if (perUserDefaultReadOnly == null) { perUserDefaultReadOnly = new HashMap<String, Boolean>(); } else { perUserDefaultReadOnly.clear(); } perUserDefaultReadOnly.putAll(userDefaultReadOnly); } /** * Gets the user specific default value for * {@link Connection#setTransactionIsolation(int)} for the specified user's pool. */ public Integer getPerUserDefaultTransactionIsolation(String key) { Integer value = null; if (perUserDefaultTransactionIsolation != null) { value = perUserDefaultTransactionIsolation.get(key); } return value; } /** * Sets a user specific default value for * {@link Connection#setTransactionIsolation(int)} for the specified user's pool. */ public void setPerUserDefaultTransactionIsolation(String username, Integer value) { assertInitializationAllowed(); if (perUserDefaultTransactionIsolation == null) { perUserDefaultTransactionIsolation = new HashMap<String, Integer>(); } perUserDefaultTransactionIsolation.put(username, value); } void setPerUserDefaultTransactionIsolation(Map<String, Integer> userDefaultTransactionIsolation) { assertInitializationAllowed(); if (perUserDefaultTransactionIsolation == null) { perUserDefaultTransactionIsolation = new HashMap<String, Integer>(); } else { perUserDefaultTransactionIsolation.clear(); } perUserDefaultTransactionIsolation.putAll(userDefaultTransactionIsolation); } // ---------------------------------------------------------------------- // Instrumentation Methods /** * Get the number of active connections in the default pool. */ public int getNumActive() { return getNumActive(null); } /** * Get the number of active connections in the pool for a given user. */ public int getNumActive(String username) { ObjectPool<PooledConnectionAndInfo> pool = getPool(getPoolKey(username)); return pool == null ? 0 : pool.getNumActive(); } /** * Get the number of idle connections in the default pool. */ public int getNumIdle() { return getNumIdle(null); } /** * Get the number of idle connections in the pool for a given user. */ public int getNumIdle(String username) { ObjectPool<PooledConnectionAndInfo> pool = getPool(getPoolKey(username)); return pool == null ? 0 : pool.getNumIdle(); } // ---------------------------------------------------------------------- // Inherited abstract methods @Override protected PooledConnectionAndInfo getPooledConnectionAndInfo(String username, String password) throws SQLException { final PoolKey key = getPoolKey(username); ObjectPool<PooledConnectionAndInfo> pool; PooledConnectionManager manager; synchronized (this) { manager = managers.get(key); if (manager == null) { try { registerPool(username, password); manager = managers.get(key); } catch (NamingException e) { throw new SQLException("RegisterPool failed", e); } } pool = ((CPDSConnectionFactory) manager).getPool(); } PooledConnectionAndInfo info = null; try { info = pool.borrowObject(); } catch (NoSuchElementException ex) { throw new SQLException("Could not retrieve connection info from pool", ex); } catch (Exception e) { // See if failure is due to CPDSConnectionFactory authentication failure try { testCPDS(username, password); } catch (Exception ex) { throw new SQLException("Could not retrieve connection info from pool", ex); } // New password works, so kill the old pool, create a new one, and borrow manager.closePool(username); synchronized (this) { managers.remove(key); } try { registerPool(username, password); pool = getPool(key); } catch (NamingException ne) { throw new SQLException("RegisterPool failed", ne); } try { info = pool.borrowObject(); } catch (Exception ex) { throw new SQLException("Could not retrieve connection info from pool", ex); } } return info; } @Override protected void setupDefaults(Connection con, String username) throws SQLException { Boolean defaultAutoCommit = isDefaultAutoCommit(); if (username != null) { Boolean userMax = getPerUserDefaultAutoCommit(username); if (userMax != null) { defaultAutoCommit = userMax; } } Boolean defaultReadOnly = isDefaultReadOnly(); if (username != null) { Boolean userMax = getPerUserDefaultReadOnly(username); if (userMax != null) { defaultReadOnly = userMax; } } int defaultTransactionIsolation = getDefaultTransactionIsolation(); if (username != null) { Integer userMax = getPerUserDefaultTransactionIsolation(username); if (userMax != null) { defaultTransactionIsolation = userMax.intValue(); } } if (defaultAutoCommit != null && con.getAutoCommit() != defaultAutoCommit.booleanValue()) { con.setAutoCommit(defaultAutoCommit.booleanValue()); } if (defaultTransactionIsolation != UNKNOWN_TRANSACTIONISOLATION) { con.setTransactionIsolation(defaultTransactionIsolation); } if (defaultReadOnly != null && con.isReadOnly() != defaultReadOnly.booleanValue()) { con.setReadOnly(defaultReadOnly.booleanValue()); } } @Override protected PooledConnectionManager getConnectionManager(UserPassKey upkey) { return managers.get(getPoolKey(upkey.getUsername())); } /** * Returns a <code>PerUserPoolDataSource</code> {@link Reference}. */ @Override public Reference getReference() throws NamingException { Reference ref = new Reference(getClass().getName(), PerUserPoolDataSourceFactory.class.getName(), null); ref.add(new StringRefAddr("instanceKey", getInstanceKey())); return ref; } /** * Create a pool key from the provided parameters. * * @param username User name * @return The pool key */ private PoolKey getPoolKey(String username) { return new PoolKey(getDataSourceName(), username); } private synchronized void registerPool(String username, String password) throws NamingException, SQLException { ConnectionPoolDataSource cpds = testCPDS(username, password); // Set up the factory we will use (passing the pool associates // the factory with the pool, so we do not have to do so // explicitly) CPDSConnectionFactory factory = new CPDSConnectionFactory(cpds, getValidationQuery(), getValidationQueryTimeout(), isRollbackAfterValidation(), username, password); factory.setMaxConnLifetimeMillis(getMaxConnLifetimeMillis()); // Create an object pool to contain our PooledConnections GenericObjectPool<PooledConnectionAndInfo> pool = new GenericObjectPool<PooledConnectionAndInfo>(factory); factory.setPool(pool); pool.setBlockWhenExhausted(getPerUserBlockWhenExhausted(username)); pool.setEvictionPolicyClassName(getPerUserEvictionPolicyClassName(username)); pool.setLifo(getPerUserLifo(username)); pool.setMaxIdle(getPerUserMaxIdle(username)); pool.setMaxTotal(getPerUserMaxTotal(username)); pool.setMaxWaitMillis(getPerUserMaxWaitMillis(username)); pool.setMinEvictableIdleTimeMillis(getPerUserMinEvictableIdleTimeMillis(username)); pool.setMinIdle(getPerUserMinIdle(username)); pool.setNumTestsPerEvictionRun(getPerUserNumTestsPerEvictionRun(username)); pool.setSoftMinEvictableIdleTimeMillis(getPerUserSoftMinEvictableIdleTimeMillis(username)); pool.setTestOnCreate(getPerUserTestOnCreate(username)); pool.setTestOnBorrow(getPerUserTestOnBorrow(username)); pool.setTestOnReturn(getPerUserTestOnReturn(username)); pool.setTestWhileIdle(getPerUserTestWhileIdle(username)); pool.setTimeBetweenEvictionRunsMillis(getPerUserTimeBetweenEvictionRunsMillis(username)); pool.setSwallowedExceptionListener(new SwallowedExceptionLogger(log)); Object old = managers.put(getPoolKey(username), factory); if (old != null) { throw new IllegalStateException("Pool already contains an entry for this user/password: " + username); } } /** * Supports Serialization interface. * * @param in a <code>java.io.ObjectInputStream</code> value * @exception IOException if an error occurs * @exception ClassNotFoundException if an error occurs */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { try { in.defaultReadObject(); PerUserPoolDataSource oldDS = (PerUserPoolDataSource) new PerUserPoolDataSourceFactory() .getObjectInstance(getReference(), null, null, null); this.managers = oldDS.managers; } catch (NamingException e) { throw new IOException("NamingException: " + e); } } /** * Returns the object pool associated with the given PoolKey. * * @param key PoolKey identifying the pool * @return the GenericObjectPool pooling connections for the username and datasource * specified by the PoolKey */ private ObjectPool<PooledConnectionAndInfo> getPool(PoolKey key) { CPDSConnectionFactory mgr = (CPDSConnectionFactory) managers.get(key); return mgr == null ? null : mgr.getPool(); } }