Packages

object RetrySupport extends RetrySupport

Source
RetrySupport.scala
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RetrySupport
  2. RetrySupport
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @HotSpotIntrinsicCandidate() @native()
  6. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  8. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  9. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  10. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  11. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  12. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  13. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  14. def retry[T](attempt: () => Future[T], shouldRetry: (Throwable) => Boolean, 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, any 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 thrown.

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

    If an attempt fails, the exception from the failure will be passed to the 'shouldRetry' predicate; if the predicate evaluates 'true', a retry will be attempted. This allows for short-circuiting in situations where the retries cannot be expected to succeed (e.g. in a situation where the legality of arguments can only be determined asynchronously).

    Example usage:

    // retry with backoff

    protected val sendAndReceive: HttpRequest => Future[HttpResponse] = { (req) => ??? }
    private val sendReceiveRetry: HttpRequest => Future[HttpResponse] = (req: HttpRequest) => retry[HttpResponse](
      attempt = () => sendAndReceive(req),
      attempts = 10,
      delayFunction = attempted => Option(2.seconds * attempted),
      shouldRetry = ex => !ex.isInstanceOf[IllegalArgumentException]
    )
    Definition Classes
    RetrySupport
  15. 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 thrown.

    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)
    )
    Definition Classes
    RetrySupport
  16. 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
    )
    Definition Classes
    RetrySupport
  17. def retry[T](attempt: () => Future[T], shouldRetry: (Throwable) => Boolean, 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 made with a backoff time if the preceding attempt failed and the 'shouldRetry' predicate, when applied to the failure's exception evaluates to 'true'. If the predicate evaluates to 'false', the failed attempt will be returned. This allows for short-circuiting in situations where the retries cannot be expected to succeed (e.g. in a situation where the legality of arguments can only be determined asynchronously).

    If attempts are exhausted, the returned future is that of the last 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 def sendAndReceive(req: HttpRequest): Future[HttpResponse]
    private val sendReceiveRetry: HttpRequest => Future[HttpResponse] = (req: HttpRequest) => retry[HttpResponse](
      attempt = () => sendAndReceive(req),
      attempts = 10,
      minBackoff = 1.second,
      maxBackoff = 10.seconds,
      randomFactor = 0.2,
      shouldRetry = ex => !ex.isInstanceOf[IllegalArgumentException])
    Definition Classes
    RetrySupport
  18. 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.

    Definition Classes
    RetrySupport
  19. def retry[T](attempt: () => Future[T], shouldRetry: (Throwable) => Boolean, 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 preceding attempt failed and the 'shouldRetry' predicate, when applied to the failure's exception evaluates to 'true'. If the predicate evaluates to 'false', the failed attempt will be returned. This allows for short-circuiting in situations where the retries cannot be expected to succeed (e.g. in a situation where the legality of arguments can only be determined asynchronously).

    If attempts are exhausted, the returned future is the that of the last 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,
      shouldRetry = { (ex) => ex.isInstanceOf[IllegalArgumentException] })
    Definition Classes
    RetrySupport
  20. 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)
    Definition Classes
    RetrySupport
  21. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  22. def toString(): String
    Definition Classes
    AnyRef → Any
  23. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  24. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  25. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

    (Since version 9)

Inherited from RetrySupport

Inherited from AnyRef

Inherited from Any

Ungrouped