Struct Subscription

pub struct Subscription<Repo> {
    pub repo: Repo,
    pub id: Uuid,
    pub name: SubscriptionName,
    pub target_stream: SubscriptionName,
}

A subscription to a stream of events. Subscriptions read events from a target stream and manage a tracking stream to measure their progress. Subscriptions generate their own ids when they are created, meaning every subscription is unique and replays the target stream from the beginning. In order to avoid replaying the target stream, use the Subscription::resume method and give it the id of an existing subscription.

Fields

repo: Repo

The given repository that the subscriber reads from.

id: Uuid

The id of the subscription. This is used to track the subscription’s progress.

name: SubscriptionName

The name of the stream that this connection marks reads in. This is essentially the identity of the connection. Changing this will cause the connection to read from the beginning of the target stream. The name of the stream that the subscriber tracks its reads in. This is more or less the identity of the subscriber. Changing this will cause the subscriber to read from the beginning of the target stream.

target_stream: SubscriptionName

The name of the stream that this connection is reading from. The connection will ignore events from other streams.

Implementations

impl<Repo> Subscription<Repo>

where Repo: EventRepo + Clone,

pub fn init(repo: &Repo, name: impl SubscriptionTopic) -> Result<Self, String>

Create a new subscription to a stream of events, generating a new id for the subscription.

pub fn resume( repo: &Repo, id: Uuid, name: impl SubscriptionTopic, ) -> Result<Self, String>

Resume a subscription to a stream of events, using the given id to track the subscription’s progress. Use this to avoid replaying the target stream entirely, instead picking up at the last read position.

pub fn stream(&self) -> SubscriptionStream

where Repo: Clone + Send + Sync + 'static,

Turn the subscription into a background process that you can listen to asynchronously. This returns a SubscriptionStream that you can use to listen to the subscription, and manipulate with [StreamExt] methods.

pub fn worker<FrameService>( &self, service: FrameService, ) -> Result<SubscriptionWorker, EventRepoError>

where Repo: Clone + Send + Sync + 'static, FrameService: Service<Frame> + Send + Sync + 'static, FrameService::Future: Send, <FrameService as Service<Frame>>::Response: Into<Frame>, <FrameService as Service<Frame>>::Error: Into<Frame>,

Create a background process and process all pending events in the target stream using the given frame service.

pub async fn call_with_service<FrameService>( &self, service: FrameService, ) -> Result<(), EventRepoError>

where Repo: Clone + Send + Sync + 'static, FrameService: Service<Frame> + Send + Sync + 'static, FrameService::Future: Send,

Process all pending events in the target stream.

pub async fn last_read_position(&self) -> i64

Get the last read position for a subscriber.

pub async fn pending_events(&self) -> Result<EventLog, EventRepoError>

Get all of the events in the target stream that have occurred since the last read marker.

pub async fn poll_events(&self) -> Result<EventLog, EventRepoError>

where Repo: Clone + Send + Sync + 'static,

Poll for any pending events in the target stream.

pub async fn log_last_read(&self, position: i64) -> Result<(), EventRepoError>

Log the last read position for a subscriber. This leverages markers.

Trait Implementations

impl<Repo: Clone> Clone for Subscription<Repo>

fn clone(&self) -> Subscription<Repo>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Repo: Debug> Debug for Subscription<Repo>

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

Formats the value using the given formatter.