DynamicSettings (in-memory-queue 1.1.1 API)

java.lang.Object
- org.ak.trafficController.messaging.mem.DynamicSettings<T>

Type Parameters:

T - Type of queue.
```
public class DynamicSettings<T>
extends java.lang.Object
```
This class handles dynamic settings of flow of messages. This class helps InMemoryQueueTuner to tune as per configuration set by user. As name suggest, this enables dynamic settings like increasing and decreasing consumer count on basis of number of messages. Actual queue will be wrapped inside the settings.
Consider we have the queue and production is very fast. If we do not have more consumer, we will soon end up to a situation where we can have out of memory etc. For this, this class can be configured to choose a high limit post which if messages in queue increases to, a new consumer is tried.
If post increasing consumer, the number of messages start reducing or when we had just a flare where we had lot of messages, there is a need to reduce the consumers which is handled once low limit is encountered.
We can reduce or increase this count to an extent where we do not have any consumer or we end up having so many consumers which itself causing slowness. This is also handled by minimum consumer count and maximum count. Also, this class allows queue to throw exception or ignore taking more messages. Also, post a threshold, it can be configured to get clean itself if the messages can be allowed to.

Constructor Summary

Constructors
Constructor and Description

DynamicSettings()

Constructors
Constructor and Description
`DynamicSettings()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`addItemInQueue(T item)` This method is responsible of adding data in queue.
`boolean`	`addItemsInQueue(java.util.Collection<T> list)` This method is responsible of adding data in list in queue.
`DynamicSettings<T>`	`addPreCleanHandler(java.util.function.Consumer<java.util.Queue<T>> preCleanHandler)` Add pre clean handler.
`protected boolean`	`addStillAllowed()` This method tells if we can still add in the queue.
`void`	`adjust()` This method handles the increase/decrease of consumers.
`protected void`	`decreaseConsumerIfPossible()` Decrease consumer if low limit attained back and we still have more consumers than minimum consumers.
`protected java.util.function.Consumer<java.util.Queue<T>>[]`	`getCleaners()` Get registered cleaners.
`java.lang.Long`	`getHighLimitWhenToIncreaseConsumer()` Get high limit when increase of consumer is tried.
`java.lang.Long`	`getLowLimitWhenToDecreseConsumer()` Get low limit when decrease of consumer is tried.
`java.lang.Integer`	`getMaxBatchConsumer()` Maximum batch consumers which can be created.
`java.lang.Integer`	`getMaxDirectConsumer()` Maximum direct consumers which can be created.
`java.lang.Integer`	`getMinBatchConsumer()` Minimum batch consumers which can be reduced to.
`java.lang.Integer`	`getMinDirectConsumer()` Minimum direct consumers which can be reduced to.
`java.lang.Long`	`getNumberOfRetriesToWait()` Number of retries while adding at threshold.
`InMemoryQueue<T>`	`getQueue()`
`java.lang.Boolean`	`getShouldClearQueueAtThreshold()` Should clear the queue if threshold reached.
`java.lang.Boolean`	`getShouldRetrySenderTillThresholdNotRecovered()` Is retry enabled while adding if threshold is reached.
`java.lang.Boolean`	`getShouldStopAddingAtThreshold()` Should stop adding at threshold.
`java.lang.Boolean`	`getShouldThrowExceptionPostRetry()` Should throw exception post retries.
`java.lang.Boolean`	`getShouldThrowExceptionWhenThresholdAtAdd()` Should throw exception when threshold reached in add process.
`java.lang.Long`	`getThresholdWhenNoMoreItemsShouldBeHandled()` Threshold when more item should not be added.
`java.lang.Long`	`getWaitForRetryThresholdLimit()` Wait time for retries.
`protected boolean`	`handleStopAddingAtThreshold()` This method is to handle in situation where we need to continue even when threshold reached.
`protected void`	`increaseConsumerIfPossible()` Increase consumers if high limit is reached and we still have number of consumers less than total current consumers.
`protected <K> boolean`	`processAddItem(java.util.function.Consumer<K> consumer, K item)` Checks if add item allowed and add the item to queue.
`DynamicSettings<T>`	`setHighLimitWhenToIncreaseConsumer(java.lang.Long highLimitWhenToIncreaseConsumer)` Set high limit when increase of consumer is tried.
`DynamicSettings<T>`	`setLowLimitWhenToDecreseConsumer(java.lang.Long lowLimitWhenToDecreseConsumer)` Set low limit when decrease of consumer is tried.
`DynamicSettings<T>`	`setMaxBatchConsumer(java.lang.Integer maxBatchConsumer)` Set the number of maximum batch consumers which can be created.
`DynamicSettings<T>`	`setMaxDirectConsumer(java.lang.Integer maxDirectConsumer)` Set the number of maximum direct consumers which can be created.
`DynamicSettings<T>`	`setMinBatchConsumer(java.lang.Integer minBatchConsumer)` Setter of minimum batch consumers till which consumers count be reduced to.
`DynamicSettings<T>`	`setMinDirectConsumer(java.lang.Integer minDirectConsumer)` Setter of mimimum direct consumers till which consumers count be reduced to.
`DynamicSettings<T>`	`setNumberOfRetriesToWait(java.lang.Long numberOfRetriesToWait)` Setter of Number of retries while adding at threshold.
`DynamicSettings<T>`	`setQueue(InMemoryQueue<T> queue)` Setting queue to be worked upon.
`DynamicSettings<T>`	`setShouldClearQueueAtThreshold(java.lang.Boolean shouldClearQueueAtThreshold)` Configures to if should clear queue at threshold.
`DynamicSettings<T>`	`setShouldRetrySenderTillThresholdNotRecovered(java.lang.Boolean shouldPauseSenderTillThresholdNotRecovered)` Setter of retry enabled while adding if threshold is reached.
`DynamicSettings<T>`	`setShouldStopAddingAtThreshold(java.lang.Boolean shouldStopAddingAtThreshold)` Setter of should stop adding at threshold.
`DynamicSettings<T>`	`setShouldThrowExceptionPostRetry(java.lang.Boolean shouldThrowExceptionPostRetry)` Set if exception should be thrown to producers if threshold is reached and configured amount of retries are also taken.
`DynamicSettings<T>`	`setShouldThrowExceptionWhenThresholdAtAdd(java.lang.Boolean shouldThrowExceptionWhenThresholdAtAdd)` Setter of Should throw exception when threshold reached in add process.
`DynamicSettings<T>`	`setThresholdWhenNoMoreItemsShouldBeHandled(java.lang.Long thresholdWheNoMoreItemsShouldBeHandled)` Threshold when more item should not be added.
`DynamicSettings<T>`	`setWaitForRetryThresholdLimit(java.lang.Long waitForRetryThresholdLimit)` Set wait time for retry.
`void`	`shutdown()` Shutdown underlying queue.
`static void`	`sleep(java.lang.Long sleepTime)` Sleep for configured amount.
`protected void`	`tryIfCanFreeUp()` It verifies if it can free up messages based on configurations and condition.
`protected boolean`	`waitForRetriesIfAny()` This method waits for configured number and for given time if allowed to wait.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DynamicSettings
```
public DynamicSettings()
```
- Method Detail
  - getQueue
```
public InMemoryQueue<T> getQueue()
```
  - setQueue
```
public DynamicSettings<T> setQueue(InMemoryQueue<T> queue)
```
    Setting queue to be worked upon.
    
    Parameters:
    
    queue - Queue which needs to be worked upon
    
    Returns:
    
    this object to make it easy to work on
  - getShouldThrowExceptionPostRetry
```
public java.lang.Boolean getShouldThrowExceptionPostRetry()
```
    Should throw exception post retries.
    
    Returns:
    
    true if configured so
  - setShouldThrowExceptionPostRetry
```
public DynamicSettings<T> setShouldThrowExceptionPostRetry(java.lang.Boolean shouldThrowExceptionPostRetry)
```
    Set if exception should be thrown to producers if threshold is reached and configured amount of retries are also taken.
    
    Parameters:
    
    shouldThrowExceptionPostRetry - Boolean value to set
    
    Returns:
    
    this object to make it easy to work on
  - sleep
```
public static void sleep(java.lang.Long sleepTime)
```
    Sleep for configured amount.
    
    Parameters:
    
    sleepTime - Sleep time for which we want to sleep
  - getMaxDirectConsumer
```
public java.lang.Integer getMaxDirectConsumer()
```
    Maximum direct consumers which can be created. A new consumer will be added automatically once high limit is reached. This is maximum till what we can increase.
    
    Returns:
    
    Maximum direct consumer
  - setMaxDirectConsumer
```
public DynamicSettings<T> setMaxDirectConsumer(java.lang.Integer maxDirectConsumer)
```
    Set the number of maximum direct consumers which can be created. A new consumer will be added automatically once high limit is reached. This is maximum till what we can increase.
    
    Parameters:
    
    maxDirectConsumer - Maximum direct consumer
    
    Returns:
    
    This object for further modifications easily
  - getMinDirectConsumer
```
public java.lang.Integer getMinDirectConsumer()
```
    Minimum direct consumers which can be reduced to. A consumer is stopped automatically once count is less than low limit. This is minimum till what we can reduce.
    
    Returns:
    
    Minimum direct consumer count
  - setMinDirectConsumer
```
public DynamicSettings<T> setMinDirectConsumer(java.lang.Integer minDirectConsumer)
```
    Setter of mimimum direct consumers till which consumers count be reduced to. A consumer is stopped automatically once count is less than low limit. This is minimum till what we can reduce.
    
    Parameters:
    
    minDirectConsumer - Minimum direct consumer count to be set
    
    Returns:
    
    This object for further modifications easily
  - getMaxBatchConsumer
```
public java.lang.Integer getMaxBatchConsumer()
```
    Maximum batch consumers which can be created. A new consumer will be added automatically once high limit is reached. This is maximum till what we can increase.
    
    Returns:
    
    Maximum batch consumer count
  - setMaxBatchConsumer
```
public DynamicSettings<T> setMaxBatchConsumer(java.lang.Integer maxBatchConsumer)
```
    Set the number of maximum batch consumers which can be created. A new consumer will be added automatically once high limit is reached. This is maximum till what we can increase.
    
    Parameters:
    
    maxBatchConsumer - Maximum batch consumer
    
    Returns:
    
    This object for further modifications easily
  - getMinBatchConsumer
```
public java.lang.Integer getMinBatchConsumer()
```
    Minimum batch consumers which can be reduced to. A consumer is stopped automatically once count is less than low limit. This is minimum till what we can reduce.
    
    Returns:
    
    Minimum batch consumer count
  - setMinBatchConsumer
```
public DynamicSettings<T> setMinBatchConsumer(java.lang.Integer minBatchConsumer)
```
    Setter of minimum batch consumers till which consumers count be reduced to. A consumer is stopped automatically once count is less than low limit. This is minimum till what we can reduce.
    
    Parameters:
    
    minBatchConsumer - Minimum direct consumer count to be set
    
    Returns:
    
    This object for further modifications easily
  - getHighLimitWhenToIncreaseConsumer
```
public java.lang.Long getHighLimitWhenToIncreaseConsumer()
```
    Get high limit when increase of consumer is tried. If the number of messages in queue is greater than this value a new consumer will be tried.
    
    Returns:
    
    High limit when to increase consumer
  - setHighLimitWhenToIncreaseConsumer
```
public DynamicSettings<T> setHighLimitWhenToIncreaseConsumer(java.lang.Long highLimitWhenToIncreaseConsumer)
```
    Set high limit when increase of consumer is tried. If the number of messages in queue is greater than this value a new consumer will be tried.
    
    Parameters:
    
    highLimitWhenToIncreaseConsumer - High limit when increase of consumer should be tried
    
    Returns:
    
    This object to easily configure urther
  - getLowLimitWhenToDecreseConsumer
```
public java.lang.Long getLowLimitWhenToDecreseConsumer()
```
    Get low limit when decrease of consumer is tried. If number of messages in queue is lower than this value, a consumer can be tried to shut down.
    
    Returns:
    
    Low limit
  - setLowLimitWhenToDecreseConsumer
```
public DynamicSettings<T> setLowLimitWhenToDecreseConsumer(java.lang.Long lowLimitWhenToDecreseConsumer)
```
    Set low limit when decrease of consumer is tried. If number of messages in queue is lower than this value, a consumer can be tried to shut down.
    
    Parameters:
    
    lowLimitWhenToDecreseConsumer - Low limit which should be taken in consideration
    
    Returns:
    
    This object to easily configure further
  - getThresholdWhenNoMoreItemsShouldBeHandled
```
public java.lang.Long getThresholdWhenNoMoreItemsShouldBeHandled()
```
    Threshold when more item should not be added.
    
    Returns:
    
    Threshold value
  - setThresholdWhenNoMoreItemsShouldBeHandled
```
public DynamicSettings<T> setThresholdWhenNoMoreItemsShouldBeHandled(java.lang.Long thresholdWheNoMoreItemsShouldBeHandled)
```
    Threshold when more item should not be added.
    
    Parameters:
    
    thresholdWheNoMoreItemsShouldBeHandled - Threshold value to be configured to
    
    Returns:
    
    This object to further configure.
  - getShouldClearQueueAtThreshold
```
public java.lang.Boolean getShouldClearQueueAtThreshold()
```
    Should clear the queue if threshold reached.
    
    Returns:
    
    should clear flag
  - setShouldClearQueueAtThreshold
```
public DynamicSettings<T> setShouldClearQueueAtThreshold(java.lang.Boolean shouldClearQueueAtThreshold)
```
    Configures to if should clear queue at threshold.
    
    Parameters:
    
    shouldClearQueueAtThreshold - boolean value
    
    Returns:
    
    This object for further configure
  - getShouldStopAddingAtThreshold
```
public java.lang.Boolean getShouldStopAddingAtThreshold()
```
    Should stop adding at threshold.
    
    Returns:
    
    should stop adding at threshold
  - setShouldStopAddingAtThreshold
```
public DynamicSettings<T> setShouldStopAddingAtThreshold(java.lang.Boolean shouldStopAddingAtThreshold)
```
    Setter of should stop adding at threshold.
    
    Parameters:
    
    shouldStopAddingAtThreshold - value to be set
    
    Returns:
    
    This object to make it easy to further update this object.
  - getShouldRetrySenderTillThresholdNotRecovered
```
public java.lang.Boolean getShouldRetrySenderTillThresholdNotRecovered()
```
    Is retry enabled while adding if threshold is reached.
    
    Returns:
    
    Retry enabled status
  - setShouldRetrySenderTillThresholdNotRecovered
```
public DynamicSettings<T> setShouldRetrySenderTillThresholdNotRecovered(java.lang.Boolean shouldPauseSenderTillThresholdNotRecovered)
```
    Setter of retry enabled while adding if threshold is reached.
    
    Parameters:
    
    shouldPauseSenderTillThresholdNotRecovered - value to be set
    
    Returns:
    
    This object for easy further modification
  - getWaitForRetryThresholdLimit
```
public java.lang.Long getWaitForRetryThresholdLimit()
```
    Wait time for retries.
    
    Returns:
    
    wait time for retries
  - setWaitForRetryThresholdLimit
```
public DynamicSettings<T> setWaitForRetryThresholdLimit(java.lang.Long waitForRetryThresholdLimit)
```
    Set wait time for retry.
    
    Parameters:
    
    waitForRetryThresholdLimit - Wait for retry value to be set
    
    Returns:
    
    This object for further modifications or use
  - getNumberOfRetriesToWait
```
public java.lang.Long getNumberOfRetriesToWait()
```
    Number of retries while adding at threshold.
    
    Returns:
    
    Number of retries
  - setNumberOfRetriesToWait
```
public DynamicSettings<T> setNumberOfRetriesToWait(java.lang.Long numberOfRetriesToWait)
```
    Setter of Number of retries while adding at threshold.
    
    Parameters:
    
    numberOfRetriesToWait - Number of retries
    
    Returns:
    
    This object for further modifications or use
  - adjust
```
public void adjust()
```
    This method handles the increase/decrease of consumers. A tuner calls this method periodically.
  - tryIfCanFreeUp
```
protected void tryIfCanFreeUp()
```
    It verifies if it can free up messages based on configurations and condition.
  - getCleaners
```
protected java.util.function.Consumer<java.util.Queue<T>>[] getCleaners()
```
    Get registered cleaners.
    
    Returns:
    
    Attached cleaners
  - increaseConsumerIfPossible
```
protected void increaseConsumerIfPossible()
```
    Increase consumers if high limit is reached and we still have number of consumers less than total current consumers.
  - decreaseConsumerIfPossible
```
protected void decreaseConsumerIfPossible()
```
    Decrease consumer if low limit attained back and we still have more consumers than minimum consumers.
  - getShouldThrowExceptionWhenThresholdAtAdd
```
public java.lang.Boolean getShouldThrowExceptionWhenThresholdAtAdd()
```
    Should throw exception when threshold reached in add process.
    
    Returns:
    
    Status of shouldThrowExceptionWhenThresholdAtAdd
  - setShouldThrowExceptionWhenThresholdAtAdd
```
public DynamicSettings<T> setShouldThrowExceptionWhenThresholdAtAdd(java.lang.Boolean shouldThrowExceptionWhenThresholdAtAdd)
```
    Setter of Should throw exception when threshold reached in add process.
    
    Parameters:
    
    shouldThrowExceptionWhenThresholdAtAdd - Value to be set
    
    Returns:
    
    This object for further use
  - addItemInQueue
```
public boolean addItemInQueue(T item)
```
    This method is responsible of adding data in queue. This method also retries and/or throws exception as per configuration. If addition is not allowed and no exception should be thrown, returns false.
    
    Parameters:
    
    item - Item to be added to queue
    
    Returns:
    
    True if successfully add item in queue
  - processAddItem
```
protected <K> boolean processAddItem(java.util.function.Consumer<K> consumer,
                                     K item)
