Coverage Report - org.mule.transport.ConfigurableKeyedObjectPool
 
Classes in this File Line Coverage Branch Coverage Complexity
ConfigurableKeyedObjectPool
N/A
N/A
1
 
 1  
 /*
 2  
  * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
 3  
  * The software in this package is published under the terms of the CPAL v1.0
 4  
  * license, a copy of which has been included with this distribution in the
 5  
  * LICENSE.txt file.
 6  
  */
 7  
 package org.mule.transport;
 8  
 
 9  
 import org.apache.commons.pool.KeyedObjectPool;
 10  
 
 11  
 /**
 12  
  * A configurable {@link KeyedObjectPool}. Extracted from
 13  
  * {@link org.apache.commons.pool.impl.GenericKeyedObjectPool}.
 14  
  */
 15  
 public interface ConfigurableKeyedObjectPool extends KeyedObjectPool
 16  
 {
 17  
 
 18  
     byte WHEN_EXHAUSTED_FAIL = 0;
 19  
     byte WHEN_EXHAUSTED_BLOCK = 1;
 20  
     byte WHEN_EXHAUSTED_GROW = 2;
 21  
 
 22  
     /**
 23  
      * Clears the pool, removing all pooled instances.
 24  
      */
 25  
     void clear();
 26  
 
 27  
     /**
 28  
      * Returns the overall maximum number of objects (across pools) that can
 29  
      * exist at one time. A negative value indicates no limit.
 30  
      */
 31  
     int getMaxTotal();
 32  
 
 33  
     /**
 34  
      * Sets the cap on the total number of instances from all pools combined.
 35  
      *
 36  
      * @param maxTotal The cap on the total number of instances across pools.
 37  
      *                 Use a negative value for no limit.
 38  
      */
 39  
     void setMaxTotal(int maxTotal);
 40  
 
 41  
     /**
 42  
      * Returns the cap on the number of active instances per key.
 43  
      * A negative value indicates no limit.
 44  
      */
 45  
     int getMaxActive();
 46  
 
 47  
     /**
 48  
      * Sets the cap on the number of active instances per key.
 49  
      *
 50  
      * @param maxActive The cap on the number of active instances per key.
 51  
      *                  Use a negative value for no limit.
 52  
      */
 53  
     void setMaxActive(int maxActive);
 54  
 
 55  
     /**
 56  
      * Returns the maximum amount of time (in milliseconds) the
 57  
      * {@link #borrowObject} method should block before throwing
 58  
      * an exception when the pool is exhausted and the
 59  
      * {@link #setWhenExhaustedAction "when exhausted" action} is
 60  
      * {@link #WHEN_EXHAUSTED_BLOCK}.
 61  
      * <p/>
 62  
      * When less than or equal to 0, the {@link #borrowObject} method
 63  
      * may block indefinitely.
 64  
      */
 65  
     long getMaxWait();
 66  
 
 67  
     /**
 68  
      * Sets the maximum amount of time (in milliseconds) the
 69  
      * {@link #borrowObject} method should block before throwing
 70  
      * an exception when the pool is exhausted and the
 71  
      * {@link #setWhenExhaustedAction "when exhausted" action} is
 72  
      * {@link #WHEN_EXHAUSTED_BLOCK}.
 73  
      * <p/>
 74  
      * When less than or equal to 0, the {@link #borrowObject} method
 75  
      * may block indefinitely.
 76  
      *
 77  
      * @param maxWait the maximum number of milliseconds borrowObject will block or negative for indefinitely.
 78  
      */
 79  
     void setMaxWait(long maxWait);
 80  
 
 81  
     /**
 82  
      * Returns the cap on the number of "idle" instances per key.
 83  
      */
 84  
     int getMaxIdle();
 85  
 
 86  
     /**
 87  
      * Sets the cap on the number of "idle" instances in the pool.
 88  
      *
 89  
      * @param maxIdle the maximum number of "idle" instances that can be held
 90  
      *                in a given keyed pool. Use a negative value for no limit.
 91  
      */
 92  
     void setMaxIdle(int maxIdle);
 93  
 
 94  
     /**
 95  
      * Sets the action to take when the {@link #borrowObject} method
 96  
      * is invoked when the pool is exhausted.
 97  
      *
 98  
      * @param whenExhaustedAction the action code, which must be one of
 99  
      *                            {@link #WHEN_EXHAUSTED_BLOCK}, {@link #WHEN_EXHAUSTED_FAIL},
 100  
      *                            or {@link #WHEN_EXHAUSTED_GROW}
 101  
      */
 102  
     void setWhenExhaustedAction(byte whenExhaustedAction);
 103  
 
 104  
     /**
 105  
      * Returns the action to take when the {@link #borrowObject} method
 106  
      * is invoked when the pool is exhausted.
 107  
      *
 108  
      * @return one of {@link #WHEN_EXHAUSTED_BLOCK},
 109  
      *         {@link #WHEN_EXHAUSTED_FAIL} or {@link #WHEN_EXHAUSTED_GROW}
 110  
      */
 111  
     byte getWhenExhaustedAction();
 112  
 }