Given a function from Unit to Future, returns an internally retrying Future.

When the future is completed, the shouldRetry predicate is always been invoked with the result (or null if none) and the exception (or null if none). If the shouldRetry predicate returns true, then a new attempt is made, each subsequent attempt will be made after the 'delay' return by delayFunction (the input next attempt count start from 1). Returns scala.None for no delay.

A scheduler (eg context.system.scheduler) must be provided to delay each retry. You could provide a function to generate the next delay duration after first attempt, this function should never return null, otherwise an java.lang.IllegalArgumentException will be through.

If attempts are exhausted the returned future is simply the result of invoking attempt. Note that the attempt function will be invoked on the given execution context for subsequent tries and therefore must be thread safe (i.e. not touch unsafe mutable state).

Example usage:

//retry with back off

protected val sendAndReceive: HttpRequest => Future[HttpResponse]
protected val shouldRetry: (HttpResponse, Throwable) => throwable ne null
private val sendReceiveRetry: HttpRequest => Future[HttpResponse] = (req: HttpRequest) => retry[HttpResponse](
  attempt = () => sendAndReceive(req),
  shouldRetry,
  attempts = 10,
  delayFunction = attempted => Option(2.seconds * attempted)
)

Given a function from Unit to Future, returns an internally retrying Future. The first attempt will be made immediately, each subsequent attempt will be made after the 'delay' return by delayFunction (the input next attempt count start from 1). Returns scala.None for no delay.

A scheduler (eg context.system.scheduler) must be provided to delay each retry. You could provide a function to generate the next delay duration after first attempt, this function should never return null, otherwise an java.lang.IllegalArgumentException will be through.

If attempts are exhausted the returned future is simply the result of invoking attempt. Note that the attempt function will be invoked on the given execution context for subsequent tries and therefore must be thread safe (i.e. not touch unsafe mutable state).

Example usage:

//retry with back off

protected val sendAndReceive: HttpRequest => Future[HttpResponse]
private val sendReceiveRetry: HttpRequest => Future[HttpResponse] = (req: HttpRequest) => retry[HttpResponse](
  attempt = () => sendAndReceive(req),
  attempts = 10,
  delayFunction = attempted => Option(2.seconds * attempted)
)

Given a function from Unit to Future, returns an internally retrying Future.

When the future is completed, the shouldRetry predicate is always been invoked with the result (or null if none) and the exception (or null if none). If the shouldRetry predicate returns true, then a new attempt is made, each subsequent attempt will be made after the 'delay' return by delayFunction (the input next attempt count start from 1). Returns scala.None for no delay.

If attempts are exhausted the returned future is simply the result of invoking attempt. Note that the attempt function will be invoked on the given execution context for subsequent tries and therefore must be thread safe (i.e. not touch unsafe mutable state).

Example usage:

protected val sendAndReceive: HttpRequest => Future[HttpResponse]
protected val shouldRetry: (HttpResponse, Throwable) => throwable ne null
private val sendReceiveRetry: HttpRequest => Future[HttpResponse] = (req: HttpRequest) => retry[HttpResponse](
  attempt = () => sendAndReceive(req),
  shouldRetry,
  attempts = 10,
  delay = 2.seconds
)

Given a function from Unit to Future, returns an internally retrying Future. The first attempt will be made immediately, each subsequent attempt will be made after 'delay'. A scheduler (eg context.system.scheduler) must be provided to delay each retry.

If attempts are exhausted the returned future is simply the result of invoking attempt. Note that the attempt function will be invoked on the given execution context for subsequent tries and therefore must be thread safe (i.e. not touch unsafe mutable state).

Example usage:

protected val sendAndReceive: HttpRequest => Future[HttpResponse]
private val sendReceiveRetry: HttpRequest => Future[HttpResponse] = (req: HttpRequest) => retry[HttpResponse](
  attempt = () => sendAndReceive(req),
  attempts = 10,
  delay = 2.seconds
)

Given a function from Unit to Future, returns an internally retrying Future.

When the future is completed, the shouldRetry predicate is always been invoked with the result (or null if none) and the exception (or null if none). If the shouldRetry predicate returns true, then a new attempt is made, each subsequent attempt will be made after the 'delay' return by delayFunction (the input next attempt count start from 1). Returns scala.None for no delay.

If attempts are exhausted the returned future is simply the result of invoking attempt. Note that the attempt function will be invoked on the given execution context for subsequent tries and therefore must be thread safe (i.e. not touch unsafe mutable state).

Example usage:

protected val sendAndReceive: HttpRequest => Future[HttpResponse]
protected val shouldRetry: (HttpResponse, Throwable) => throwable ne null
private val sendReceiveRetry: HttpRequest => Future[HttpResponse] = (req: HttpRequest) => retry[HttpResponse](
  attempt = () => sendAndReceive(req),
  shouldRetry,
  attempts = 10,
  minBackoff = 1.seconds,
  maxBackoff = 2.seconds,
  randomFactor = 0.5
)

Given a function from Unit to Future, returns an internally retrying Future. The first attempt will be made immediately, each subsequent attempt will be made with a backoff time, if the previous attempt failed.

If attempts are exhausted the returned future is simply the result of invoking attempt. Note that the attempt function will be invoked on the given execution context for subsequent tries and therefore must be thread safe (i.e. not touch unsafe mutable state).

Example usage:

protected val sendAndReceive: HttpRequest => Future[HttpResponse]
private val sendReceiveRetry: HttpRequest => Future[HttpResponse] = (req: HttpRequest) => retry[HttpResponse](
  attempt = () => sendAndReceive(req),
  attempts = 10,
  minBackoff = 1.seconds,
  maxBackoff = 2.seconds,
  randomFactor = 0.5
)

Given a function from Unit to Future, returns an internally retrying Future.

When the future is completed, the shouldRetry predicate is always been invoked with the result (or null if none) and the exception (or null if none). If the shouldRetry predicate returns true, then a new attempt is made, each subsequent attempt will be made after the 'delay' return by delayFunction (the input next attempt count start from 1). Returns scala.None for no delay.

If attempts are exhausted the returned future is simply the result of invoking attempt. Note that the attempt function will be invoked on the given execution context for subsequent tries and therefore must be thread safe (i.e. not touch unsafe mutable state).

Example usage:

def possiblyFailing(): Future[Something] = ???
val shouldRetry: (Something, Throwable) => throwable ne null
val withRetry: Future[Something] = retry(attempt = possiblyFailing, shouldRetry, attempts = 10)

Given a function from Unit to Future, returns an internally retrying Future. The first attempt will be made immediately, each subsequent attempt will be made immediately if the previous attempt failed.

If attempts are exhausted the returned future is simply the result of invoking attempt. Note that the attempt function will be invoked on the given execution context for subsequent tries and therefore must be thread safe (i.e. not touch unsafe mutable state).

Example usage:

def possiblyFailing(): Future[Something] = ???
val withRetry: Future[Something] = retry(attempt = possiblyFailing, attempts = 10)