Struct FileSubscriber 

pub struct FileSubscriber { /* private fields */ }

A subscription to one stream key in the file; yields FileMessages.

Dropping the subscriber stops the driver task. The stream also ends on its own when the file does: a replay reaches the end of what was retained, and a live subscription reaches the end-of-stream mark a writer left with end_with_eos. A replay that ended can still be moved by its seeker until the subscriber is dropped, and its stream then delivers again.

A handler taking &[T] consumes batches of this subscription, and batch(n) at the mount site says how large one may be. The client reads one entry at a time, so the batch is assembled here: it holds at most the size the mount site named, and fewer when that is all the file had. A partial batch goes out 10 ms after its first delivery. The Batches page shows it in a service.

Examples

use ruststream_sea_file::file::prelude::*;
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Reading {
    millivolts: u32,
}

#[subscriber(FileStream::new("readings"))]
async fn aggregate(batch: &[Reading]) -> Vec<HandlerOutcome> {
    let total: u32 = batch.iter().map(|reading| reading.millivolts).sum();
    tracing::info!(readings = batch.len(), total, "aggregated");
    batch.iter().map(|_| HandlerOutcome::ack()).collect()
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("readings", "0.1.0"))
        .with_broker(FileBroker::new("/tmp/readings.ss"), |b| {
            b.include(aggregate.batch(nonzero!(4)))
                .max_attempts(nonzero!(3u32))
                .dead_letter("readings.dead");
        })
}

Implementations

impl FileSubscriber

pub fn stream_key(&self) -> &str

The stream key this subscription consumes.

Trait Implementations

impl BatchSubscriber for FileSubscriber

type Batch = Vec<FileMessage>

Container yielded by batches. Implementations choose between Vec, custom iterators, or anything else that yields the underlying Subscriber::Message.

fn batches( &mut self, size: NonZeroUsize, ) -> impl Stream<Item = Result<Self::Batch, SeaFileError>> + Send + '_

Returns a stream of batches of at most size messages.

impl Debug for FileSubscriber

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

Formats the value using the given formatter.

impl Seekable for FileSubscriber

type Seeker = FileSeeker

The handle usable while this subscriber’s stream is running.

fn seeker(&self) -> FileSeeker

Mints a handle for repositioning this subscription.

impl Subscriber for FileSubscriber

type Message = FileMessage

The message type yielded by this subscriber.

type Error = SeaFileError

The error type yielded by the stream when delivery fails.

fn stream( &mut self, ) -> impl Stream<Item = Result<FileMessage, SeaFileError>> + Send + '_

Returns a stream of broker deliveries.