Struct FeedSource 

pub(crate) struct FeedSource {
    broker: Arc<Broker>,
    filestore: Arc<FileStore>,
    global_store: Option<Arc<FileStore>>,
    mstore: Arc<Store>,
    hub: Arc<FeedHub>,
    block_id: String,
}

Where a feed reads its agent’s transcript from.

Fields

broker: Arc<Broker>

filestore: Arc<FileStore>

global_store: Option<Arc<FileStore>>

mstore: Arc<Store>

hub: Arc<FeedHub>

block_id: String

Implementations

impl FeedSource

pub(crate) fn of(state: &AppState, block_id: &str) -> Self

async fn read( &self, offset: u64, expect_gen: &str, tail: bool, ) -> Option<BlockfileReadRangeResult>

async fn position(&self) -> Option<(String, String, u64)>

async fn snapshot(&self) -> Option<Snapshot>

The tail, through the bounded range read. Retried when the transcript is replaced between the count and the read; None if it keeps moving or can’t be read.

async fn resume(&self, gen: &str, line: u64) -> Option<(Cursor, Vec<String>)>

The lines from line on, for a reconnect that sent gen:line: None when the transcript has another generation now, or more has been written since than a stream may fall behind by (a snapshot then).

async fn catch_up(&self, cursor: &mut Cursor) -> CatchUp

Lines of the agent’s shared transcript past cursor that no event of this block brought: another block, or another srv instance, running the same agent wrote them, or this block’s append didn’t say where it landed in the shared stream. Moves the cursor past what it returns. Lines an event brings later are then skipped by line number (feed::apply_append), so nothing is sent twice.

A cursor on the block’s own transcript is left to its events, unless the transcript is now read from another stream: the agent’s shared transcript started after the snapshot (another srv instance may have begun it, and its appends reach no event here).