Struct MemorySeeker 

pub struct MemorySeeker { /* private fields */ }

A clonable handle repositioning one MemorySubscriber, minted by Seekable::seeker before the subscription’s stream is opened.

The scope is that one subscription instance: other subscribers of the same name are unaffected. After the bus shuts down, seek reports MemoryError::ShutDown like any other aliased handle.

Examples

use ruststream::Seeker;
use ruststream::memory::prelude::*;
use serde::Deserialize;

#[derive(Deserialize)]
struct Job {
    id: u64,
    poisoned_until: Option<usize>,
}

/// Skips forward past a region the producer marked poisoned.
#[subscriber("jobs")]
async fn work(job: &Job, Ctx(seeker): Ctx<SeekHandle>) -> HandlerOutcome {
    if let Some(resume_at) = job.poisoned_until {
        if seeker
            .seek(MemoryPosition::sequence(resume_at))
            .await
            .is_err()
        {
            return HandlerOutcome::retry();
        }
    }
    tracing::info!(job.id, "done");
    HandlerOutcome::ack()
}

fn app() -> RustStream {
    let broker = MemoryBroker::retaining(Retention::Messages(nonzero!(1024)));
    RustStream::new(AppInfo::new("jobs", "0.1.0")).with_broker(broker, |b| {
        b.include(work);
    })
}

Trait Implementations

impl Clone for MemorySeeker

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 MemorySeeker

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

Formats the value using the given formatter.

impl Seeker for MemorySeeker

fn seek( &self, to: MemoryPosition, ) -> impl Future<Output = Result<(), MemoryError>>

Records the reposition and wakes the subscription; the stream applies it at the top of its next poll, so once this resolves the next delivery reflects the new position.

Under a TestApp the reposition counts as in-flight work until the subscription applies it, so driving the service to a standstill waits for the replay instead of racing the poll that produces it.

Errors

Returns MemoryError::ShutDown through a handle aliasing a shut-down bus, and MemoryError::PositionEvicted for a sequence the retention bound has already dropped.

type Position = MemoryPosition

The broker’s own position type (Kafka partition offsets, a Redis entry id, a byte offset), constructed by the broker crate or captured from a delivered message via Positioned::position.

type Error = MemoryError

The error returned when the broker rejects the reposition.