Package org.apache.pekko.actor

Class CoordinatedShutdown

java.lang.Object
org.apache.pekko.actor.CoordinatedShutdown
All Implemented Interfaces:
Extension
public final class CoordinatedShutdown extends Object implements Extension

  • Method Details

    • PhaseBeforeServiceUnbind

      public static String PhaseBeforeServiceUnbind()

    • PhaseServiceUnbind

      public static String PhaseServiceUnbind()
      Stop accepting new incoming requests in for example HTTP.

    • PhaseServiceRequestsDone

      public static String PhaseServiceRequestsDone()
      Wait for requests that are in progress to be completed.

    • PhaseServiceStop

      public static String PhaseServiceStop()
      Final shutdown of service endpoints.

    • PhaseBeforeClusterShutdown

      public static String PhaseBeforeClusterShutdown()
      Phase for custom application tasks that are to be run after service shutdown and before cluster shutdown.

    • PhaseClusterShardingShutdownRegion

      public static String PhaseClusterShardingShutdownRegion()
      Graceful shutdown of the Cluster Sharding regions.

    • PhaseClusterLeave

      public static String PhaseClusterLeave()
      Emit the leave command for the node that is shutting down.

    • PhaseClusterExiting

      public static String PhaseClusterExiting()
      Shutdown cluster singletons

    • PhaseClusterExitingDone

      public static String PhaseClusterExitingDone()
      Wait until exiting has been completed

    • PhaseClusterShutdown

      public static String PhaseClusterShutdown()
      Shutdown the cluster extension

    • PhaseBeforeActorSystemTerminate

      public static String PhaseBeforeActorSystemTerminate()
      Phase for custom application tasks that are to be run after cluster shutdown and before ActorSystem termination.

    • PhaseActorSystemTerminate

      public static String PhaseActorSystemTerminate()
      Last phase. See terminate-actor-system and exit-jvm above. Don't add phases that depends on this phase because the dispatcher and scheduler of the ActorSystem have been shutdown.

    • unknownReason

      public static CoordinatedShutdown.Reason unknownReason()

    • actorSystemTerminateReason

      public static CoordinatedShutdown.Reason actorSystemTerminateReason()

    • jvmExitReason

      public static CoordinatedShutdown.Reason jvmExitReason()

    • clusterDowningReason

      public static CoordinatedShutdown.Reason clusterDowningReason()

    • clusterJoinUnsuccessfulReason

      public static CoordinatedShutdown.Reason clusterJoinUnsuccessfulReason()

    • incompatibleConfigurationDetectedReason

      public static CoordinatedShutdown.Reason incompatibleConfigurationDetectedReason()

    • clusterLeavingReason

      public static CoordinatedShutdown.Reason clusterLeavingReason()

    • get

      public static CoordinatedShutdown get(ActorSystem system)

    • get

      public static CoordinatedShutdown get(ClassicActorSystemProvider system)

    • lookup

      public static CoordinatedShutdown$ lookup()

    • createExtension

      public static CoordinatedShutdown createExtension(ExtendedActorSystem system)

    • apply

      public static T apply(ActorSystem system)

    • apply

      public static T apply(ClassicActorSystemProvider system)

    • hashCode

      public static final int hashCode()

    • equals

      public static final boolean equals(Object other)

    • addCancellableTask

      public Cancellable addCancellableTask(String phase, String taskName, scala.Function0<scala.concurrent.Future<Done>> task)
      Scala API: Add a task to a phase, returning an object which will cancel it on demand and remove it from the task pool (so long as the same task has not been added elsewhere). Tasks in a phase are run concurrently, with no ordering assumed.

      Adding a task to a phase does not remove any other tasks from the phase.

      If the same task is added multiple times, each addition will be run unless cancelled.

      Tasks should typically be registered as early as possible -- once coordinated shutdown begins, tasks may be added without ever being run. A task may add tasks to a later stage with confidence that they will be run.

    • addCancellableTask

      public Cancellable addCancellableTask(String phase, String taskName, Supplier<CompletionStage<Done>> task)
      Java API: Add a task to a phase, returning an object which will cancel it on demand and remove it from the task pool (so long as the same task has not been added elsewhere). Tasks in a phase are run concurrently, with no ordering assumed.

      Adding a task to a phase does not remove any other tasks from the phase.

      If the same task is added multiple times, each addition will be run unless cancelled.

      Tasks should typically be registered as early as possible -- once coordinated shutdown begins, tasks may be added without ever being run. A task may add tasks to a later stage with confidence that they will be run.

    • addTask

      public void addTask(String phase, String taskName, scala.Function0<scala.concurrent.Future<Done>> task)
      Scala API: Add a task to a phase. It doesn't remove previously added tasks. Tasks added to the same phase are executed in parallel without any ordering assumptions. Next phase will not start until all tasks of previous phase have been completed.

      Tasks should typically be registered as early as possible after system startup. When running the coordinated shutdown tasks that have been registered will be performed but tasks that are added too late will not be run. It is possible to add a task to a later phase by a task in an earlier phase and it will be performed.

    • addTask

      public void addTask(String phase, String taskName, Supplier<CompletionStage<Done>> task)
      Java API: Add a task to a phase. It doesn't remove previously added tasks. Tasks added to the same phase are executed in parallel without any ordering assumptions. Next phase will not start until all tasks of previous phase have been completed.

      Tasks should typically be registered as early as possible after system startup. When running the coordinated shutdown tasks that have been registered will be performed but tasks that are added too late will not be run. It is possible to add a task to a later phase by a task in an earlier phase and it will be performed.

    • addActorTerminationTask

      public void addActorTerminationTask(String phase, String taskName, ActorRef actor, scala.Option<Object> stopMsg)
      Scala API: Add an actor termination task to a phase. It doesn't remove previously added tasks. Tasks added to the same phase are executed in parallel without any ordering assumptions. Next phase will not start until all tasks of previous phase have been completed.

      When executed, this task will first send the given stop message, if defined, to the actor, then it will watch the actor, and complete when the actor terminates.

      Tasks should typically be registered as early as possible after system startup. When running the coordinated shutdown tasks that have been registered will be performed but tasks that are added too late will not be run. It is possible to add a task to a later phase by a task in an earlier phase and it will be performed.

    • addActorTerminationTask

      public void addActorTerminationTask(String phase, String taskName, ActorRef actor, Optional<Object> stopMsg)
      Java API: Add an actor termination task to a phase. It doesn't remove previously added tasks. Tasks added to the same phase are executed in parallel without any ordering assumptions. Next phase will not start until all tasks of previous phase have been completed.

      When executed, this task will first send the given stop message, if defined, to the actor, then it will watch the actor, and complete when the actor terminates.

      Tasks should typically be registered as early as possible after system startup. When running the coordinated shutdown tasks that have been registered will be performed but tasks that are added too late will not be run. It is possible to add a task to a later phase by a task in an earlier phase and it will be performed.

    • shutdownReason

      public scala.Option<CoordinatedShutdown.Reason> shutdownReason()
      The Reason for the shutdown as passed to the run method. None if the shutdown has not been started.

    • getShutdownReason

      public Optional<CoordinatedShutdown.Reason> getShutdownReason()
      The Reason for the shutdown as passed to the run method. Optional.empty if the shutdown has not been started.

    • run

      public scala.concurrent.Future<Done> run(CoordinatedShutdown.Reason reason)
      Scala API: Run tasks of all phases. The returned Future is completed when all tasks have been completed, or there is a failure when recovery is disabled.

      It's safe to call this method multiple times. It will only run the shutdown sequence once.

    • runAll

      public CompletionStage<Done> runAll(CoordinatedShutdown.Reason reason)
      Java API: Run tasks of all phases. The returned CompletionStage is completed when all tasks have been completed, or there is a failure when recovery is disabled.

      It's safe to call this method multiple times. It will only run the shutdown sequence once.

    • run

      public scala.concurrent.Future<Done> run(CoordinatedShutdown.Reason reason, scala.Option<String> fromPhase)
      Scala API: Run tasks of all phases including and after the given phase. The returned Future is completed when all such tasks have been completed, or there is a failure when recovery is disabled.

      It's safe to call this method multiple times. It will only run shutdown sequence once.

    • run

      public CompletionStage<Done> run(CoordinatedShutdown.Reason reason, Optional<String> fromPhase)
      Java API: Run tasks of all phases including and after the given phase. The returned CompletionStage is completed when all such tasks have been completed, or there is a failure when recovery is disabled.

      It's safe to call this method multiple times. It will only run the shutdown sequence once.

    • timeout

      public scala.concurrent.duration.FiniteDuration timeout(String phase)
      The configured timeout for a given phase. For example useful as timeout when actor ask requests is used as a task.

    • totalTimeout

      public scala.concurrent.duration.FiniteDuration totalTimeout()
      Sum of timeouts of all phases that have some task.

    • addJvmShutdownHook

      public <T> void addJvmShutdownHook(scala.Function0<T> hook)
      Scala API: Add a JVM shutdown hook that will be run when the JVM process begins its shutdown sequence. Added hooks may run in any order concurrently, but they are running before Pekko internal shutdown hooks, e.g. those shutting down Artery.

    • addCancellableJvmShutdownHook

      public <T> Cancellable addCancellableJvmShutdownHook(scala.Function0<T> hook)
      Scala API: Add a JVM shutdown hook that will be run when the JVM process begins its shutdown sequence. Added hooks may run in any order concurrently, but they are running before Pekko internal shutdown hooks, e.g. those shutting down Artery.

      The returned Cancellable makes it possible to de-register the hook. For example on actor system shutdown to avoid leaking references to the actor system in tests.

      For shutdown hooks that does not have any requirements on running before the Akka shutdown hooks the standard library JVM shutdown hooks APIs are better suited.

    • addJvmShutdownHook

      public void addJvmShutdownHook(Runnable hook)
      Java API: Add a JVM shutdown hook that will be run when the JVM process begins its shutdown sequence. Added hooks may run in any order concurrently, but they are running before Pekko internal shutdown hooks, e.g. those shutting down Artery.

    • addCancellableJvmShutdownHook

      public Cancellable addCancellableJvmShutdownHook(Runnable hook)
      Java API: Add a JVM shutdown hook that will be run when the JVM process begins its shutdown sequence. Added hooks may run in an order concurrently, but they are running before Pekko internal shutdown hooks, e.g. those shutting down Artery.

      The returned Cancellable makes it possible to de-register the hook. For example on actor system shutdown to avoid leaking references to the actor system in tests.

      For shutdown hooks that does not have any requirements on running before the Akka shutdown hooks the standard library JVM shutdown hooks APIs are better suited.