Enum nix_compat::nix_daemon::framing::stderr_read::StderrReaderState

enum StderrReaderState {
    RequestingNextFrame {
        write_state: U64WriteState,
    },
    RequestingFrameLen {
        write_state: U64WriteState,
    },
    FrameLenRequested,
    ReadingSize {
        buf: [u8; 8],
        filled: usize,
    },
    ReadingPayload {
        remaining: u64,
        pad: usize,
        tmp_buf: BytesMut,
    },
}

State machine for StderrReadFramedReader.

As the reader progresses it linearly cycles through the states.

Variants

RequestingNextFrame

Represents the state indicating that we are about to request a new frame.

When poll_read is called, it writes STDERR_READ into the writer and progresses to the StderrReaderState::RequestingFrameLen state

The reader always starts in this state and is reached after every frame has been fully read.

Fields

write_state: U64WriteState

RequestingFrameLen

At this point the reader writes the desired payload length we want to receive based on read_buf.remaining().

Fields

write_state: U64WriteState

FrameLenRequested

At this point the reader just flushes the writer and gets ready to receive the actual payload size that is about to be sent to us by transitioning to the StderrReaderState::ReadingSize state.

ReadingSize

The size is a u64 which is 8 bytes long, while it’s likely that we will receive the whole u64 in one read, it’s possible that it will arrive in smaller chunks. So in this state we read up to 8 bytes and transition to StderrReaderState::ReadingPayload when done.

Fields

buf: [u8; 8]

filled: usize

ReadingPayload

This is where we read the actual payload that is sent to us. All of the previous states were just internal bookkeeping where we did not return any data to the conumer, and only returned Poll::Pending.

Having read the full payload, progresses to the StderrReaderState::RequestingNextFrame state to read the next frame when/if requested.

Fields

remaining: u64

Represents the remaining number of bytes we expect to read based on the value read in the previous state.

pad: usize

Represents the remaining of padding we expect to read before switching back to the RequestingNextFrame state.

tmp_buf: BytesMut

In an ideal case this reader does not allocate, but in the scenario where we’ve read the whol payload frame but still have padding remaining, it’s not safe to return the payload to the consumer as there is risk that the reader won’t be called again, leaving dangling padding. In this case we store the payload in this buffer until we’ve read the padding, and then return the data from here.

Implementations

impl StderrReaderState

fn request_next_frame() -> Self

fn read_written(len: u64) -> Self

Trait Implementations

impl Debug for StderrReaderState

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

Formats the value using the given formatter.