again.core — opploans/again 0.2.0

additive-strategy clj

(additive-strategy increment)

(additive-strategy initial-delay increment)

Returns a retry strategy where, after the initial-delay (ms), the delay increases by increment (ms) after each retry. The single argument version uses the given increment as both the initial delay and the increment.

clamp-delay clj

(clamp-delay delay retry-strategy)

Replace delays in the strategy that are larger than delay with delay.

constant-strategy clj

(constant-strategy delay)

Generates a retry strategy with a constant delay (ms) between attempts, ie the delay is the same for each retry.

immediate-strategy clj

(immediate-strategy)

Returns a retry strategy that retries without any delay.

max-delay clj

(max-delay delay retry-strategy)

Stop retrying once the a delay is larger than delay.

max-duration clj

(max-duration timeout retry-strategy)

Stop retrying once the sum of past delays exceeds timeout (ms). Note: the sum considers only the delays in the strategy, any time spent on executing the operation etc is not included (that is, we're not measuring wallclock time here).

max-retries clj

(max-retries n retry-strategy)

Stop retrying after n retries.

multiplicative-strategy clj

(multiplicative-strategy initial-delay delay-multiplier)

Returns a retry strategy with exponentially increasing delays, ie each previous delay is multiplied by delay-multiplier to generate the next delay.

randomize-strategy clj

(randomize-strategy rand-factor retry-strategy)

Returns a retry strategy where all the delays have been scaled by a random number between [1 - rand-factor, 1 + rand-factor]. rand-factor must be greater than 0 and less than 1.

stop-strategy clj

(stop-strategy)

A no-retries policy.

with-retries clj macro

(with-retries strategy-or-options & body)

Try executing body. If body throws an Exception, retry according to the retry strategy.

A retry strategy is a seq of delays: with-retries will sleep the duration of the delay (in ms) before each retry. The total number of attempts is the number of elements in the strategy plus one. A simple retry stategy would be: [100 100 100 100] which results in the operation being retried four times, for a total of five attempts, with 100ms sleeps in between attempts. Note: that infinite strategies are supported, but maybe not encouraged…

Strategies can be built with the provided builder fns, eg linear-strategy, and modified with the provided manipulator fns, eg clamp-delay, but you can also create any custom seq of delays that suits your use case.

Instead of a simple delay sequence, you can also pass in the following type of options map:

{:again.core/callback <fn> :again.core/user-context <anything, but probably an atom> :again.core/exception-predicate <fn> :again.core/strategy <delay strategy>}

:again.core/callback is a callback function that is called after each attempt. :again.core/user-context is an opaque value that is passed to the callback function as an argument. And :again.core/strategy is the sequence of delays.

The callback function is called with the following type of map as its only argument:

{:again.core/attempts <the number of attempts thus far> :again.core/exception <the exception thrown by body> :again.core/slept <the sum of all delays thus far> :again.core/status <the result of the last attempt: :success, :failure, or :retry :again.core/user-context <the user context from the options map>}

The exception-predicate is a function that is called with an exception. It can return truthy or falsey. If truthy, the exception is retried. This function defaults to (constantly true)

with-retries* clj

(with-retries* strategy-or-options f)