Struct BroadcastOutputStream 

pub struct BroadcastOutputStream { /* private fields */ }

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

This is the broadcast variant, allowing for multiple simultaneous consumers with the downside of inducing memory allocations not required when only one consumer is listening. For that case, prefer using the crate::output_stream::single_subscriber::SingleSubscriberOutputStream.

Implementations

impl BroadcastOutputStream

pub fn inspect_chunks( &self, f: impl FnMut(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 BroadcastOutputStream

pub fn collect_chunks<S: Sink>( &self, into: S, collect: impl FnMut(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 FnMut(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 BroadcastOutputStream

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 BroadcastOutputStream

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

Formats the value using the given formatter.

impl Drop for BroadcastOutputStream

fn drop(&mut self)

Executes the destructor for this type.

impl OutputStream for BroadcastOutputStream

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.