```
    Checks if add item allowed and add the item to queue.
    
    Type Parameters:
    
    K - type of item to be added
    
    Parameters:
    
    consumer - Consumer which will actually add item in queue
    
    item - Item to be added
    
    Returns:
    
    true if successfully added to queue
  - addItemsInQueue
```
public boolean addItemsInQueue(java.util.Collection<T> list)
```
    This method is responsible of adding data in list in queue. This method also retries and/or throws exception as per configuration. If addition is not allowed and no exception should be thrown, returns false.
    
    Parameters:
    
    list - List containing data to be saved in queue
    
    Returns:
    
    True if successfully added to queue
  - addStillAllowed
```
protected boolean addStillAllowed()
```
    This method tells if we can still add in the queue.
    
    Returns:
    
    true if allowed
  - handleStopAddingAtThreshold
```
protected boolean handleStopAddingAtThreshold()
```
    This method is to handle in situation where we need to continue even when threshold reached. To continue, we can try again for given retries or directly return false. In case of waiting is allowed, this method will throw ThresholdReachedException in case all retries are over and still threshold is there.
    
    Returns:
    
    true if post retries items in queue lowers to less than threshold
  - waitForRetriesIfAny
```
protected boolean waitForRetriesIfAny()
```
    This method waits for configured number and for given time if allowed to wait. Post each retry, it checks if we threshold is now cooled off.
    
    Returns:
    
    true if we can add more data
  - addPreCleanHandler
```
public DynamicSettings<T> addPreCleanHandler(java.util.function.Consumer<java.util.Queue<T>> preCleanHandler)
```
    Add pre clean handler. This will be used if threshold of queued items is reached and is configured to clean queue post threshold. Before cleanup, the consumer attached will read all data queued. Removal from any consumer will mean removal from queue itself. One can add multiple pre clean handlers. They will be called one by one.
    
    Parameters:
    
    preCleanHandler - Hanlder to be called before clear
    
    Returns:
    
    Current object to make it more usable
  - shutdown
```
public void shutdown()
```
    Shutdown underlying queue.

Class DynamicSettings<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DynamicSettings

Method Detail

getQueue

setQueue

getShouldThrowExceptionPostRetry

setShouldThrowExceptionPostRetry

sleep

getMaxDirectConsumer

setMaxDirectConsumer

getMinDirectConsumer

setMinDirectConsumer

getMaxBatchConsumer

setMaxBatchConsumer

getMinBatchConsumer

setMinBatchConsumer

getHighLimitWhenToIncreaseConsumer

setHighLimitWhenToIncreaseConsumer

getLowLimitWhenToDecreseConsumer

setLowLimitWhenToDecreseConsumer

getThresholdWhenNoMoreItemsShouldBeHandled

setThresholdWhenNoMoreItemsShouldBeHandled

getShouldClearQueueAtThreshold

setShouldClearQueueAtThreshold

getShouldStopAddingAtThreshold

setShouldStopAddingAtThreshold

getShouldRetrySenderTillThresholdNotRecovered

setShouldRetrySenderTillThresholdNotRecovered

getWaitForRetryThresholdLimit

setWaitForRetryThresholdLimit

getNumberOfRetriesToWait

setNumberOfRetriesToWait

adjust

tryIfCanFreeUp

getCleaners

increaseConsumerIfPossible

decreaseConsumerIfPossible

getShouldThrowExceptionWhenThresholdAtAdd

setShouldThrowExceptionWhenThresholdAtAdd

addItemInQueue

processAddItem

addItemsInQueue

addStillAllowed

handleStopAddingAtThreshold

waitForRetriesIfAny

addPreCleanHandler

shutdown