Struct InMemoryStore 

pub struct InMemoryStore { /* private fields */ }

Correct non-durable crate::EventStore implementation for tests and backend equivalence.

Implementations

impl InMemoryStore

pub fn write_raw_worker_deployment( &self, name: &str, bytes: Vec<u8>, ) -> Result<(), StoreError>

Write backend bytes directly for persistence conformance testing.

This deliberately bypasses the entity codec so the shared suite can pin poisoned-row listing, replacement, and deletion behavior on every backend.

Errors

Returns StoreError::Serialization when name is empty or whitespace.

Trait Implementations

impl Debug for InMemoryStore

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

Formats the value using the given formatter.

impl Default for InMemoryStore

fn default() -> InMemoryStore

Returns the “default value” for a type.

impl NamespaceStore for InMemoryStore

fn register_namespace<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, origin: NamespaceOrigin, ) -> Pin<Box<dyn Future<Output = Result<MintOutcome, StoreError>> + Send + 'async_trait>>

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

Idempotent minted-on-use upsert.

fn put_namespace<'life0, 'async_trait>( &'life0 self, record: NamespaceRecord, ) -> Pin<Box<dyn Future<Output = Result<MintOutcome, StoreError>> + Send + 'async_trait>>

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

Explicit upsert (POST /namespaces).

fn list_namespaces<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<NamespaceRecord>, StoreError>> + Send + 'async_trait>>

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

Returns the live durable set, ascending by created_at (ties broken by name).

fn get_namespace<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<NamespaceRecord>, StoreError>> + Send + 'async_trait>>

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

Looks up a single namespace by name.

fn set_namespace_placement<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, placement: NamespacePlacement, ) -> Pin<Box<dyn Future<Output = Result<Option<()>, StoreError>> + Send + 'async_trait>>

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

Idempotent quorum-CAS update of an existing namespace’s placement directive (Control-Plane Phase 2, P2-P2).

fn deprecate_namespace<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Transitions a namespace from NamespaceState::Active to NamespaceState::Deprecated (deprecate-before-delete).

impl PackageStore for InMemoryStore

fn put_package<'life0, 'async_trait>( &'life0 self, record: PackageRecord, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Persists record and atomically points the type’s route at it.

fn put_package_with_routes<'life0, 'life1, 'async_trait>( &'life0 self, record: PackageRecord, route_workflow_types: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Persists record and atomically points every member workflow type at its content hash.

fn list_packages<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<PackageRecord>, StoreError>> + Send + 'async_trait>>

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

Lists every persisted package in ascending deployed_at order (ties broken by (workflow_type, content_hash) text order), so startup reload re-applies deploys deterministically.

fn delete_package<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, workflow_type: &'life1 str, content_hash: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Deletes the persisted archive for (workflow_type, content_hash).

fn put_package_route<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, workflow_type: &'life1 str, content_hash: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Upserts the route pointer for workflow_type to content_hash.

fn list_package_routes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<PackageRouteRecord>, StoreError>> + Send + 'async_trait>>

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

Lists every persisted route pointer in workflow_type text order.

impl ReadableEventStore for InMemoryStore

fn read_history<'life0, 'life1, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Event>, StoreError>> + Send + 'async_trait>>

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

Reads the complete event history for workflow_id in ascending sequence order.

fn read_history_from<'life0, 'life1, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, from_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<Event>, StoreError>> + Send + 'async_trait>>

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

Reads the event history for workflow_id restricted to events with sequence number greater than or equal to from_seq, in ascending sequence order.

fn read_run_chain<'life0, 'life1, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, ) -> Pin<Box<dyn Future<Output = Result<Vec<RunSummary>, StoreError>> + Send + 'async_trait>>

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

Reads the concrete run chain for workflow_id in continuation order.

fn list_workflow_ids<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkflowId>, StoreError>> + Send + 'async_trait>>

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

Lists every workflow identifier that has at least one event in history.

fn list_active<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkflowId>, StoreError>> + Send + 'async_trait>>

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

Lists workflow identifiers whose projected status is exactly WorkflowStatus::Running.

fn list_paused<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkflowId>, StoreError>> + Send + 'async_trait>>

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

Lists workflow identifiers whose projected status is exactly WorkflowStatus::Paused.

fn query<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 WorkflowFilter, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkflowSummary>, StoreError>> + Send + 'async_trait>>

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

Returns workflow summaries matching filter.

fn schedule_timer<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, timer_id: &'life2 TimerId, fire_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Persists a durable timer for workflow_id that is due at fire_at.

