Package akka.actor

Class CoordinatedShutdown

  • All Implemented Interfaces:
    Extension

    public final class CoordinatedShutdown
    extends java.lang.Object
    implements Extension
    • Method Detail

      • PhaseBeforeServiceUnbind

        public static java.lang.String PhaseBeforeServiceUnbind()
        The first pre-defined phase that applications can add tasks to. Note that more phases can be added in the application's configuration by overriding this phase with an additional depends-on.
        Returns:
        (undocumented)
      • PhaseServiceUnbind

        public static java.lang.String PhaseServiceUnbind()
        Stop accepting new incoming requests in for example HTTP.
        Returns:
        (undocumented)
      • PhaseServiceRequestsDone

        public static java.lang.String PhaseServiceRequestsDone()
        Wait for requests that are in progress to be completed.
        Returns:
        (undocumented)
      • PhaseServiceStop

        public static java.lang.String PhaseServiceStop()
        Final shutdown of service endpoints.
        Returns:
        (undocumented)
      • PhaseBeforeClusterShutdown

        public static java.lang.String PhaseBeforeClusterShutdown()
        Phase for custom application tasks that are to be run after service shutdown and before cluster shutdown.
        Returns:
        (undocumented)
      • PhaseClusterShardingShutdownRegion

        public static java.lang.String PhaseClusterShardingShutdownRegion()
        Graceful shutdown of the Cluster Sharding regions.
        Returns:
        (undocumented)
      • PhaseClusterLeave

        public static java.lang.String PhaseClusterLeave()
        Emit the leave command for the node that is shutting down.
        Returns:
        (undocumented)
      • PhaseClusterExiting

        public static java.lang.String PhaseClusterExiting()
        Shutdown cluster singletons
        Returns:
        (undocumented)
      • PhaseClusterExitingDone

        public static java.lang.String PhaseClusterExitingDone()
        Wait until exiting has been completed
        Returns:
        (undocumented)
      • PhaseClusterShutdown

        public static java.lang.String PhaseClusterShutdown()
        Shutdown the cluster extension
        Returns:
        (undocumented)
      • PhaseBeforeActorSystemTerminate

        public static java.lang.String PhaseBeforeActorSystemTerminate()
        Phase for custom application tasks that are to be run after cluster shutdown and before ActorSystem termination.
        Returns:
        (undocumented)
      • PhaseActorSystemTerminate

        public static java.lang.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.
        Returns:
        (undocumented)
      • unknownReason

        public static CoordinatedShutdown.Reason unknownReason()
        Java API: The reason for the shutdown was unknown. Needed for backwards compatibility.
        Returns:
        (undocumented)
      • jvmExitReason

        public static CoordinatedShutdown.Reason jvmExitReason()
        Java API: The shutdown was initiated by a JVM shutdown hook, e.g. triggered by SIGTERM.
        Returns:
        (undocumented)
      • clusterDowningReason

        public static CoordinatedShutdown.Reason clusterDowningReason()
        Java API: The shutdown was initiated by Cluster downing.
        Returns:
        (undocumented)
      • clusterLeavingReason

        public static CoordinatedShutdown.Reason clusterLeavingReason()
        Java API: The shutdown was initiated by Cluster leaving.
        Returns:
        (undocumented)
      • confWithOverrides

        public static com.typesafe.config.Config confWithOverrides​(com.typesafe.config.Config conf,
                                                                   scala.Option<CoordinatedShutdown.Reason> reason)
      • phasesFromConfig

        public static scala.collection.immutable.Map<java.lang.String,​CoordinatedShutdown.Phase> phasesFromConfig​(com.typesafe.config.Config conf)
        INTERNAL API
        Parameters:
        conf - (undocumented)
        Returns:
        (undocumented)
      • topologicalSort

        public static scala.collection.immutable.List<java.lang.String> topologicalSort​(scala.collection.immutable.Map<java.lang.String,​CoordinatedShutdown.Phase> phases)
        INTERNAL API: https://en.wikipedia.org/wiki/Topological_sorting
        Parameters:
        phases - (undocumented)
        Returns:
        (undocumented)
      • orderedPhases

        public scala.collection.immutable.List<java.lang.String> orderedPhases()
        INTERNAL API
      • jvmHooksLatch

        public java.util.concurrent.CountDownLatch jvmHooksLatch()
        INTERNAL API
        Returns:
        (undocumented)
      • addTask

        public void addTask​(java.lang.String phase,
                            java.lang.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.

        Parameters:
        phase - (undocumented)
        taskName - (undocumented)
        task - (undocumented)
      • addTask

        public void addTask​(java.lang.String phase,
                            java.lang.String taskName,
                            java.util.function.Supplier<java.util.concurrent.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.

        Parameters:
        phase - (undocumented)
        taskName - (undocumented)
        task - (undocumented)
      • 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.
        Returns:
        (undocumented)
      • getShutdownReason

        public java.util.Optional<CoordinatedShutdown.Reason> getShutdownReason()
        The Reason for the shutdown as passed to the run method. Optional.empty if the shutdown has not been started.
        Returns:
        (undocumented)
      • 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.

        Parameters:
        reason - (undocumented)
        Returns:
        (undocumented)
      • run

        public scala.concurrent.Future<Done> run()
        Deprecated.
        Use the method with `reason` parameter instead. Since 2.5.8.
      • runAll

        public java.util.concurrent.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.

        Parameters:
        reason - (undocumented)
        Returns:
        (undocumented)
      • runAll

        public java.util.concurrent.CompletionStage<Done> runAll()
        Deprecated.
        Use the method with `reason` parameter instead. Since 2.5.8.
      • run

        public scala.concurrent.Future<Done> run​(CoordinatedShutdown.Reason reason,
                                                 scala.Option<java.lang.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.

        Parameters:
        reason - (undocumented)
        fromPhase - (undocumented)
        Returns:
        (undocumented)
      • run

        public scala.concurrent.Future<Done> run​(scala.Option<java.lang.String> fromPhase)
        Deprecated.
        Use the method with `reason` parameter instead. Since 2.5.8.
      • run

        public java.util.concurrent.CompletionStage<Done> run​(CoordinatedShutdown.Reason reason,
                                                              java.util.Optional<java.lang.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.

        Parameters:
        reason - (undocumented)
        fromPhase - (undocumented)
        Returns:
        (undocumented)
      • run

        public java.util.concurrent.CompletionStage<Done> run​(java.util.Optional<java.lang.String> fromPhase)
        Deprecated.
        Use the method with `reason` parameter instead. Since 2.5.8.
      • timeout

        public scala.concurrent.duration.FiniteDuration timeout​(java.lang.String phase)
        The configured timeout for a given phase. For example useful as timeout when actor ask requests is used as a task.
        Parameters:
        phase - (undocumented)
        Returns:
        (undocumented)
      • totalTimeout

        public scala.concurrent.duration.FiniteDuration totalTimeout()
        Sum of timeouts of all phases that have some task.
        Returns:
        (undocumented)
      • 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 Akka internal shutdown hooks, e.g. those shutting down Artery.
        Parameters:
        hook - (undocumented)
      • 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 Akka 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.

        Parameters:
        hook - (undocumented)
        Returns:
        (undocumented)
      • addJvmShutdownHook

        public void addJvmShutdownHook​(java.lang.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 Akka internal shutdown hooks, e.g. those shutting down Artery.
        Parameters:
        hook - (undocumented)
      • addCancellableJvmShutdownHook

        public Cancellable addCancellableJvmShutdownHook​(java.lang.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 Akka 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.

        Parameters:
        hook - (undocumented)
        Returns:
        (undocumented)