Struct ExecTeardown 

pub(super) struct ExecTeardown {
    stdio: (Receiver<Message>, Receiver<Message>),
    attach: SharedContainerAttach,
    token: CancellationToken,
    process: Arc<Process>,
    pub(super) kill: Arc<AtomicBool>,
    _stop_output: StopOutput,
}

Ends an exec session however it ends, also if the client went away and the loop got aborted, or before the process even got started. The loop ends before the exit of the process if the connection is gone, if the client sent a message which is too large, or if the session hit the idle timeout or lost the exit. Only the last two kill the process, see ExecTeardown::kill, the others close its stdin or hang up its terminal. All but the hang-up stop the output, which nothing takes anymore.

Fields

stdio: (Receiver<Message>, Receiver<Message>)

The stdout and stderr channels of the process.

attach: SharedContainerAttach

token: CancellationToken

Cancelled once the process exited.

process: Arc<Process>

The process, which its watcher may reap before the token got cancelled, so it does not get signalled by its PID.

kill: Arc<AtomicBool>

Set once the session ended with the idle timeout or lost the exit, which kills the process, like the reaper kills one after its timeout. Without a session the process would run on with nothing waiting for it. Otherwise it gets the end of its stdin and its output pipes closed, or the hang-up of its terminal, like a process started by the client itself once the client went away.

_stop_output: StopOutput

Stops the read loops once the session took the output, after the exit, dropped after the rest.

Implementations

impl ExecTeardown

fn hang_up(&self)

Hang up the terminal like a closed connection does: signal the process group and the process. Only while the process was not reaped yet, its group may be gone and taken by another one otherwise, see Process::signal_group.

Trait Implementations

impl Drop for ExecTeardown

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.