package org.apache.ojb.broker.accesslayer;
   
   /* Copyright 2002-2005 The Apache Software Foundation
    *
    * 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.
   */
  
  import org.apache.commons.pool.BasePoolableObjectFactory;
  import org.apache.commons.pool.ObjectPool;
  import org.apache.commons.pool.PoolableObjectFactory;
  import org.apache.commons.pool.impl.GenericObjectPool;
  import org.apache.ojb.broker.metadata.JdbcConnectionDescriptor;
  import org.apache.ojb.broker.util.logging.Logger;
  import org.apache.ojb.broker.util.logging.LoggerFactory;
  import org.apache.ojb.broker.OJBRuntimeException;
  
  import java.sql.Connection;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.sql.PreparedStatement;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.NoSuchElementException;
  
  /**
   * Connection factory which pools the requested
   * connections for different JdbcConnectionDescriptors
   * using Commons Pool API.
   *
   * @version $Id: ConnectionFactoryPooledImpl.java,v 1.1 2007-08-24 22:17:30 ewestfal Exp $
   * @see <a href="http://jakarta.apache.org/commons/pool/">Commons Pool Website</a>
   */
  public class ConnectionFactoryPooledImpl extends ConnectionFactoryAbstractImpl
  {
  
      private Logger log = LoggerFactory.getLogger(ConnectionFactoryPooledImpl.class);
      /** Key=PBKey, value=ObjectPool. */
      private Map poolMap = new HashMap();
      /** Synchronize object for operations not synchronized on Map only. */
      private final Object poolSynch = new Object();
  
      public void releaseJdbcConnection(JdbcConnectionDescriptor jcd, Connection con)
              throws LookupException
      {
          final ObjectPool op = (ObjectPool) poolMap.get(jcd.getPBKey());
          try
          {
              /* mkalen: NB - according to the Commons Pool API we should _not_ perform
               * any additional checks here since we will then break testOnX semantics
               *
               * To enable Connection validation on releaseJdbcConnection,
               * set a validation query and specify testOnRelease=true
               *
               * Destruction of pooled objects is performed by the actual Commons Pool
               * ObjectPool implementation when the object factory's validateObject method
               * returns false. See ConPoolFactory#validateObject.
               */
              op.returnObject(con);
          }
          catch (Exception e)
          {
              throw new LookupException(e);
          }
      }
  
      public Connection checkOutJdbcConnection(JdbcConnectionDescriptor jcd) throws LookupException
      {
          ObjectPool op = (ObjectPool) poolMap.get(jcd.getPBKey());
          if (op == null)
          {
              synchronized (poolSynch)
              {
                  log.info("Create new connection pool:" + jcd);
                  op = createConnectionPool(jcd);
                  poolMap.put(jcd.getPBKey(), op);
              }
          }
          final Connection conn;
          try
          {
              conn = (Connection) op.borrowObject();
          }
          catch (NoSuchElementException e)
          {
              int active = 0;
              int idle = 0;
              try
             {
                 active = op.getNumActive();
                 idle = op.getNumIdle();
             }
             catch(Exception ignore){}
             throw new LookupException("Could not borrow connection from pool, seems ObjectPool is exhausted." +
                     " Active/Idle instances in pool=" + active + "/" +  idle
                     + ". "+ JdbcConnectionDescriptor.class.getName() + ":  " + jcd, e);
         }
         catch (Exception e)
         {
             int active = 0;
             int idle = 0;
             try
             {
                 active = op.getNumActive();
                 idle = op.getNumIdle();
             }
             catch(Exception ignore){}
             throw new LookupException("Could not borrow connection from pool." +
                     " Active/Idle instances in pool=" + active + "/" +  idle
                     + ". "+ JdbcConnectionDescriptor.class.getName() + ":  " + jcd, e);
         }
         return conn;
     }
 
     /**
      * Create the pool for pooling the connections of the given connection descriptor.
      * Override this method to implement your on {@link org.apache.commons.pool.ObjectPool}.
      */
     public ObjectPool createConnectionPool(JdbcConnectionDescriptor jcd)
     {
         if (log.isDebugEnabled()) log.debug("createPool was called");
         PoolableObjectFactory pof = new ConPoolFactory(this, jcd);
         GenericObjectPool.Config conf = jcd.getConnectionPoolDescriptor().getObjectPoolConfig();
         return (ObjectPool)new GenericObjectPool(pof, conf);
     }
 
     /**
      * Closes all managed pools.
      */
     public void releaseAllResources()
     {
         synchronized (poolSynch)
         {
             Collection pools = poolMap.values();
             poolMap = new HashMap(poolMap.size());
             ObjectPool op = null;
             for (Iterator iterator = pools.iterator(); iterator.hasNext();)
             {
                 try
                 {
                     op = ((ObjectPool) iterator.next());
                     op.close();
                 }
                 catch (Exception e)
                 {
                     log.error("Exception occured while closing pool " + op, e);
                 }
             }
         }
         super.releaseAllResources();
     }
 
     //**************************************************************************************
     // Inner classes
     //************************************************************************************
 
     /**
      * Inner class - {@link org.apache.commons.pool.PoolableObjectFactory}
      * used as factory for connection pooling.
      */
     class ConPoolFactory extends BasePoolableObjectFactory
     {
         final private JdbcConnectionDescriptor jcd;
         final private ConnectionFactoryPooledImpl cf;
         private int failedValidationQuery;
 
         public ConPoolFactory(ConnectionFactoryPooledImpl cf, JdbcConnectionDescriptor jcd)
         {
             this.cf = cf;
             this.jcd = jcd;
         }
 
         public boolean validateObject(Object obj)
         {
             boolean isValid = false;
             if (obj != null)
             {
                 final Connection con = (Connection) obj;
                 try
                 {
                     isValid = !con.isClosed();
                 }
                 catch (SQLException e)
                 {
                     log.warn("Connection validation failed: " + e.getMessage());
                     if (log.isDebugEnabled()) log.debug(e);
                     isValid = false;
                 }
                 if (isValid)
                 {
                     final String validationQuery;
                     validationQuery = jcd.getConnectionPoolDescriptor().getValidationQuery();
                     if (validationQuery != null)
                     {
                         isValid = validateConnection(con, validationQuery);
                     }
                 }
             }
             return isValid;
         }
 
         private boolean validateConnection(Connection conn, String query)
         {
             PreparedStatement stmt = null;
             ResultSet rset = null;
             boolean isValid = false;
             if (failedValidationQuery > 100)
             {
                 --failedValidationQuery;
                 throw new OJBRuntimeException("Validation of connection "+conn+" using validation query '"+
                         query + "' failed more than 100 times.");
             }
             try
             {
                 stmt = conn.prepareStatement(query);
                 stmt.setMaxRows(1);
                 stmt.setFetchSize(1);
                 rset = stmt.executeQuery();
                 if (rset.next())
                 {
                     failedValidationQuery = 0;
                     isValid = true;
                 }
                 else
                 {
                     ++failedValidationQuery;
                     log.warn("Validation query '" + query +
                             "' result set does not match, discard connection");
                     isValid = false;
                 }
             }
             catch (SQLException e)
             {
                 ++failedValidationQuery;
                 log.warn("Validation query for connection failed, discard connection. Query was '" +
                         query + "', Message was " + e.getMessage());
                 if (log.isDebugEnabled()) log.debug(e);
             }
             finally
             {
                 try
                 {
                     if(rset != null) rset.close();
                 }
                 catch (SQLException t)
                 {
                     if (log.isDebugEnabled()) log.debug("ResultSet already closed.", t);
                 }
                 try
                 {
                     if(stmt != null) stmt.close();
                 }
                 catch (SQLException t)
                 {
                     if (log.isDebugEnabled()) log.debug("Statement already closed.", t);
                 }
             }
             return isValid;
         }
 
         public Object makeObject() throws Exception
         {
             if (log.isDebugEnabled()) log.debug("makeObject called");
             return cf.newConnectionFromDriverManager(jcd);
         }
 
         public void destroyObject(Object obj)
                 throws Exception
         {
             log.info("Destroy object was called, try to close connection: " + obj);
             try
             {
                 ((Connection) obj).close();
             }
             catch (SQLException ignore)
             {
                 //ignore it
             }
         }
     }
 
 }