Struct FilePublisher 

pub struct FilePublisher { /* private fields */ }

Publishes messages into the stream file.

User headers travel in a text-safe envelope applied only when headers are present, so a file written without headers stays readable as a plain payload stream by other tools.

A publish carries no per-message settings: an append to a stream file 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.

A destination is a stream key inside the broker, and the file itself is named once, in FileBroker::new. The FilePublish page shows it in a service.

Examples

A reply type declares its stream key, and the subscriber carries the bare reply clause:

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

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

#[derive(Debug, Outgoing, Serialize)]
#[outgoing(name = "receipts")]
struct Receipt {
    order: u64,
}

#[subscriber(FileStream::new("orders"), reply)]
async fn confirm(order: &Order) -> Receipt {
    tracing::info!(order.id, "confirmed");
    Receipt { order: order.id }
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("orders", "0.1.0"))
        .with_broker(FileBroker::new("/tmp/orders.ss"), |b| {
            b.include(confirm).out_reply(Publish);
        })
}

Trait Implementations

impl Clone for FilePublisher

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 FilePublisher

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

Formats the value using the given formatter.

impl Publisher for FilePublisher

type Payload = Lend

The append reads the bytes and keeps nothing: the client’s send_to takes a slice, and the envelope this crate writes is a buffer of its own anyway.

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.