Package org.apache.pekko.pattern

Interface RetrySupport

All Known Implementing Classes:
RetrySupport$
public interface RetrySupport
This trait provides the retry utility function

  • Method Summary

    Modifier and Type
    Method
    Description
    <T> scala.concurrent.Future<T>
    retry(scala.Function0<scala.concurrent.Future<T>> attempt, int attempts, scala.concurrent.duration.FiniteDuration minBackoff, scala.concurrent.duration.FiniteDuration maxBackoff, double randomFactor, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
    Given a function from Unit to Future, returns an internally retrying Future.
    <T> scala.concurrent.Future<T>
    retry(scala.Function0<scala.concurrent.Future<T>> attempt, int attempts, scala.concurrent.duration.FiniteDuration delay, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
    Given a function from Unit to Future, returns an internally retrying Future.
    <T> scala.concurrent.Future<T>
    retry(scala.Function0<scala.concurrent.Future<T>> attempt, int attempts, scala.concurrent.ExecutionContext ec)
    Given a function from Unit to Future, returns an internally retrying Future.
    <T> scala.concurrent.Future<T>
    retry(scala.Function0<scala.concurrent.Future<T>> attempt, int attempts, scala.Function1<Object,scala.Option<scala.concurrent.duration.FiniteDuration>> delayFunction, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
    Given a function from Unit to Future, returns an internally retrying Future.
    <T> scala.concurrent.Future<T>
    retry(scala.Function0<scala.concurrent.Future<T>> attempt, scala.Function2<T,Throwable,Object> shouldRetry, int attempts, scala.concurrent.duration.FiniteDuration minBackoff, scala.concurrent.duration.FiniteDuration maxBackoff, double randomFactor, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
    Given a function from Unit to Future, returns an internally retrying Future.
    <T> scala.concurrent.Future<T>
    retry(scala.Function0<scala.concurrent.Future<T>> attempt, scala.Function2<T,Throwable,Object> shouldRetry, int attempts, scala.concurrent.duration.FiniteDuration delay, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
    Given a function from Unit to Future, returns an internally retrying Future.
    <T> scala.concurrent.Future<T>
    retry(scala.Function0<scala.concurrent.Future<T>> attempt, scala.Function2<T,Throwable,Object> shouldRetry, int attempts, scala.concurrent.ExecutionContext ec)
    Given a function from Unit to Future, returns an internally retrying Future.
    <T> scala.concurrent.Future<T>
    retry(scala.Function0<scala.concurrent.Future<T>> attempt, scala.Function2<T,Throwable,Object> shouldRetry, int attempts, scala.Function1<Object,scala.Option<scala.concurrent.duration.FiniteDuration>> delayFunction, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
    Given a function from Unit to Future, returns an internally retrying Future.

  • Method Details

    • retry

      <T> scala.concurrent.Future<T> retry(scala.Function0<scala.concurrent.Future<T>> attempt, int attempts, scala.concurrent.ExecutionContext ec)
      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)

    • retry

      <T> scala.concurrent.Future<T> retry(scala.Function0<scala.concurrent.Future<T>> attempt, scala.Function2<T,Throwable,Object> shouldRetry, int attempts, scala.concurrent.ExecutionContext ec)
      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 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)

      Parameters:
      attempt - the function to be attempted
      shouldRetry - the predicate to determine if the attempt should be retried
      attempts - the maximum number of attempts
      ec - the execution context
      Returns:
      the result future which maybe retried

      Since:
      1.1.0

    • retry

      <T> scala.concurrent.Future<T> retry(scala.Function0<scala.concurrent.Future<T>> attempt, int attempts, scala.concurrent.duration.FiniteDuration minBackoff, scala.concurrent.duration.FiniteDuration maxBackoff, double randomFactor, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
      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
 )

      Parameters:
      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.

    • retry

      <T> scala.concurrent.Future<T> retry(scala.Function0<scala.concurrent.Future<T>> attempt, scala.Function2<T,Throwable,Object> shouldRetry, int attempts, scala.concurrent.duration.FiniteDuration minBackoff, scala.concurrent.duration.FiniteDuration maxBackoff, double randomFactor, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
      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 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
 )

      Parameters:
      attempt - the function to be attempted
      shouldRetry - the predicate to determine if the attempt should be retried
      attempts - the maximum number of attempts
      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.
      ec - the execution context
      scheduler - the scheduler for scheduling a delay
      Returns:
      the result future which maybe retried

      Since:
      1.1.0

    • retry

      <T> scala.concurrent.Future<T> retry(scala.Function0<scala.concurrent.Future<T>> attempt, int attempts, scala.concurrent.duration.FiniteDuration delay, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
      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
 )

    • retry

      <T> scala.concurrent.Future<T> retry(scala.Function0<scala.concurrent.Future<T>> attempt, scala.Function2<T,Throwable,Object> shouldRetry, int attempts, scala.concurrent.duration.FiniteDuration delay, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
      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 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
 )

      Parameters:
      attempt - the function to be attempted
      shouldRetry - the predicate to determine if the attempt should be retried
      attempts - the maximum number of attempts
      delay - the delay duration
      ec - the execution context
      scheduler - the scheduler for scheduling a delay
      Returns:
      the result future which maybe retried

      Since:
      1.1.0

    • retry

      <T> scala.concurrent.Future<T> retry(scala.Function0<scala.concurrent.Future<T>> attempt, int attempts, scala.Function1<Object,scala.Option<scala.concurrent.duration.FiniteDuration>> delayFunction, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
      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 a 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)
 )

    • retry

      <T> scala.concurrent.Future<T> retry(scala.Function0<scala.concurrent.Future<T>> attempt, scala.Function2<T,Throwable,Object> shouldRetry, int attempts, scala.Function1<Object,scala.Option<scala.concurrent.duration.FiniteDuration>> delayFunction, scala.concurrent.ExecutionContext ec, Scheduler scheduler)
      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 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 a 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)
 )

      Parameters:
      attempt - the function to be attempted
      shouldRetry - the predicate to determine if the attempt should be retried
      attempts - the maximum number of attempts
      delayFunction - the function to generate the next delay duration, None for no delay
      ec - the execution context
      scheduler - the scheduler for scheduling a delay
      Returns:
      the result future which maybe retried

      Since:
      1.1.0