Repeater (Apache Brooklyn)

java.lang.Object
- org.apache.brooklyn.util.repeat.Repeater

All Implemented Interfaces:

java.util.concurrent.Callable<java.lang.Boolean>
```
public class Repeater
extends java.lang.Object
implements java.util.concurrent.Callable<java.lang.Boolean>
```
Simple mechanism to repeat an operation periodically until a condition is satisfied.
In its simplest case it is passed two Callable objects, the operation and the condition which are executed in that order. This execution is repeated until the condition returns true, when the loop finishes. Further customization can be applied to set the period between loops and place a maximum limit on how long the loop should run for, as well as other timing and delay properties.
```
 Repeater.create("Wait until the Frobnitzer is ready")
     .until(new Callable<Boolean>() {
              public Boolean call() {
                  String status = frobnitzer.getStatus()
                  return "Ready".equals(status) || "Failed".equals(status);
              }})
     .limitIterationsTo(30)
     .run()
 
```
The

Field Summary

Fields
Modifier and Type Field and Description

static Duration DEFAULT_REAL_QUICK_PERIOD
A small initial duration that something should wait between repeats, e.g.

Fields
Modifier and Type	Field and Description
`static Duration`	`DEFAULT_REAL_QUICK_PERIOD` A small initial duration that something should wait between repeats, e.g.

Constructor Summary

Constructors
Constructor and Description

Repeater()

Repeater(java.lang.String description)
Construct a new instance of Repeater.

Constructors
Constructor and Description
`Repeater()`
`Repeater(java.lang.String description)` Construct a new instance of Repeater.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Repeater`	`backoff(Duration initialDelay, double multiplier, Duration finalDelay)` Sets the `#delayOnIteration(Function)` function to be an exponential backoff.
`Repeater`	`backoffTo(Duration finalDelay)` convenience to start with a 10ms delay and exponentially back-off at a rate of 1.2 up to a max per-iteration delay as supplied here.
`java.lang.Boolean`	`call()`
`static Repeater`	`create()`
`static Repeater`	`create(java.lang.String description)`
`Repeater`	`delayOnIteration(<any> delayFunction)` Sets a function which determines how long to delay on a given iteration between checks, with 0 being mapped to the initial delay (after the initial check)
`Repeater`	`every(Duration duration)` Set how long to wait between loop iterations, as a constant function in `delayOnIteration`
`Repeater`	`every(groovy.time.Duration duration)` Deprecated. since 0.11.0; explicit groovy utilities/support will be deleted (instead use `every(Duration)`).
`Repeater`	`every(long period, java.util.concurrent.TimeUnit unit)` Set how long to wait between loop iterations.
`java.lang.String`	`getDescription()`
`Duration`	`getTimeLimit()`
`Repeater`	`limitIterationsTo(int iterationLimit)` Set the maximum number of iterations.
`Repeater`	`limitTimeTo(Duration duration)` Set the amount of time to wait for the condition.
`Repeater`	`limitTimeTo(long deadline, java.util.concurrent.TimeUnit unit)`
`Repeater`	`repeat(java.util.concurrent.Callable<?> body)` Sets the main body of the loop.
`Repeater`	`repeat(java.lang.Runnable body)` Sets the main body of the loop.
`Repeater`	`rethrowException()` If the exit condition check throws an exception, it will be recorded and the last exception will be thrown on failure.
`Repeater`	`rethrowExceptionImmediately()` If the repeated body or the exit condition check throws an exception, then propagate that exception immediately.
`Repeater`	`rethrowExceptionImmediately(<any> val)`
`boolean`	`run()` Run the loop.
`ReferenceWithError<java.lang.Boolean>`	`runKeepingError()`
`void`	`runRequiringTrue()`
`Repeater`	`suppressWarnings()`
`Repeater`	`threaded()` Use a new thread for every iteration of the loop.
`Repeater`	`threaded(java.util.concurrent.ExecutorService executor)` Use the passed in `executor` to generate threads for every iteration of the loop.
`<T> Repeater`	`until(<any> supplier, <any> exitCondition)`
`Repeater`	`until(java.util.concurrent.Callable<java.lang.Boolean> exitCondition)` Set code fragment that tests if the loop has completed.
`<T> Repeater`	`until(T target, <any> exitCondition)`

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

- Field Detail
  - DEFAULT_REAL_QUICK_PERIOD
```
public static final Duration DEFAULT_REAL_QUICK_PERIOD
```
    A small initial duration that something should wait between repeats, e.g. when doing backoffTo(Duration).
    Chosen to be small enough that a user won't notice at all, but we're not going to be chewing up CPU while waiting.
- Constructor Detail
  - Repeater
```
public Repeater()
```
  - Repeater
```
public Repeater(java.lang.String description)
```
    Construct a new instance of Repeater.
    
    Parameters:
    
    description - a description of the operation that will appear in debug logs.
- Method Detail
  - create
```
public static Repeater create()
```
  - create
```
public static Repeater create(java.lang.String description)
```
  - repeat
```
public Repeater repeat(java.lang.Runnable body)
```
    Sets the main body of the loop.
    
    Parameters:
    
    body - a closure or other Runnable that is executed in the main body of the loop.
    
    Returns:
    
    this to aid coding in a fluent style.
  - repeat
```
public Repeater repeat(java.util.concurrent.Callable<?> body)
```
    Sets the main body of the loop.
    
    Parameters:
    
    body - a closure or other Callable that is executed in the main body of the loop.
    
    Returns:
    
    this to aid coding in a fluent style.
  - threaded
