Repeater (Apache Brooklyn)

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

public class Repeater
extends java.lang.Object

Simple DSL to repeat a fragment of code periodically until a condition is satisfied. In its simplest case, it is passed two Closures / Callable - the first is executed, then the second. If the second closure returns false, the loop is repeated; if true, it 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.

It is configured in a fluent manner. For example, in Groovy:

 Repeater.create("Wait until the Frobnitzer is ready")
     .repeat {
         status = frobnitzer.getStatus()
     }
     .until {
         status == "Ready" || status == "Failed"
     }
     .limitIterationsTo(30)
     .run()

Or in Java:

 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()

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

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 as follows:
`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.
`static Repeater`	`create()`
`static Repeater`	`create(java.lang.String description)`
`Repeater`	`delayOnIteration(com.google.common.base.Function<? super java.lang.Integer,Duration> 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)`
`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()` Deprecated. since 0.7.0 this is no-op, as the repeater defaults to repeating nothing, simply remove the call, using just `Repeater.until(...)`.
`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.
`boolean`	`run()` Run the loop.
`ReferenceWithError<java.lang.Boolean>`	`runKeepingError()`
`void`	`runRequiringTrue()`
`Repeater`	`suppressWarnings()`
`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, com.google.common.base.Predicate<T> exitCondition)`

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

- 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()
```
    Deprecated. since 0.7.0 this is no-op, as the repeater defaults to repeating nothing, simply remove the call, using just Repeater.until(...).
    
    Sets the main body of the loop to be a no-op; useful if using until(Callable) instead
    
    Returns:
    this to aid coding in a fluent style.
  - 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.
  - 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
```
public Repeater every(groovy.time.Duration duration)
```
  - delayOnIteration
```
public Repeater delayOnIteration(com.google.common.base.Function<? super java.lang.Integer,Duration> 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 as follows:
    
    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,
                 com.google.common.base.Predicate<T> 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.
  - 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()
```

Class Repeater

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Repeater

Repeater

Method Detail

create

create

repeat

repeat

repeat

every

every

every

delayOnIteration

backoff

backoffTo

until

until

rethrowException

rethrowExceptionImmediately

suppressWarnings

limitIterationsTo

limitTimeTo

limitTimeTo

run

runRequiringTrue

runKeepingError

getDescription

getTimeLimit