trait RetrySupport extends AnyRef
This trait provides the retry utility function
- Source
- RetrySupport.scala
- Alphabetic
- By Inheritance
- RetrySupport
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- Implicit
- This member is added by an implicit conversion from RetrySupport toany2stringadd[RetrySupport] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
- def ->[B](y: B): (RetrySupport, B)
- Implicit
- This member is added by an implicit conversion from RetrySupport toArrowAssoc[RetrySupport] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @HotSpotIntrinsicCandidate() @native()
- def ensuring(cond: (RetrySupport) => Boolean, msg: => Any): RetrySupport
- Implicit
- This member is added by an implicit conversion from RetrySupport toEnsuring[RetrySupport] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: (RetrySupport) => Boolean): RetrySupport
- Implicit
- This member is added by an implicit conversion from RetrySupport toEnsuring[RetrySupport] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean, msg: => Any): RetrySupport
- Implicit
- This member is added by an implicit conversion from RetrySupport toEnsuring[RetrySupport] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean): RetrySupport
- Implicit
- This member is added by an implicit conversion from RetrySupport toEnsuring[RetrySupport] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- def retry[T](attempt: () => Future[T], shouldRetry: (T, 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.
When the future is completed, the
shouldRetry
predicate is always been invoked with the result (ornull
if none) and the exception (ornull
if none). If theshouldRetry
predicate returns true, then a new attempt is made, each subsequent attempt will be made after the 'delay' return bydelayFunction
(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) )
- 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
- 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 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) )
- def retry[T](attempt: () => Future[T], shouldRetry: (T, Throwable) => Boolean, 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.
When the future is completed, the
shouldRetry
predicate is always been invoked with the result (ornull
if none) and the exception (ornull
if none). If theshouldRetry
predicate returns true, then a new attempt is made, each subsequent attempt will be made after the 'delay' return bydelayFunction
(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 )
- 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
- 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 (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 )
- def retry[T](attempt: () => Future[T], shouldRetry: (T, 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.
When the future is completed, the
shouldRetry
predicate is always been invoked with the result (ornull
if none) and the exception (ornull
if none). If theshouldRetry
predicate returns true, then a new attempt is made, each subsequent attempt will be made after the 'delay' return bydelayFunction
(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 )
- 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 to20%
delay. In order to skip this additional delay pass in0
.- ec
the execution context
- scheduler
the scheduler for scheduling a delay
- returns
the result future which maybe retried
- Since
1.1.0
- 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 (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 )
- 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 to20%
delay. In order to skip this additional delay pass in0
.
- def retry[T](attempt: () => Future[T], shouldRetry: (T, 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.
When the future is completed, the
shouldRetry
predicate is always been invoked with the result (ornull
if none) and the exception (ornull
if none). If theshouldRetry
predicate returns true, then a new attempt is made, each subsequent attempt will be made after the 'delay' return bydelayFunction
(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)
- 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
- 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 (i.e. not touch unsafe mutable state).
Example usage:
def possiblyFailing(): Future[Something] = ??? val withRetry: Future[Something] = retry(attempt = possiblyFailing, attempts = 10)
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated
(Since version 9)
- def formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from RetrySupport toStringFormat[RetrySupport] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.12.16) Use
formatString.format(value)
instead ofvalue.formatted(formatString)
, or use thef""
string interpolator. In Java 15 and later,formatted
resolves to the new method in String which has reversed parameters.
- def →[B](y: B): (RetrySupport, B)
- Implicit
- This member is added by an implicit conversion from RetrySupport toArrowAssoc[RetrySupport] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.