Package akka.pattern

Class BackoffSupervisor

  • All Implemented Interfaces:
    Actor, ActorLogging, HandleBackoff

    public final class BackoffSupervisor
    extends java.lang.Object
    implements Actor, HandleBackoff, ActorLogging
    Back-off supervisor that stops and starts a child actor using a back-off algorithm when the child actor stops. This back-off supervisor is created by using akka.pattern.BackoffSupervisor.props with Backoff.onStop.
    • Constructor Detail

      • BackoffSupervisor

        public BackoffSupervisor​(Props childProps,
                                 java.lang.String childName,
                                 scala.concurrent.duration.FiniteDuration minBackoff,
                                 scala.concurrent.duration.FiniteDuration maxBackoff,
                                 BackoffReset reset,
                                 double randomFactor,
                                 SupervisorStrategy strategy,
                                 scala.Option<java.lang.Object> replyWhileStopped,
                                 scala.Option<scala.Function1<java.lang.Object,​java.lang.Object>> finalStopMessage)
      • BackoffSupervisor

        public BackoffSupervisor​(Props childProps,
                                 java.lang.String childName,
                                 scala.concurrent.duration.FiniteDuration minBackoff,
                                 scala.concurrent.duration.FiniteDuration maxBackoff,
                                 BackoffReset reset,
                                 double randomFactor,
                                 SupervisorStrategy strategy,
                                 scala.Option<java.lang.Object> replyWhileStopped)
      • BackoffSupervisor

        public BackoffSupervisor​(Props childProps,
                                 java.lang.String childName,
                                 scala.concurrent.duration.FiniteDuration minBackoff,
                                 scala.concurrent.duration.FiniteDuration maxBackoff,
                                 double randomFactor,
                                 SupervisorStrategy supervisorStrategy)
      • BackoffSupervisor

        public BackoffSupervisor​(Props childProps,
                                 java.lang.String childName,
                                 scala.concurrent.duration.FiniteDuration minBackoff,
                                 scala.concurrent.duration.FiniteDuration maxBackoff,
                                 double randomFactor)
    • Method Detail

      • props

        public static 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 static 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 static 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 static 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 static 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 static 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 static 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)
      • sender

        public static final ActorRef sender()
      • aroundReceive

        protected static void aroundReceive​(scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> receive,
                                            java.lang.Object msg)
      • aroundPreStart

        protected static void aroundPreStart()
      • aroundPostStop

        protected static void aroundPostStop()
      • aroundPreRestart

        protected static void aroundPreRestart​(java.lang.Throwable reason,
                                               scala.Option<java.lang.Object> message)
      • aroundPostRestart

        protected static void aroundPostRestart​(java.lang.Throwable reason)
      • preStart

        public static void preStart()
                             throws java.lang.Exception
        Throws:
        java.lang.Exception
      • postStop

        public static void postStop()
                             throws java.lang.Exception
        Throws:
        java.lang.Exception
      • preRestart

        public static void preRestart​(java.lang.Throwable reason,
                                      scala.Option<java.lang.Object> message)
                               throws java.lang.Exception
        Throws:
        java.lang.Exception
      • postRestart

        public static void postRestart​(java.lang.Throwable reason)
                                throws java.lang.Exception
        Throws:
        java.lang.Exception
      • unhandled

        public static void unhandled​(java.lang.Object message)
      • startChild

        public static void startChild()
      • handleBackoff

        public static scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> handleBackoff()
      • akka$actor$ActorLogging$$_log

        public static LoggingAdapter akka$actor$ActorLogging$$_log()
      • akka$actor$ActorLogging$$_log_$eq

        public static void akka$actor$ActorLogging$$_log_$eq​(LoggingAdapter x$1)
      • context

        public ActorContext context()
        Description copied from interface: Actor
        Scala API: Stores the context for this actor, including self, and sender. It is implicit to support operations such as forward.

        WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!

        ActorContext is the Scala API. getContext returns a AbstractActor.ActorContext, which is the Java API of the actor context.

        Specified by:
        context in interface Actor
        Returns:
        (undocumented)
      • self

        public final ActorRef self()
        Description copied from interface: Actor
        The 'self' field holds the ActorRef for this actor.

        Can be used to send messages to itself:
         self ! message
         
        Specified by:
        self in interface Actor
        Returns:
        (undocumented)
      • akka$actor$Actor$_setter_$context_$eq

        protected void akka$actor$Actor$_setter_$context_$eq​(ActorContext x$1)
        Description copied from interface: Actor
        Scala API: Stores the context for this actor, including self, and sender. It is implicit to support operations such as forward.

        WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!

        ActorContext is the Scala API. getContext returns a AbstractActor.ActorContext, which is the Java API of the actor context.

        Specified by:
        akka$actor$Actor$_setter_$context_$eq in interface Actor
        Parameters:
        x$1 - (undocumented)
      • akka$actor$Actor$_setter_$self_$eq

        protected final void akka$actor$Actor$_setter_$self_$eq​(ActorRef x$1)
        Description copied from interface: Actor
        The 'self' field holds the ActorRef for this actor.

        Can be used to send messages to itself:
         self ! message
         
        Specified by:
        akka$actor$Actor$_setter_$self_$eq in interface Actor
        Parameters:
        x$1 - (undocumented)
      • finalStopMessage

        public scala.Option<scala.Function1<java.lang.Object,​java.lang.Object>> finalStopMessage()
        Specified by:
        finalStopMessage in interface HandleBackoff
      • supervisorStrategy

        public SupervisorStrategy supervisorStrategy()
        Description copied from interface: Actor
        User overridable definition the strategy to use for supervising child actors.
        Specified by:
        supervisorStrategy in interface Actor
        Returns:
        (undocumented)
      • onTerminated

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> onTerminated()
      • receive

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> receive()
        Description copied from interface: Actor
        Scala API: This defines the initial actor behavior, it must return a partial function with the actor logic.
        Specified by:
        receive in interface Actor
        Returns:
        (undocumented)