/*

  * 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.performance.pool;

 import java.util.HashMap;

 import java.util.Map;

 import java.util.Iterator;

 import java.util.logging.Logger;

 import java.util.logging.Level;

 import java.util.concurrent.atomic.AtomicInteger;

 import org.apache.commons.pool.PoolableObjectFactory;

 import org.apache.commons.pool.KeyedPoolableObjectFactory;

 /**

  * Object factory with configurable latencies for object lifecycle methods.

  *

  */

 public class WaiterFactory implements PoolableObjectFactory,

 KeyedPoolableObjectFactory {

     // TODO: implement protected getters so these can be stochastic

     private long activateLatency = 0;

     private long destroyLatency = 0;

     private long makeLatency = 0;

     private long passivateLatency = 0;

     private long validateLatency = 0;

     private long waiterLatency = 0;

     /** Count of (makes - destroys) since last reset */

     private long activeCount = 0;

     /** Count of (makes - destroys) per key since last reset */

     private Map<Object, AtomicInteger> activeCounts = 

         new HashMap<Object, AtomicInteger>();

     /** Maximum of (makes - destroys) - if exceeded IllegalStateException */

     private long maxActive = Long.MAX_VALUE;

     /** Maximum of (makes - destroys) per key */

     private long maxActivePerKey = Long.MAX_VALUE;

     protected static final Logger logger = 

         Logger.getLogger(WaiterFactory.class.getName());

     public WaiterFactory(long activateLatency, long destroyLatency,

             long makeLatency, long passivateLatency, long validateLatency,

             long waiterLatency,long maxActive, long maxActivePerKey) {

         this.activateLatency = activateLatency;

         this.destroyLatency = destroyLatency;

         this.makeLatency = makeLatency;

         this.passivateLatency = passivateLatency;

         this.validateLatency = validateLatency;

         this.waiterLatency = waiterLatency;

         this.maxActive = maxActive;

         this.maxActivePerKey = maxActivePerKey;

     }

     public WaiterFactory(long activateLatency, long destroyLatency,

             long makeLatency, long passivateLatency, long validateLatency,

             long waiterLatency) {

         this(activateLatency, destroyLatency, makeLatency, passivateLatency,

                 validateLatency, waiterLatency, Long.MAX_VALUE, Long.MAX_VALUE);

     }

     public WaiterFactory(long activateLatency, long destroyLatency,

             long makeLatency, long passivateLatency, long validateLatency,

             long waiterLatency,long maxActive) {

         this(activateLatency, destroyLatency, makeLatency, passivateLatency,

                 validateLatency, waiterLatency, maxActive, Long.MAX_VALUE);

     }

     public void activateObject(Object arg0) throws Exception {

         if (logger.isLoggable(Level.FINEST)) {

             logger.finest("activate");

         }

         doWait(activateLatency);

     }

     public void destroyObject(Object arg0) throws Exception {

         if (logger.isLoggable(Level.FINE)) {

             logger.fine("destroy");

         }

         doWait(destroyLatency);

         ((Waiter) arg0).setValid(false);

         // Decrement *after* destroy 

         synchronized (this) {

             activeCount--;

         }

     }

     public Object makeObject() throws Exception {

         // Increment and test *before* make

         synchronized (this) {

             if (activeCount >= maxActive) {

                 throw new IllegalStateException("Too many active instances: " +

                 activeCount + " in circulation with maxActive = " + maxActive);

             } else {

                 activeCount++;

             }

         }

         if (logger.isLoggable(Level.FINE)) {

             logger.fine("makeObject");

         }

         doWait(makeLatency);

         return new Waiter(false, true, waiterLatency);

     }

     public void passivateObject(Object arg0) throws Exception {

         if (logger.isLoggable(Level.FINEST)) {

             logger.finest("passivate");

         }

         ((Waiter) arg0).setActive(false);

         doWait(passivateLatency);

     }

     public boolean validateObject(Object arg0) {

         if (logger.isLoggable(Level.FINE)) {

             logger.fine("validate");

         }

         doWait(validateLatency);

         return ((Waiter) arg0).isValid();

     }

     protected void doWait(long latency) {

         try {

             Thread.sleep(latency);

         } catch (InterruptedException ex) {

             // ignore

         }

     }

     public synchronized void reset() {

         activeCount = 0;

         if (activeCounts.isEmpty()) {

             return;

         }

         Iterator it = activeCounts.keySet().iterator();

         while (it.hasNext()) {

             ((AtomicInteger) activeCounts.get(it.next())).getAndSet(0);

         }

     }

     /**

      * @return the maxActive

      */

     public synchronized long getMaxActive() {

         return maxActive;

     }

     /**

      * @param maxActive the maxActive to set

      */

     public synchronized void setMaxActive(long maxActive) {

         this.maxActive = maxActive;

     }

     // KeyedPoolableObjectFactory methods

     public void activateObject(Object key, Object obj) throws Exception {

         activateObject(obj);

     }

     public void destroyObject(Object key, Object obj) throws Exception {

         destroyObject(obj);

         ((AtomicInteger) activeCounts.get(key)).getAndDecrement(); 

     }

     public Object makeObject(Object key) throws Exception {

         synchronized (this) {

             AtomicInteger count = (AtomicInteger) activeCounts.get(key);

             if (count == null) {

                 count = new AtomicInteger(1);

                 activeCounts.put(key, count);

             } else {

                 if (count.get() >= maxActivePerKey) {

                     throw new IllegalStateException("Too many active " +

                     "instances for key = " + key + ": " + count.get() + 

                     " in circulation " + "with maxActivePerKey = " + 

                     maxActivePerKey);

                 } else {

                     count.incrementAndGet();

                 }

             }

         }

         return makeObject();

     }

     public void passivateObject(Object key, Object obj) throws Exception {

         passivateObject(obj);

     }

     public boolean validateObject(Object key, Object obj) {

         return validateObject(obj);

     }

 }