/*

  * 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 org.apache.commons.dbcp.datasources;

 import java.io.IOException;

 import java.io.ObjectInputStream;

 import java.sql.Connection;

 import java.sql.SQLException;

 import javax.naming.NamingException;

 import javax.naming.Reference;

 import javax.naming.StringRefAddr;

 import javax.sql.ConnectionPoolDataSource;

 import org.apache.commons.pool.KeyedObjectPool;

 import org.apache.commons.pool.impl.GenericKeyedObjectPool;

 import org.apache.commons.pool.impl.GenericObjectPool;

 import org.apache.commons.dbcp.SQLNestedException;

 /**

  * <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. All users (based on username) share a single 

  * maximum number of Connections in this datasource.</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, idle connections

  * created using the old password are destroyed and new connections are created

  * using the new password.</p>

  *

  * @author John D. McNally

  * @version $Revision: 1023401 $ $Date: 2010-10-16 21:54:24 -0400 (Sat, 16 Oct 2010) $

  */

 public class SharedPoolDataSource

     extends InstanceKeyDataSource {

     private static final long serialVersionUID = -8132305535403690372L;

     private int maxActive = GenericObjectPool.DEFAULT_MAX_ACTIVE;

     private int maxIdle = GenericObjectPool.DEFAULT_MAX_IDLE;

     private int maxWait = (int)Math.min(Integer.MAX_VALUE,

         GenericObjectPool.DEFAULT_MAX_WAIT);

     private transient KeyedObjectPool pool = null;

     private transient KeyedCPDSConnectionFactory factory = null;

     /**

      * Default no-arg constructor for Serialization

      */

     public SharedPoolDataSource() {

     }

     /**

      * Close pool being maintained by this datasource.

      */

     public void close() throws Exception {

         if (pool != null) {

             pool.close();

         }

         InstanceKeyObjectFactory.removeInstance(instanceKey);

     }

     // -------------------------------------------------------------------

     // Properties

     /**

      * The maximum number of active connections that can be allocated from

      * this pool at the same time, or non-positive for no limit.

      */

     public int getMaxActive() {

         return (this.maxActive);

     }

     /**

      * The maximum number of active connections that can be allocated from

      * this pool at the same time, or non-positive for no limit.

      * The default is 8.

      */

     public void setMaxActive(int maxActive) {

         assertInitializationAllowed();

         this.maxActive = maxActive;

     }

     /**

      * The maximum number of active connections that can remain idle in the

      * pool, without extra ones being released, or negative for no limit.

      */

     public int getMaxIdle() {

         return (this.maxIdle);

     }

     /**

      * The maximum number of active connections that can remain idle in the

      * pool, without extra ones being released, or negative for no limit.

      * The default is 8.

      */

     public void setMaxIdle(int maxIdle) {

         assertInitializationAllowed();

         this.maxIdle = maxIdle;

     }

     /**

      * The maximum number of milliseconds that the pool will wait (when there

      * are no available connections) for a connection to be returned before

      * throwing an exception, or -1 to wait indefinitely.  Will fail 

      * immediately if value is 0.

      * The default is -1.

      */

     public int getMaxWait() {

         return (this.maxWait);

     }

     /**

      * The maximum number of milliseconds that the pool will wait (when there

      * are no available connections) for a connection to be returned before

      * throwing an exception, or -1 to wait indefinitely.  Will fail 

      * immediately if value is 0.

      * The default is -1.

      */

     public void setMaxWait(int maxWait) {

         assertInitializationAllowed();

         this.maxWait = maxWait;

     }

     // ----------------------------------------------------------------------

     // Instrumentation Methods

     /**

      * Get the number of active connections in the pool.

      */

     public int getNumActive() {

         return (pool == null) ? 0 : pool.getNumActive();

     }

     /**

      * Get the number of idle connections in the pool.

      */

     public int getNumIdle() {

         return (pool == null) ? 0 : pool.getNumIdle();

     }

     // ----------------------------------------------------------------------

     // Inherited abstract methods

     protected PooledConnectionAndInfo 

         getPooledConnectionAndInfo(String username, String password)

         throws SQLException {

         synchronized(this) {

             if (pool == null) {

                 try {

                     registerPool(username, password);

                 } catch (NamingException e) {

                     throw new SQLNestedException("RegisterPool failed", e);

                 }

             }

         }

         PooledConnectionAndInfo info = null;

         UserPassKey key = new UserPassKey(username, password);

         try {

             info = (PooledConnectionAndInfo) pool.borrowObject(key);

         }

         catch (Exception e) {

             throw new SQLNestedException(

                     "Could not retrieve connection info from pool", e);

         }

         return info;

     }

     protected PooledConnectionManager getConnectionManager(UserPassKey upkey)  {

         return factory;

     }

     /**

      * Returns a <code>SharedPoolDataSource</code> {@link Reference}.

      * 

      * @since 1.2.2

      */

     public Reference getReference() throws NamingException {

         Reference ref = new Reference(getClass().getName(),

             SharedPoolDataSourceFactory.class.getName(), null);

         ref.add(new StringRefAddr("instanceKey", instanceKey));

         return ref;

     }

     private void registerPool(

         String username, String password) 

         throws javax.naming.NamingException, SQLException {

         ConnectionPoolDataSource cpds = testCPDS(username, password);

         // Create an object pool to contain our PooledConnections

         GenericKeyedObjectPool tmpPool = new GenericKeyedObjectPool(null);

         tmpPool.setMaxActive(getMaxActive());

         tmpPool.setMaxIdle(getMaxIdle());

         tmpPool.setMaxWait(getMaxWait());

         tmpPool.setWhenExhaustedAction(whenExhaustedAction(maxActive, maxWait));

         tmpPool.setTestOnBorrow(getTestOnBorrow());

         tmpPool.setTestOnReturn(getTestOnReturn());

         tmpPool.setTimeBetweenEvictionRunsMillis(

             getTimeBetweenEvictionRunsMillis());

         tmpPool.setNumTestsPerEvictionRun(getNumTestsPerEvictionRun());

         tmpPool.setMinEvictableIdleTimeMillis(getMinEvictableIdleTimeMillis());

         tmpPool.setTestWhileIdle(getTestWhileIdle());

         pool = tmpPool;

         // 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)

         factory = new KeyedCPDSConnectionFactory(cpds, pool, getValidationQuery(),

                                        isRollbackAfterValidation());

     }

     protected void setupDefaults(Connection con, String username) throws SQLException {

         boolean defaultAutoCommit = isDefaultAutoCommit();

         if (con.getAutoCommit() != defaultAutoCommit) {

             con.setAutoCommit(defaultAutoCommit);

         }

         int defaultTransactionIsolation = getDefaultTransactionIsolation();

         if (defaultTransactionIsolation != UNKNOWN_TRANSACTIONISOLATION) {

             con.setTransactionIsolation(defaultTransactionIsolation);

         }

         boolean defaultReadOnly = isDefaultReadOnly();

         if (con.isReadOnly() != defaultReadOnly) {

             con.setReadOnly(defaultReadOnly);

         }

     }

     /**

      * 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();

             SharedPoolDataSource oldDS = (SharedPoolDataSource)

                 new SharedPoolDataSourceFactory()

                     .getObjectInstance(getReference(), null, null, null);

             this.pool = oldDS.pool;

         }

         catch (NamingException e)

         {

             throw new IOException("NamingException: " + e);

         }

     }

 }