Package akka.pattern

Class BackoffSupervisor$


  • public class BackoffSupervisor$
    extends java.lang.Object
    • Field Detail

      • MODULE$

        public static final BackoffSupervisor$ MODULE$
        Static reference to the singleton instance of this Scala object.
    • Constructor Detail

      • BackoffSupervisor$

        public BackoffSupervisor$()
    • Method Detail

      • props

        public Props props​(Props childProps,
                           java.lang.String childName,
                           scala.concurrent.duration.FiniteDuration minBackoff,
                           scala.concurrent.duration.FiniteDuration maxBackoff,
                           double randomFactor)
        Props for creating a BackoffSupervisor actor.

        Exceptions in the child are handled with the default supervision strategy, i.e. most exceptions will immediately restart the child. You can define another supervision strategy by using propsWithSupervisorStrategy(akka.actor.Props, java.lang.String, scala.concurrent.duration.FiniteDuration, scala.concurrent.duration.FiniteDuration, double, akka.actor.SupervisorStrategy).

        Parameters:
        childProps - the Props of the child actor that will be started and supervised
        childName - name of the child actor
        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.
        Returns:
        (undocumented)
      • props

        public Props props​(Props childProps,
                           java.lang.String childName,
                           scala.concurrent.duration.FiniteDuration minBackoff,
                           scala.concurrent.duration.FiniteDuration maxBackoff,
                           double randomFactor,
                           int maxNrOfRetries)
        Props for creating a BackoffSupervisor actor.

        Exceptions in the child are handled with the default supervision strategy, i.e. most exceptions will immediately restart the child. You can define another supervision strategy by using propsWithSupervisorStrategy(akka.actor.Props, java.lang.String, scala.concurrent.duration.FiniteDuration, scala.concurrent.duration.FiniteDuration, double, akka.actor.SupervisorStrategy).

        Parameters:
        childProps - the Props of the child actor that will be started and supervised
        childName - name of the child actor
        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.
        maxNrOfRetries - maximum number of attempts to restart the child actor. The supervisor will terminate itself after the maxNoOfRetries is reached. In order to restart infinitely pass in -1.
        Returns:
        (undocumented)
      • props

        public Props props​(Props childProps,
                           java.lang.String childName,
                           java.time.Duration minBackoff,
                           java.time.Duration maxBackoff,
                           double randomFactor)
        Props for creating a BackoffSupervisor actor.

        Exceptions in the child are handled with the default supervision strategy, i.e. most exceptions will immediately restart the child. You can define another supervision strategy by using propsWithSupervisorStrategy(akka.actor.Props, java.lang.String, scala.concurrent.duration.FiniteDuration, scala.concurrent.duration.FiniteDuration, double, akka.actor.SupervisorStrategy).

        Parameters:
        childProps - the Props of the child actor that will be started and supervised
        childName - name of the child actor
        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.
        Returns:
        (undocumented)
      • props

        public Props props​(Props childProps,
                           java.lang.String childName,
                           java.time.Duration minBackoff,
                           java.time.Duration maxBackoff,
                           double randomFactor,
                           int maxNrOfRetries)
        Props for creating a BackoffSupervisor actor.

        Exceptions in the child are handled with the default supervision strategy, i.e. most exceptions will immediately restart the child. You can define another supervision strategy by using propsWithSupervisorStrategy(akka.actor.Props, java.lang.String, scala.concurrent.duration.FiniteDuration, scala.concurrent.duration.FiniteDuration, double, akka.actor.SupervisorStrategy).

        Parameters:
        childProps - the Props of the child actor that will be started and supervised
        childName - name of the child actor
        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.
        maxNrOfRetries - maximum number of attempts to restart the child actor. The supervisor will terminate itself after the maxNoOfRetries is reached. In order to restart infinitely pass in -1.
        Returns:
        (undocumented)
      • propsWithSupervisorStrategy

        public Props propsWithSupervisorStrategy​(Props childProps,
                                                 java.lang.String childName,
                                                 scala.concurrent.duration.FiniteDuration minBackoff,
                                                 scala.concurrent.duration.FiniteDuration maxBackoff,
                                                 double randomFactor,
                                                 SupervisorStrategy strategy)
        Props for creating a BackoffSupervisor actor with a custom supervision strategy.

        Exceptions in the child are handled with the given supervisionStrategy. A Restart will perform a normal immediate restart of the child. A Stop will stop the child, but it will be started again after the back-off duration.

        Parameters:
        childProps - the Props of the child actor that will be started and supervised
        childName - name of the child actor
        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.
        strategy - the supervision strategy to use for handling exceptions in the child. As the BackoffSupervisor creates a separate actor to handle the backoff process, only a OneForOneStrategy makes sense here.
        Returns:
        (undocumented)
      • propsWithSupervisorStrategy

        public Props propsWithSupervisorStrategy​(Props childProps,
                                                 java.lang.String childName,
                                                 java.time.Duration minBackoff,
                                                 java.time.Duration maxBackoff,
                                                 double randomFactor,
                                                 SupervisorStrategy strategy)
        Props for creating a BackoffSupervisor actor with a custom supervision strategy.

        Exceptions in the child are handled with the given supervisionStrategy. A Restart will perform a normal immediate restart of the child. A Stop will stop the child, but it will be started again after the back-off duration.

        Parameters:
        childProps - the Props of the child actor that will be started and supervised
        childName - name of the child actor
        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.
        strategy - the supervision strategy to use for handling exceptions in the child. As the BackoffSupervisor creates a separate actor to handle the backoff process, only a OneForOneStrategy makes sense here.
        Returns:
        (undocumented)
      • calculateDelay

        public scala.concurrent.duration.FiniteDuration calculateDelay​(int restartCount,
                                                                       scala.concurrent.duration.FiniteDuration minBackoff,
                                                                       scala.concurrent.duration.FiniteDuration maxBackoff,
                                                                       double randomFactor)
        INTERNAL API

        Calculates an exponential back off delay.

        Parameters:
        restartCount - (undocumented)
        minBackoff - (undocumented)
        maxBackoff - (undocumented)
        randomFactor - (undocumented)
        Returns:
        (undocumented)