Struct CountingStore 

pub struct CountingStore<S> { /* private fields */ }

A DurableStore that forwards every method to S and counts the work.

Counter increments take no lock and allocate nothing. An installed observer receives the increment and explicit flush call; every await is the inner store’s.

Implementations

impl<S: DurableStore> CountingStore<S>

pub fn new(inner: S) -> Self

Wraps inner, with every counter at zero.

pub fn handle(&self) -> StoreCountsHandle

A handle that reads this store’s counters, to be kept beside the store once it is held only as Arc<dyn DurableStore>.

pub fn snapshot(&self) -> StoreCounts

Every counter as it stands now.

Each counter is read once, without a lock, so a snapshot taken while other calls are in flight may count a call whose rows it does not yet count. Between two steps of one journey nothing is in flight.

Trait Implementations

impl<S: Debug> Debug for CountingStore<S>

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

Formats the value using the given formatter.

impl<S: DurableStore> DurableStore for CountingStore<S>

fn apply_routed_entries<'life0, 'life1, 'async_trait>( &'life0 self, route_key: &'life1 str, entries: Vec<RoutedBatchEntry>, ) -> Pin<Box<dyn Future<Output = Result<(), DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Counted as a routed batch: one call, and every entry (a put or a delete) an item of it once it committed.

fn reclaim_spine(&self) -> Option<Arc<EventStore>>

The haematite store behind this one, when it is the spine opened from disk: the owner releases its held reclaim, watches its passes and reads its status through it (DUR-021). A store that is not the spine answers None.

fn max_request_bytes(&self) -> Option<usize>

The largest request this store admits, in bytes, or None when it names no bound (DUR-024 R2). A caller assembling a batch keeps each request under it; the bound is read here, from the open store, and is never assumed or learnt from a refusal.

fn apply_routed_batch<'life0, 'life1, 'async_trait>( &'life0 self, route_key: &'life1 str, items: Vec<RoutedBatchItem>, ) -> Pin<Box<dyn Future<Output = Result<(), DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Commits all conditional replacements on one route, or publishes none.

fn get_routed<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, route_key: &'life1 str, key: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Reads one key from the route used by the atomic writer.

fn append<'life0, 'life1, 'async_trait>( &'life0 self, stream_key: &'life1 str, payload: Vec<u8>, expected_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<u64, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Appends payload to stream_key if expected_seq matches the stream head.

fn read_from<'life0, 'life1, 'async_trait>( &'life0 self, stream_key: &'life1 str, offset: u64, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<StoredEntry>, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads entries from stream_key beginning at offset, up to limit entries.

fn append_all<'life0, 'life1, 'async_trait>( &'life0 self, stream_key: &'life1 str, payloads: Vec<Vec<u8>>, expected_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<u64, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically appends all payloads in order, starting at the expected head, and returns the stream’s next sequence.

fn read_at<'life0, 'life1, 'async_trait>( &'life0 self, stream_key: &'life1 str, sequence: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<StoredEntry>, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads exactly the event at sequence without traversing its suffix.

fn cas<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, old_value: u64, new_value: u64, ) -> Pin<Box<dyn Future<Output = Result<(), DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically replaces a stored numeric value if it equals old_value.

fn read_stream_next_seq<'life0, 'life1, 'async_trait>( &'life0 self, stream_key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads the exclusive append head without reading stream rows.

fn read_value<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads a numeric value previously updated through compare-and-swap.

fn scan_page<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 str, cursor: Option<ScanCursor>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<ScanPage, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads one page of at most limit entries from the streams whose keys begin with prefix, in byte order of stream key and then sequence.

fn flush<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Flushes buffered writes so completed durable operations are persisted.

fn truncate_before<'life0, 'life1, 'async_trait>( &'life0 self, stream_key: &'life1 str, before_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<u64, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Deletes every entry of stream_key with sequence below before_seq, in one commit, and returns how many were deleted. Later entries are untouched, the stream’s head is kept (an append continues where it would have, and no sequence is reused), and a second identical call deletes nothing and returns 0.

fn scan_routed<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, route_key: &'life1 str, from: &'life2 [u8], to: &'life3 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<(Vec<u8>, Vec<u8>)>, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Reads the routed keys of one window on a route, with their values.

fn remove_routed_range<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, route_key: &'life1 str, from: &'life2 [u8], to: &'life3 [u8], ) -> Pin<Box<dyn Future<Output = Result<u64, DurabilityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Deletes the routed keys of one window on a route in one commit.

fn store_counts(&self) -> Option<StoreCountsHandle>

A reader of the counters of the work done through this store, when the store counts it.