fn expired_timers<'life0, 'async_trait>( &'life0 self, as_of: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<Vec<TimerEntry>, StoreError>> + Send + 'async_trait>>

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

Returns durable timers whose fire_at is less than or equal to as_of.

fn set_owned_shards(&self, shards: Option<&[usize]>)

Restrict every per-workflow enumeration (active workflows, timers, outbox rows) to the named set of distribution shards this node owns, or restore the own-all-shards default when shards is None.

fn acquire_owned_shards(&self, shards: &[usize]) -> Result<(), StoreError>

Acquire-and-serve ownership of each named distribution shard BEFORE the boot path recovers or enumerates over them, so the node is the fenced owner and its replicated state is union-merged locally first.

fn acquire_owned_shard(&self, shard: usize) -> Result<(), StoreError>

Acquire-and-serve ownership of a SINGLE distribution shard — the per-shard primitive Self::acquire_owned_shards is a loop over, exposed so the failover path can drive a per-shard abort seam: a clean election loss on one shard (StoreError::NotOwner) drops only that shard rather than failing the whole adoption batch (ADR-021 clean-partial).

fn is_current_owner(&self, shard: usize) -> bool

Whether this node currently holds LIVE serve-authority for shard — it won the per-shard election THIS process lifetime and has not been deposed in-process.

fn extend_owned_shards(&self, shards: &[usize])

Add shards to this node’s owned-enumeration scope, UNIONING them with the shards it already owns rather than replacing the set.

fn publish_shard_owner(&self, shard: usize) -> Result<(), StoreError>

Publish THIS node as the current owner of shard in the cluster’s shard-owner directory, so other nodes’ request-routing edges resolve shard to this node (SS-3).

impl VisibilityStore for InMemoryStore

fn record_visibility<'life0, 'async_trait>( &'life0 self, record: VisibilityRecord, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Upserts a workflow visibility record.

fn list_workflows<'life0, 'async_trait>( &'life0 self, filter: ListWorkflowsFilter, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkflowSummary>, StoreError>> + Send + 'async_trait>>

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

Lists workflow visibility summaries matching filter.

fn count_workflows<'life0, 'async_trait>( &'life0 self, filter: ListWorkflowsFilter, ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>

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

Counts workflow visibility summaries matching filter.

impl WorkerDeploymentStore for InMemoryStore

fn put_worker_deployment<'life0, 'async_trait>( &'life0 self, record: WorkerDeployment, ) -> Pin<Box<dyn Future<Output = Result<WorkerDeploymentPutResult, StoreError>> + Send + 'async_trait>>

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

Create or replace a deployment record, returning the exact persisted value.

fn get_worker_deployment<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<WorkerDeployment>, StoreError>> + Send + 'async_trait>>

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

Look up one deployment by name.

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

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

List decodable deployments and report every undecodable key, with both sets ordered by primary-key name.

fn set_desired_state<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, desired: DesiredState, ) -> Pin<Box<dyn Future<Output = Result<Option<WorkerDeployment>, StoreError>> + Send + 'async_trait>>

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

Set desired state on an existing record, returning None when absent.

fn delete_worker_deployment<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<WorkerDeploymentDeleteOutcome, StoreError>> + Send + 'async_trait>>

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

Atomically remove a row by key without requiring it to decode.

impl WritableEventStore for InMemoryStore

fn append<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _token: WriteToken, workflow_id: &'life1 WorkflowId, events: &'life2 [Event], expected_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Atomically appends events to workflow_id when the stored history head equals expected_seq.

fn append_with_outbox<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, token: WriteToken, workflow_id: &'life1 WorkflowId, events: &'life2 [Event], expected_seq: u64, outbox_rows: &'life3 [OutboxRow], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Atomically appends events and the durable-outbox outbox_rows for workflow_id in a single transaction, under the same expected-head sequence guard as Self::append.

fn rearm_outbox_pending<'life0, 'life1, 'async_trait>( &'life0 self, rows: &'life1 [OutboxRow], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Returns the outbox rows for rows’ dispatch_keys to Pending, re-staging them for the out-of-band dispatcher.

fn settle_outbox_row_cancelled<'life0, 'life1, 'async_trait>( &'life0 self, dispatch_key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Idempotently settles one outbox row to cancelled when this writer is backed by an outbox.

fn settle_workflow_outbox_rows_cancelled<'life0, 'life1, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StoreError>> + Send + 'async_trait>>

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

Idempotently settles EVERY live (crate::OutboxStatus::Pending or crate::OutboxStatus::Claimed) outbox row of workflow_id to crate::OutboxStatus::Cancelled, returning the settled dispatch_keys (#253).