Struct SingleSubscriberOutputStream 

pub struct SingleSubscriberOutputStream { /* private fields */ }

The output stream from a process. Either representing stdout or stderr.

This is the single-subscriber variant, allowing for just one consumer. This has the upside of requiring as few memory allocations as possible. If multiple concurrent inspections are required, prefer using the output_stream::broadcast::BroadcastOutputSteam.

Implementations

impl SingleSubscriberOutputStream

pub fn from_stream<S: AsyncRead + Unpin + Send + 'static>( stream: S, stream_name: &'static str, backpressure_control: BackpressureControl, options: FromStreamOptions, ) -> SingleSubscriberOutputStream

Creates a new single subscriber output stream from an async read stream.

impl SingleSubscriberOutputStream

pub fn inspect_chunks( &self, f: impl Fn(Chunk) -> Next + Send + 'static, ) -> Inspector

Inspects chunks of output from the stream without storing them.

The provided closure is called for each chunk of data. Return Next::Continue to keep processing or Next::Break to stop.

pub fn inspect_lines( &self, f: impl FnMut(Cow<'_, str>) -> Next + Send + 'static, options: LineParsingOptions, ) -> Inspector

Inspects lines of output from the stream without storing them.

The provided closure is called for each line. Return Next::Continue to keep processing or Next::Break to stop.

pub fn inspect_lines_async<Fut>( &self, f: impl FnMut(Cow<'_, str>) -> Fut + Send + 'static, options: LineParsingOptions, ) -> Inspector

where Fut: Future<Output = Next> + Send,

Inspects lines of output from the stream without storing them, using an async closure.

The provided async closure is called for each line. Return Next::Continue to keep processing or Next::Break to stop.

impl SingleSubscriberOutputStream

pub fn collect_chunks<S: Sink>( &self, into: S, collect: impl Fn(Chunk, &mut S) + Send + 'static, ) -> Collector<S>

Collects chunks from the stream into a sink.

The provided closure is called for each chunk, with mutable access to the sink.

pub fn collect_chunks_async<S, F>(&self, into: S, collect: F) -> Collector<S>

where S: Sink, F: Fn(Chunk, &mut S) -> Pin<Box<dyn Future<Output = Next> + Send + '_>> + Send + 'static,

Collects chunks from the stream into a sink using an async closure.

The provided async closure is called for each chunk, with mutable access to the sink.

pub fn collect_lines<S: Sink>( &self, into: S, collect: impl Fn(Cow<'_, str>, &mut S) -> Next + Send + 'static, options: LineParsingOptions, ) -> Collector<S>

Collects lines from the stream into a sink.

The provided closure is called for each line, with mutable access to the sink. Return Next::Continue to keep processing or Next::Break to stop.

pub fn collect_lines_async<S, F>( &self, into: S, collect: F, options: LineParsingOptions, ) -> Collector<S>

where S: Sink, F: for<'a> Fn(Cow<'a, str>, &'a mut S) -> Pin<Box<dyn Future<Output = Next> + Send + 'a>> + Send + Sync + 'static,

Collects lines from the stream into a sink using an async closure.

The provided async closure is called for each line, with mutable access to the sink. Return Next::Continue to keep processing or Next::Break to stop.

pub fn collect_chunks_into_vec(&self) -> Collector<Vec<u8>>

Convenience method to collect all chunks into a Vec<u8>.

pub fn collect_lines_into_vec( &self, options: LineParsingOptions, ) -> Collector<Vec<String>>

Convenience method to collect all lines into a Vec<String>.

pub fn collect_chunks_into_write<W: Sink + AsyncWriteExt + Unpin>( &self, write: W, ) -> Collector<W>

Collects chunks into an async writer.

pub fn collect_lines_into_write<W: Sink + AsyncWriteExt + Unpin>( &self, write: W, options: LineParsingOptions, ) -> Collector<W>

Collects lines into an async writer.

pub fn collect_chunks_into_write_mapped<W: Sink + AsyncWriteExt + Unpin, B: AsRef<[u8]> + Send>( &self, write: W, mapper: impl Fn(Chunk) -> B + Send + Sync + Copy + 'static, ) -> Collector<W>

Collects chunks into an async writer after mapping them with the provided function.

pub fn collect_lines_into_write_mapped<W: Sink + AsyncWriteExt + Unpin, B: AsRef<[u8]> + Send>( &self, write: W, mapper: impl Fn(Cow<'_, str>) -> B + Send + Sync + Copy + 'static, options: LineParsingOptions, ) -> Collector<W>

Collects lines into an async writer after mapping them with the provided function.

impl SingleSubscriberOutputStream

pub async fn wait_for_line( &self, predicate: impl Fn(Cow<'_, str>) -> bool + Send + Sync + 'static, options: LineParsingOptions, ) -> Result<(), InspectorError>

Waits for a line that matches the given predicate.

This method blocks until a line is found that satisfies the predicate.

pub async fn wait_for_line_with_timeout( &self, predicate: impl Fn(Cow<'_, str>) -> bool + Send + Sync + 'static, options: LineParsingOptions, timeout: Duration, ) -> Result<(), OutputError>

Waits for a line that matches the given predicate, with a timeout.

Returns Ok(()) if a matching line is found, or Err(OutputError::Timeout) if the timeout expires.

Trait Implementations

impl Debug for SingleSubscriberOutputStream

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

Formats the value using the given formatter.

impl Drop for SingleSubscriberOutputStream

fn drop(&mut self)

Executes the destructor for this type.

impl OutputStream for SingleSubscriberOutputStream

fn chunk_size(&self) -> NumBytes

The maximum size of every chunk read by the backing stream_reader.

fn channel_capacity(&self) -> usize

The number of chunks held by the underlying async channel.

fn name(&self) -> &'static str

Type of stream. Can be “stdout” or “stderr”. But we do not guarantee this output. It should only be used for logging/debugging.