Packages

trait RetrySupport extends AnyRef

This trait provides the retry utility function

Source
RetrySupport.scala
Linear Supertypes
AnyRef, Any
Known Subclasses
RetrySupport
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RetrySupport
  2. AnyRef
  3. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. def retry[T](attempt: () => Future[T], attempts: Int, delayFunction: (Int) => Option[FiniteDuration])(implicit ec: ExecutionContext, scheduler: Scheduler): Future[T]

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

    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 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 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 (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)
)
  2. def retry[T](attempt: () => Future[T], attempts: Int, delay: FiniteDuration)(implicit ec: ExecutionContext, scheduler: Scheduler): Future[T]

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

    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 (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
)
  3. def retry[T](attempt: () => Future[T], attempts: Int, minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double)(implicit ec: ExecutionContext, scheduler: Scheduler): Future[T]

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

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

    minimum (initial) duration until the child actor will started again, if it is terminated

    maxBackoff

    the exponential back-off is capped to this duration

    randomFactor

    after calculation of the exponential back-off an additional random delay based on this factor is added, e.g. 0.2 adds up to 20% delay. In order to skip this additional delay pass in 0.

  4. def retry[T](attempt: () => Future[T], attempts: Int)(implicit ec: ExecutionContext): Future[T]

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

    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 (not touch unsafe mutable state).

    Example usage:

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