Struct InMemorySessionStore 

pub struct InMemorySessionStore { /* private fields */ }

Implementations

impl InMemorySessionStore

pub fn new() -> Self

pub fn with_clock(clock: Arc<dyn Clock>) -> Self

Trait Implementations

impl AttachmentManifest for InMemorySessionStore

fn record_intent(&self, _intent: AttachmentIntent) -> Result<(), StoreError>

fn commit_refs( &self, _session_id: &str, _attachment_ids: &[AttachmentId], ) -> Result<(), StoreError>

Mark a set of attachment ids as committed (i.e. now referenced by a durable session-graph commit). Backends that store commits and manifest in the same database stamp this inside the commit transaction; the trait-level method is the out-of-band entry point for hosts that want to commit an id outside the normal turn-commit flow.

fn list_uncommitted( &self, _older_than_epoch_ms: u64, ) -> Result<Vec<AttachmentManifestEntry>, StoreError>

Return manifest entries whose intent has aged past older_than_epoch_ms without ever being committed. Hosts run this periodically to find orphans left by crashes between record_intent and the next turn commit.

fn forget(&self, _attachment_id: &AttachmentId) -> Result<(), StoreError>

Remove a manifest row entirely. Called by the GC coordinator after the corresponding bytes have been removed from the backing AttachmentStore.

impl Default for InMemorySessionStore

fn default() -> Self

Returns the “default value” for a type.

impl QueuedWorkStore for InMemorySessionStore

fn enqueue_queued_work<'life0, 'async_trait>( &'life0 self, batch: QueuedWorkBatchDraft, ) -> Pin<Box<dyn Future<Output = Result<QueuedWorkBatch, StoreError>> + Send + 'async_trait>>

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

Persist a queued-work batch for later claiming.

fn claim_leading_ready_session_command<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<QueuedWorkClaim>, StoreError>> + Send + 'async_trait>>

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

Claim a leading ready session-command batch for owner_id.

fn claim_ready_queued_work<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, boundary: QueuedWorkClaimBoundary, lease_ttl_ms: u64, max_batches: usize, ) -> Pin<Box<dyn Future<Output = Result<Option<QueuedWorkClaim>, StoreError>> + Send + 'async_trait>>

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

Claim the next ready turn-work group for owner_id.

fn renew_queued_work_claim<'life0, 'life1, 'async_trait>( &'life0 self, claim: &'life1 QueuedWorkClaim, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<QueuedWorkClaim, StoreError>> + Send + 'async_trait>>

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

Extend the lease on a held queued-work claim.

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

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

Release a held queued-work claim without completing it.

fn cancel_queued_work_batch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, batch_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<QueuedWorkBatch>, StoreError>> + Send + 'async_trait>>

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

Remove an unclaimed queued-work batch from durable ingress.

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

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

List all queued-work batches for a session, including batches held by a live claim.

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

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

List queued-work batches that are still pending presentation/editing.

fn claim_ready_queued_work_by_batch_ids<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, boundary: QueuedWorkClaimBoundary, lease_ttl_ms: u64, batch_ids: &'life4 [String], ) -> Pin<Box<dyn Future<Output = Result<Option<QueuedWorkClaim>, StoreError>> + Send + 'async_trait>>

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

Claim a specific ready batch set selected from the durable queue.

impl SessionCommitStore for InMemorySessionStore

fn load_session<'life0, 'async_trait>( &'life0 self, scope: SessionReadScope, ) -> Pin<Box<dyn Future<Output = Result<Option<PersistedSessionRead>, StoreError>> + Send + 'async_trait>>

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

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

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

fn commit_runtime_state<'life0, 'async_trait>( &'life0 self, commit: RuntimeCommit, ) -> Pin<Box<dyn Future<Output = Result<RuntimeCommitResult, StoreError>> + Send + 'async_trait>>

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

fn save_session_meta<'life0, 'async_trait>( &'life0 self, meta: SessionMeta, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

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

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

fn durability_tier(&self) -> DurabilityTier

Durability tier this session store provides; defaults to DurabilityTier::Inline.

impl SessionExecutionLeaseStore for InMemorySessionStore

fn try_claim_session_execution_lease<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, owner: &'life2 LeaseOwnerIdentity, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<SessionExecutionLeaseClaimOutcome, StoreError>> + Send + 'async_trait>>

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

Try to claim the durable single-writer execution lane for session_id.

fn reclaim_session_execution_lease<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 str, owner: &'life2 LeaseOwnerIdentity, observed_holder: &'life3 SessionExecutionLeaseFence, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<SessionExecutionLeaseClaimOutcome, StoreError>> + Send + 'async_trait>>

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

Reclaim an unexpired session execution lease whose observed holder is definitely dead according to persisted local-process liveness metadata.

fn renew_session_execution_lease<'life0, 'life1, 'async_trait>( &'life0 self, fence: &'life1 SessionExecutionLeaseFence, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<SessionExecutionLease, StoreError>> + Send + 'async_trait>>

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

Extend a live session execution lease owned by the caller.

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

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

Release a session execution lease fenced by its completion token.

impl StoreMaintenance for InMemorySessionStore

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

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

Mark graph nodes as tombstoned so reads exclude them until vacuum physically removes them.

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

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

Physically delete tombstoned graph-node rows and prune terminal pending-turn-input evidence rows. See VacuumReport.

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

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

Delete blobs no longer reachable from any retained root.

impl TurnInputStore for InMemorySessionStore

fn enqueue_pending_turn_input<'life0, 'async_trait>( &'life0 self, draft: PendingTurnInputDraft, ) -> Pin<Box<dyn Future<Output = Result<PendingTurnInput, StoreError>> + Send + 'async_trait>>

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

Persist model-visible user input into the pending turn-input lifecycle.

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

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

List pending user inputs for UI reconciliation and queue preview.

fn cancel_pending_turn_inputs<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, targets: &'life2 [PendingTurnInputCancelTarget], ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingTurnInputCancelResult>, StoreError>> + Send + 'async_trait>>

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

Atomically cancel a list of pending user inputs by input id or source key.

fn cancel_pending_turn_input_suffix<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, anchor: &'life2 PendingTurnInputCancelTarget, ) -> Pin<Box<dyn Future<Output = Result<PendingTurnInputSuffixCancelOutcome, StoreError>> + Send + 'async_trait>>

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

Atomically cancel the same-session runtime-admission suffix from an anchor.

fn claim_active_turn_inputs<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, turn_id: &'life4 str, checkpoint: CheckpointKind, lease_ttl_ms: u64, max_inputs: usize, ) -> Pin<Box<dyn Future<Output = Result<Option<TurnInputClaim>, StoreError>> + Send + 'async_trait>>

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

Claim active-turn input at a checkpoint for the live turn id.

fn claim_next_turn_inputs<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, lease_ttl_ms: u64, max_inputs: usize, ) -> Pin<Box<dyn Future<Output = Result<Option<TurnInputClaim>, StoreError>> + Send + 'async_trait>>

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

Claim queued next-turn input at idle.

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

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

Abandon a held pending-turn-input claim so it can be reclaimed.

fn cancel_pending_turn_input<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, input_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<PendingTurnInputCancelOutcome, StoreError>> + Send + 'async_trait>>

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

Cancel an unclaimed pending user input by id.