/*

  * 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.ArrayList;

 import java.util.List;

 import java.util.logging.Logger;

 import org.apache.commons.pool.ObjectPool;

 import org.apache.commons.pool.KeyedObjectPool;

 import org.apache.commons.math.random.RandomData;

 import org.apache.commons.math.random.RandomDataImpl;

 import org.apache.commons.math.stat.descriptive.SummaryStatistics;

 import org.apache.commons.performance.ClientThread;

 import org.apache.commons.performance.Statistics;

 /**

  * Client thread that borrows and returns objects from a pool in a loop.

  * See {@link ClientThread ClientThread javadoc} for a description

  * of how times between requests are computed.

  *

  */

 public class PoolClientThread extends ClientThread {

     private ObjectPool pool;

     private KeyedObjectPool keyedPool;

     private boolean keyed;

     private List<Integer> keys;

     private RandomData randomData = new RandomDataImpl();

     private SummaryStatistics numActiveStats = new SummaryStatistics();

     private SummaryStatistics numIdleStats = new SummaryStatistics();

     private double samplingRate = 0;

     /**

      * Create a pool client thread for an ObjectPool.

      * 

      * @param iterations number of iterations

      * @param minDelay minimum mean time between client requests

      * @param maxDelay maximum mean time between client requests

      * @param delayType distribution of time between client requests

      * @param rampPeriod ramp period of cycle for cyclic load

      * @param peakPeriod peak period of cycle for cyclic load

      * @param troughPeriod trough period of cycle for cyclic load

      * @param cycleType type of cycle for mean delay

      * @param rampType type of ramp (linear or random jumps)

      * @param logger common logger shared by all clients

      * @param stats Statistics container

      * @param pool ObjectPool

      */

     public PoolClientThread(long iterations, long minDelay, long maxDelay,

             double sigma, String delayType, long rampPeriod, long peakPeriod,

             long troughPeriod, String cycleType, String rampType, Logger logger, 

             Statistics stats, ObjectPool pool, double samplingRate) {

         super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod,

                 peakPeriod, troughPeriod, cycleType,rampType, logger, 

                 stats); 

         this.pool = pool;

         this.keyed = false;

         this.samplingRate = samplingRate;

     }

     /**

      * Create a pool client thread for a KeyedObjectPool.

      * 

      * @param iterations number of iterations

      * @param minDelay minimum mean time between client requests

      * @param maxDelay maximum mean time between client requests

      * @param delayType distribution of time between client requests

      * @param rampPeriod ramp period of cycle for cyclic load

      * @param peakPeriod peak period of cycle for cyclic load

      * @param troughPeriod trough period of cycle for cyclic load

      * @param cycleType type of cycle for mean delay

      * @param rampType type of ramp (linear or random jumps)

      * @param logger common logger shared by all clients

      * @param stats Statistics container 

      * @param keyedPool KeyedObjectPool

      */

     public PoolClientThread(long iterations, long minDelay, long maxDelay,

             double sigma, String delayType, long rampPeriod, long peakPeriod,

             long troughPeriod, String cycleType, String rampType, Logger logger, 

             Statistics stats, KeyedObjectPool keyedPool, double samplingRate) {

         super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod,

                 peakPeriod, troughPeriod, cycleType,rampType, logger, 

                 stats); 

         this.keyedPool = keyedPool;

         this.keyed = true;

         this.samplingRate = samplingRate;

         keys = new ArrayList<Integer>();

         for (int i = 0; i < 20; i++) { //TODO: make number of keys configurable

             keys.add(new Integer(i));

         }

         randomData = new RandomDataImpl();

     }

     /** Borrow and return */

     public void execute() throws Exception {

        if (keyed) {

            Integer key = keys.get(randomData.nextInt(0, 19));

            Waiter waiter = (Waiter) keyedPool.borrowObject(key);

            waiter.doWait();

            keyedPool.returnObject(key, waiter);

        } else {

            Waiter waiter = (Waiter) pool.borrowObject(); 

            waiter.doWait();

            pool.returnObject(waiter);

        }

     }

     protected void cleanUp() throws Exception {

         // Capture pool metrics 

         if (randomData.nextUniform(0, 1) < samplingRate) {

             if (keyed) {

                 numIdleStats.addValue(keyedPool.getNumIdle());

                 numActiveStats.addValue(keyedPool.getNumActive());

             } else {

                 numIdleStats.addValue(pool.getNumIdle());

                 numActiveStats.addValue(pool.getNumActive());

             }

         }

     }

     protected void finish() throws Exception {

         // Add pool metrics to stats

         stats.addStatistics(

                 numIdleStats, Thread.currentThread().getName(), "numIdle");

         stats.addStatistics(

                 numActiveStats, Thread.currentThread().getName(), "numActive");

     }

 }