```
public Repeater threaded()
```
    Use a new thread for every iteration of the loop.
    
    Returns:
    
    this to aid coding in a fluent style.
  - threaded
```
public Repeater threaded(java.util.concurrent.ExecutorService executor)
```
    Use the passed in executor to generate threads for every iteration of the loop. Because the executor is externally managed it will not be shut down by us when we finish.
    
    Parameters:
    
    executor - an externally managed ExecutorService to use when creating threads.
    
    Returns:
    
    this to aid coding in a fluent style.
    
    See Also:
    
    #threaded()}
  - every
```
public Repeater every(long period,
                      java.util.concurrent.TimeUnit unit)
```
    Set how long to wait between loop iterations.
    
    Parameters:
    
    period - how long to wait between loop iterations.
    
    unit - the unit of measurement of the period.
    
    Returns:
    
    this to aid coding in a fluent style.
  - every
```
public Repeater every(Duration duration)
```
    Set how long to wait between loop iterations, as a constant function in delayOnIteration
  - every
```
@Deprecated
public Repeater every(groovy.time.Duration duration)
```
    Deprecated. since 0.11.0; explicit groovy utilities/support will be deleted (instead use every(Duration)).
  - delayOnIteration
```
public Repeater delayOnIteration(<any> delayFunction)
```
    Sets a function which determines how long to delay on a given iteration between checks, with 0 being mapped to the initial delay (after the initial check)
  - backoff
```
public Repeater backoff(Duration initialDelay,
                        double multiplier,
                        @Nullable
                        Duration finalDelay)
```
    Sets the #delayOnIteration(Function) function to be an exponential backoff.
    
    Parameters:
    
    initialDelay - the delay on the first iteration, after the initial check
    
    multiplier - the rate at which to increase the loop delay, must be >= 1
    
    finalDelay - an optional cap on the loop delay
  - backoffTo
```
public Repeater backoffTo(Duration finalDelay)
```
    convenience to start with a 10ms delay and exponentially back-off at a rate of 1.2 up to a max per-iteration delay as supplied here. 1.2 chosen because it decays nicely, going from 10ms to 1s in approx 25 iterations totalling 5s elapsed time.
  - until
```
public Repeater until(java.util.concurrent.Callable<java.lang.Boolean> exitCondition)
```
    Set code fragment that tests if the loop has completed.
    
    Parameters:
    
    exitCondition - a closure or other Callable that returns a boolean. If this code returns true then the loop will stop executing.
    
    Returns:
    
    this to aid coding in a fluent style.
  - until
```
public <T> Repeater until(T target,
                          <any> exitCondition)
```
  - until
```
public <T> Repeater until(<any> supplier,
                          <any> exitCondition)
```
  - rethrowException
```
public Repeater rethrowException()
```
    If the exit condition check throws an exception, it will be recorded and the last exception will be thrown on failure.
    
    Returns:
    
    this to aid coding in a fluent style.
  - rethrowExceptionImmediately
```
public Repeater rethrowExceptionImmediately()
```
    If the repeated body or the exit condition check throws an exception, then propagate that exception immediately.
    
    Returns:
    
    this to aid coding in a fluent style.
  - rethrowExceptionImmediately
```
public Repeater rethrowExceptionImmediately(<any> val)
```
  - suppressWarnings
```
public Repeater suppressWarnings()
```
  - limitIterationsTo
```
public Repeater limitIterationsTo(int iterationLimit)
```
    Set the maximum number of iterations. The loop will exit if the condition has not been satisfied after this number of iterations.
    
    Parameters:
    
    iterationLimit - the maximum number of iterations.
    
    Returns:
    
    this to aid coding in a fluent style.
  - limitTimeTo
```
public Repeater limitTimeTo(long deadline,
                            java.util.concurrent.TimeUnit unit)
```
    Parameters:
    
    deadline - the time that the loop should wait.
    
    unit - the unit of measurement of the period.
    
    Returns:
    
    this to aid coding in a fluent style.
    
    See Also:
    
    limitTimeTo(Duration)
  - limitTimeTo
```
public Repeater limitTimeTo(Duration duration)
```
    Set the amount of time to wait for the condition. The repeater will wait at least this long for the condition to be true, and will exit soon after even if the condition is false.
  - run
```
public boolean run()
```
    Run the loop.
    
    Returns:
    
    true if the exit condition was satisfied; false if the loop terminated for any other reason.
  - runRequiringTrue
```
public void runRequiringTrue()
```
  - runKeepingError
```
public ReferenceWithError<java.lang.Boolean> runKeepingError()
```
  - getDescription
```
public java.lang.String getDescription()
```
  - getTimeLimit
```
public Duration getTimeLimit()
```
  - call
```
public java.lang.Boolean call()
                       throws java.lang.Exception
```
    Specified by:
    
    call in interface java.util.concurrent.Callable<java.lang.Boolean>
    
    Throws:
    
    java.lang.Exception

Class Repeater

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_REAL_QUICK_PERIOD

Constructor Detail

Repeater

Repeater

Method Detail

create

create

repeat

repeat

threaded

threaded

every

every

every

delayOnIteration

backoff

backoffTo

until

until

until

rethrowException

rethrowExceptionImmediately

rethrowExceptionImmediately

suppressWarnings

limitIterationsTo

limitTimeTo

limitTimeTo

run

runRequiringTrue

runKeepingError

getDescription

getTimeLimit

call