Struct StdioPublisher 

pub struct StdioPublisher { /* private fields */ }

Publishes messages to standard output.

The line format is the client’s own. A line is text, ends at a newline, and the reader trims it, so a payload that is not UTF-8, holds a newline or begins or ends with whitespace (and any message with headers) travels in the text-safe envelope. The client silently drops empty lines, so an empty payload is rejected here instead.

A publish carries no per-message settings: a line on standard output takes a key and a payload and nothing else, so Publisher::Options is the unit type and the publish builder gains no step from this crate.

Standard output reaches the next process in the pipeline and never this process’s own standard input, so a registration that defers a delivery names where the copy goes, with .out_retry(Publish).to(key) or a transform that names one per delivery; one that names neither refuses to start. The StdioPublish page shows it in a service.

Examples

use ruststream_sea_file::stdio::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize)]
struct Job {
    id: u64,
}

#[derive(Debug, Outgoing, Serialize)]
#[outgoing(name = "results")]
struct Done {
    id: u64,
}

#[subscriber("jobs", reply)]
async fn work(job: &Job) -> Done {
    tracing::info!(job.id, "done");
    Done { id: job.id }
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("pipeline", "0.1.0")).with_broker(StdioBroker::new(), |b| {
        b.include(work).out_retry(Publish).to("jobs.retry");
    })
}

Trait Implementations

impl Clone for StdioPublisher

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StdioPublisher

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

Formats the value using the given formatter.

impl Publisher for StdioPublisher

type Payload = Lend

A line on standard output is written from the bytes and keeps nothing: the client’s send_to takes a slice, and the text-safe envelope is a buffer of this crate’s own.

type Error = SeaFileError

The error type returned by publish.

type Options = ()

The broker’s per-message settings: a QoS, a priority, an ordering key, whatever this transport lets one message differ from the next in.

async fn publish( &self, msg: OutgoingMessage<'_, &[u8]>, _options: Option<&()>, ) -> Result<(), Self::Error>

Publishes a message to the broker, with the per-message settings the call site adjusted.

fn base_headers(&self) -> Option<&HeaderMap>

The headers this publisher contributes to every message it sends, underneath whatever the message itself names.