Struct rocket::config::Shutdown[][src]

pub struct Shutdown {
    pub ctrlc: bool,
    pub signals: HashSet<Sig>,
    pub grace: u32,
    pub mercy: u32,
    pub force: bool,
    // some fields omitted
}
Expand description

Graceful shutdown configuration.

Summary

This structure configures when and how graceful shutdown occurs. The ctrlc and signals properties control when and the grace and mercy properties control how.

When a shutdown is triggered by an externally or internally initiated Shutdown::notify(), Rocket allows application I/O to make progress for at most grace seconds before initiating connection-level shutdown. Connection shutdown forcibly terminates application I/O, but connections are allowed an additional mercy seconds to shutdown before being forcefully terminated. This implies that a cooperating and active remote client maintaining an open connection can stall shutdown for at most grace seconds, while an uncooperative remote client can stall shutdown for at most grace + mercy seconds.

Triggers

All graceful shutdowns are initiated via Shutdown::notify(). Rocket can be configured to call Shutdown::notify() automatically on certain conditions, specified via the ctrlc and signals properties of this structure. More specifically, if ctrlc is true (the default), ctrl-c (SIGINT) initiates a server shutdown, and on Unix, signals specifies a list of IPC signals that trigger a shutdown (["term"] by default).

Grace Period

Once a shutdown is triggered, Rocket stops accepting new connections and waits at most grace seconds before initiating connection shutdown. Applications can await the Shutdown future to detect a shutdown and cancel any server-initiated I/O, such as from infinite responders, to avoid abrupt I/O cancellation.

Mercy Period

After the grace period has elapsed, Rocket initiates connection shutdown, allowing connection-level I/O termination such as TLS’s close_notify to proceed nominally. Rocket waits at most mercy seconds for connections to shutdown before forcefully terminating all connections.

Runaway I/O

If tasks are still executing after both periods and a Rocket configured async runtime is in use, Rocket waits an unspecified amount of time (not to exceed 1s) and forcefully exits the current process with an exit code of 1. This guarantees that the server process terminates, prohibiting uncooperative, runaway I/O from preventing shutdown altogether.

A “Rocket configured runtime” is one started by the #[rocket::main] and #[launch] attributes. Rocket never forcefully terminates a server that is running inside of a custom runtime. A server that creates its own async runtime must take care to terminate itself if tasks it spawns fail to cooperate.

Under normal circumstances, forced termination should never occur. No use of “normal” cooperative I/O (that is, via .await or task::spawn()) should trigger abrupt termination. Instead, forced cancellation is intended to prevent buggy code, such as an unintended infinite loop or unknown use of blocking I/O, from preventing shutdown.

This behavior can be disabled by setting Shutdown::force to false.

Example

As with all Rocket configuration options, when using the default Config::figment(), Shutdown can be configured via a Rocket.toml file. As always, defaults are provided (documented below), and thus configuration only needs to provided to change defaults.

use rocket::Config;

// If these are the contents of `Rocket.toml`...
[default.shutdown]
ctrlc = false
signals = ["term", "hup"]
grace = 10
mercy = 5

// The config parses as follows:
assert_eq!(config.shutdown.ctrlc, false);
assert_eq!(config.shutdown.grace, 10);
assert_eq!(config.shutdown.mercy, 5);

use rocket::config::Sig;

assert_eq!(config.shutdown.signals.len(), 2);
assert!(config.shutdown.signals.contains(&Sig::Term));
assert!(config.shutdown.signals.contains(&Sig::Hup));

Or, as with all configuration options, programatically:

use rocket::config::{Config, Shutdown};

#[cfg(unix)]
use rocket::config::Sig;

let config = Config {
    shutdown: Shutdown {
        ctrlc: false,
        #[cfg(unix)]
        signals: {
            let mut set = std::collections::HashSet::new();
            set.insert(Sig::Term);
            set.insert(Sig::Hup);
            set
        },
        grace: 10,
        mercy: 5,
        force: true,
        ..Default::default()
    },
    ..Config::default()
};

assert_eq!(config.shutdown.ctrlc, false);
assert_eq!(config.shutdown.grace, 10);
assert_eq!(config.shutdown.mercy, 5);
assert_eq!(config.shutdown.force, true);

#[cfg(unix)] {
    assert_eq!(config.shutdown.signals.len(), 2);
    assert!(config.shutdown.signals.contains(&Sig::Term));
    assert!(config.shutdown.signals.contains(&Sig::Hup));
}

Fields

ctrlc: bool

Whether ctrl-c (SIGINT) initiates a server shutdown.

default: true

signals: HashSet<Sig>
This is supported on Unix only.

On Unix, a set of signal which trigger a shutdown. On non-Unix, this option is unavailable and silently ignored.

default: { Sig::Term }

grace: u32

The grace period: number of seconds to continue to try to finish outstanding server I/O for before forcibly terminating it.

default: 2

mercy: u32

The mercy period: number of seconds to continue to try to finish outstanding connection I/O for before forcibly terminating it.

default: 3

force: bool

Whether to force termination of a process that refuses to cooperatively shutdown.

Rocket never forcefully terminates a server that is running inside of a custom runtime irrespective of this value. A server that creates its own async runtime must take care to terminate itself if it fails to cooperate.

default: true

Trait Implementations

impl Clone for Shutdown[src]

fn clone(&self) -> Shutdown[src]

Returns a copy of the value. Read more

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl Debug for Shutdown[src]

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

Formats the value using the given formatter. Read more

impl Default for Shutdown[src]

fn default() -> Self[src]

Returns the “default value” for a type. Read more

impl<'de> Deserialize<'de> for Shutdown[src]

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 
[src]

Deserialize this value from the given Serde deserializer. Read more

impl Display for Shutdown[src]

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

Formats the value using the given formatter. Read more

impl PartialEq<Shutdown> for Shutdown[src]

fn eq(&self, other: &Shutdown) -> bool[src]

This method tests for self and other values to be equal, and is used by ==. Read more

fn ne(&self, other: &Shutdown) -> bool[src]

This method tests for !=.

impl Serialize for Shutdown[src]

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer
[src]

Serialize this value into the given Serde serializer. Read more

impl StructuralPartialEq for Shutdown[src]

Auto Trait Implementations

impl RefUnwindSafe for Shutdown

impl Send for Shutdown

impl Sync for Shutdown

impl Unpin for Shutdown

impl UnwindSafe for Shutdown

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T> Instrument for T[src]

fn instrument(self, span: Span) -> Instrumented<Self>[src]

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>[src]

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> IntoCollection<T> for T

pub fn into_collection<A>(self) -> SmallVec<A> where
    A: Array<Item = T>, 

Converts self into a collection.

pub fn mapped<U, F, A>(self, f: F) -> SmallVec<A> where
    F: FnMut(T) -> U,
    A: Array<Item = U>, 

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T[src]

Creates owned data from borrowed data, usually by cloning. Read more

pub fn clone_into(&self, target: &mut T)[src]

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> ToString for T where
    T: Display + ?Sized
[src]

pub default fn to_string(&self) -> String[src]

Converts the given value to a String. Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

pub fn vzip(self) -> V

impl<T> DeserializeOwned for T where
    T: for<'de> Deserialize<'de>, 
[src]