Enum Termination 

#[non_exhaustive]
pub enum Termination {
    Terminate,
    Hangup,
}

Why the system, rather than the user, is ending the application.

On Unix the terminal Runtime catches SIGTERM, SIGINT and SIGHUP for as long as it runs, and a Harness simulates them with Harness::terminate. The application hears the cause through App::terminating, which is how it tells “the system is ending us” from “the user asked to quit” (App::before_quit).

Whatever the application answers, the run ends in bounded time:

• Answering None quits at once.
• A message keeps the application running while it finishes, e.g. saves and returns Command::quit. After Termination::grace the runtime quits without it.
• A second SIGTERM or SIGINT ends the run at once. When the application does not return to the loop within a second after that, or after its grace, the runtime restores the terminal itself and the process ends by the signal, as it would have without the framework.

Every quit restores the terminal (raw mode off, the normal screen, the cursor) as long as the terminal still exists; after a hangup nothing is written to it.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Terminate

SIGTERM, or SIGINT from kill -INT: another program or the system (a service manager, a shutdown, kill) asks the application to end. The terminal is still there, so the application may save and quit, and it may even ask the user something, within the grace. By default the application answers as for a quit the user asked for, with App::before_quit.

Inside the application ctrl c is a key, not this signal: raw mode turns the terminal’s interrupt key off.

Hangup

SIGHUP: the terminal went away, because the SSH connection dropped, the terminal window or the tmux pane closed. Nobody can answer a question any more and nothing is drawn after it, so the application gets one chance to save, without a dialog. By default it quits at once.

A hangup that repeats (the shell forwards its own and the system sends another when the shell ends) changes nothing. A SIGHUP sent by hand while the terminal is still there is heard the same way, and the terminal is restored on the way out.

Implementations

impl Termination

pub const fn grace(self) -> Duration

How long the application has, after this cause, to quit on its own before the runtime quits without it: five seconds after Termination::Terminate, three after Termination::Hangup. A hangup during a pending terminate shortens what is left to the hangup’s grace.

use std::time::Duration;
use qframe::runtime::Termination;

assert_eq!(Termination::Terminate.grace(), Duration::from_secs(5));
assert_eq!(Termination::Hangup.grace(), Duration::from_secs(3));

Trait Implementations

impl Clone for Termination

fn clone(&self) -> Termination

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Termination

impl Debug for Termination

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

Formats the value using the given formatter.

impl Eq for Termination

impl Hash for Termination

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Termination

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Termination