Struct GracefulShutdown 

pub struct GracefulShutdown {
    pub unix: UnixGracefulShutdown,
}

Per-platform graceful-shutdown policy passed to ProcessHandle::terminate and related APIs.

Carries a sequence of one or more graceful-shutdown signals to dispatch before falling back to the implicit forceful kill. The shape is platform-conditional because the available graceful-shutdown signals themselves are platform-conditional:

• On Unix it carries a UnixGracefulShutdown of one or more UnixGracefulPhases.
• On Windows it carries a single WindowsGracefulShutdown timeout for the only available graceful signal, CTRL_BREAK_EVENT.

SIGKILL on Unix and TerminateProcess on Windows are always the implicit final fallback; they are not configurable phases.

Choosing the Unix sequence

See UnixGracefulShutdown for the recommended single-signal sequences and a discussion of why mixing SIGINT and SIGTERM does not cover children with unknown signal handlers.

Cross-platform construction

Use GracefulShutdown::builder to write a single cross-platform construction expression. The setter for the platform that does not match the current target accepts its argument without using it, so no cfg gates are needed at the call site:

use std::time::Duration;
use tokio_process_tools::GracefulShutdown;

// Common case: single-signal sequences via the convenience shortcuts.
let shutdown = GracefulShutdown::builder()
    .unix_sigterm(Duration::from_secs(10))
    .windows_ctrl_break(Duration::from_secs(10))
    .build();

For the rare multiphase case, use the GracefulShutdownBuilder::unix setter, accepting a custom-built UnixGracefulShutdown:

use std::time::Duration;
use tokio_process_tools::{
    GracefulShutdown, UnixGracefulPhase, UnixGracefulShutdown,
};

let shutdown = GracefulShutdown::builder()
    .unix(UnixGracefulShutdown::from_phases([
        UnixGracefulPhase::interrupt(Duration::from_secs(60)),
        UnixGracefulPhase::terminate(Duration::from_secs(5)),
    ]))
    .windows_ctrl_break(Duration::from_secs(10))
    .build();

Platform availability

This type is only available on Unix and Windows because the underlying graceful-shutdown signals only exist there. On other Tokio-supported targets the spawn, wait, output-collection, and ProcessHandle::kill APIs remain available; only the graceful-termination surface (terminate(...), terminate_on_drop(...), wait_for_completion_or_terminate(...), the send_*_signal(...) methods, and this type) is gated out.

Fields

unix: UnixGracefulShutdown

Unix graceful-shutdown phase sequence.

Implementations

impl GracefulShutdown

pub fn builder() -> GracefulShutdownBuilder<UnixUnset>

Start a fluent specification of a GracefulShutdown value.

Call unix, then windows, then build. The setter for the platform that does not match the current target accepts its argument without using it, which lets cross-platform code construct the value without cfg gates.

pub fn total_timeout(&self) -> Duration

Upper bound on wall-clock time spent in graceful phases before the implicit forceful kill.

On Unix this is the sum of every UnixGracefulPhase’s timeout in the configured sequence. On Windows it is the single WindowsGracefulShutdown::timeout.

Trait Implementations

impl Clone for GracefulShutdown

fn clone(&self) -> GracefulShutdown

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GracefulShutdown

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for GracefulShutdown

fn eq(&self, other: &GracefulShutdown) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for GracefulShutdown

impl StructuralPartialEq for GracefulShutdown