Struct GracefulTimeouts 

pub struct GracefulTimeouts {
    pub interrupt_timeout: Duration,
    pub terminate_timeout: Duration,
}

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

The shape mirrors the platform’s actual graceful-shutdown model. On Unix the type carries two separate timeout, one per graceful phase (SIGINT then SIGTERM). On Windows it carries a single timeout for the single graceful phase (CTRL_BREAK_EVENT) on that platform.

Cross-platform construction

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

use std::time::Duration;
use tokio_process_tools::{GracefulTimeouts, both};

let timeouts = GracefulTimeouts::builder()
    .unix((Duration::from_secs(3), Duration::from_secs(5)))
    .windows(Duration::from_secs(8))
    .build();

// For the common case where both Unix phases share a value:
let timeouts = GracefulTimeouts::builder()
    .unix(both(Duration::from_secs(3)))
    .windows(Duration::from_secs(8))
    .build();

Platform-specific construction

Code that intentionally tunes Unix and Windows independently can also construct the value directly with cfg gates:

use std::time::Duration;
use tokio_process_tools::GracefulTimeouts;

#[cfg(unix)]
let timeouts = GracefulTimeouts {
    interrupt_timeout: Duration::from_secs(3),
    terminate_timeout: Duration::from_secs(5),
};
#[cfg(windows)]
let timeouts = GracefulTimeouts {
    graceful_timeout: Duration::from_secs(8),
};

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

interrupt_timeout: Duration

Maximum time to wait after sending SIGINT before escalating to SIGTERM.

terminate_timeout: Duration

Maximum time to wait after sending SIGTERM before escalating to SIGKILL.

Implementations

impl GracefulTimeouts

pub fn builder() -> GracefulTimeoutsBuilder<UnixUnset>

Start a fluent specification of a GracefulTimeouts value.

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

See the type-level documentation for an example.

Trait Implementations

impl Clone for GracefulTimeouts

fn clone(&self) -> GracefulTimeouts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GracefulTimeouts

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

Formats the value using the given formatter.

impl PartialEq for GracefulTimeouts

fn eq(&self, other: &GracefulTimeouts) -> 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 Copy for GracefulTimeouts

impl Eq for GracefulTimeouts

impl StructuralPartialEq for GracefulTimeouts