Struct MemorySource 

pub struct MemorySource { /* private fields */ }

In-memory Source driven entirely by its SourceHandle.

Trait Implementations

impl Debug for MemorySource

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

Formats the value using the given formatter.

impl Source for MemorySource

fn component_type(&self) -> &str

Scopes the source’s own metric families under spate_memory_source_*.

type Lane = MemoryLane

The lane type this source produces.

fn open(&mut self, ctx: SourceCtx) -> Result<(), SourceError>

Connect and prepare. Called once before any other method.

fn poll_events( &mut self, timeout: Duration, ) -> Result<SourceEvent<MemoryLane>, SourceError>

Service control-plane work (rebalance callbacks, statistics) and return the next event, waiting at most timeout. Must be called regularly regardless of backpressure state.

fn commit( &mut self, watermarks: &[(PartitionId, i64)], ) -> Result<(), SourceError>

Store per-partition committable positions (each is the offset one past the last acknowledged record). Positions are durable per the source’s own policy (e.g. interval auto-commit of stored offsets).

fn flush_commits(&mut self) -> Result<(), SourceError>

Synchronously flush stored positions (shutdown, revocation).

fn pause(&mut self, lanes: &[LaneId]) -> Result<(), SourceError>

Stop fetching for lanes (backpressure). Optional capability: sources that cannot pause rely on bounded-queue pushback alone.

fn resume(&mut self, lanes: &[LaneId]) -> Result<(), SourceError>

Resume fetching for lanes.

fn framing_contract(&self) -> FramingContract

How the payloads this source emits are framed, so the framework can pair it with a deserializer without the two being coordinated by hand (see FramingContract). A source that splits its own bytes into one record per payload returns FramingContract::PerRecord; the default is FramingContract::WholePayload, where the source emits whole payloads and the deserializer owns framing (Kafka, and any source that does not frame).

fn configure_feed( &mut self, section: &FeedSection, feed: Arc<dyn Feed>, origin: FeedOrigin, ) -> Result<(), ConfigError>

Accept the pipeline’s feed: section and the feed it names. The runtime calls this once, before open and before the pipeline threads start, and only when the section is present.

fn renew_held(&mut self)

Renew the feed units the source holds, and nothing else.

fn reading_on_stop(&mut self) -> bool

Whether the source is still reading units it holds after a graceful stop began. The controller asks on each pass between the stop and the drain, and begins the drain on the first false or at STOP_RESERVE before the deadline. Never waits. The default returns false, so the drain begins at once.

fn stop_reading(&mut self) -> Result<(), SourceError>

End the stop’s reading: hand back every unit not read to its end. Called once, after the last reading_on_stop on a graceful stop, or at once when the run fails, and before the pipeline threads drain. Never waits. The default does nothing.