Struct SessionInput 

pub(super) struct SessionInput {
    io: Arc<ContainerIO>,
    attach: SharedContainerAttach,
    client: ClientRx,
    pending: Option<Bytes>,
    ping: Interval,
    pub(super) stdin_open: bool,
}

Forwards the stdin and the resize events of a client to the process, for the loops of exec and attach sessions, which forward the output meanwhile.

Fields

io: Arc<ContainerIO>

attach: SharedContainerAttach

client: ClientRx

pending: Option<Bytes>

Stdin which waits for the container.

ping: Interval

Pings the client while stdin waits.

stdin_open: bool

Whether stdin gets forwarded, until the client closed it.

Implementations

impl SessionInput

pub(super) fn new( io: Arc<ContainerIO>, attach: SharedContainerAttach, client: ClientRx, stdin: bool, ) -> Self

Forward the input of client to the process of io and attach, stdin only if stdin is set.

pub(super) async fn next(&mut self) -> InputEvent

Forward stdin until the session has something to handle. The session may cancel it for its output, nothing gets lost then.

pub(super) fn close_container_stdin(&mut self)

Close the stdin of the container after the stdin before. A terminal cannot be closed without ending its output, it gets its end of file character instead, like from a user pressing Ctrl-D. A process reading lines sees the end of its input then, one after a line without its ending needs a second one, like a user would type it.

pub(super) fn resize(&self, data: &[u8])

Handle a resize event of the client, its JSON.

pub(super) fn resize_with( data: &[u8], resize: impl FnOnce(u16, u16) -> Result<bool>, )

Handle a resize event of the client, its JSON, with resize, which returns whether there is a terminal. Clients send them regardless of a terminal, a broken one does not end the session.

fn try_resize( data: &[u8], resize: impl FnOnce(u16, u16) -> Result<bool>, ) -> Result<()>