Skip to main content

RuntimeStore

meerkat_runtime::store

Trait RuntimeStore 

Source 
pub trait RuntimeStore: Send + Sync {

Show 21 methods    // Required methods
    fn commit_session_snapshot<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        session_delta: SessionDelta,
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn atomic_apply<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        session_delta: Option<SessionDelta>,
        receipt: RunBoundaryReceipt,
        input_updates: Vec<InputStatePersistenceRecord>,
        session_store_key: Option<SessionId>,
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_input_states<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<StoredInputState>, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_boundary_receipt<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        run_id: &'life2 RunId,
        sequence: u64,
    ) -> Pin<Box<dyn Future<Output = Result<Option<RunBoundaryReceipt>, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn load_session_snapshot<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn clear_session_snapshot<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn replace_session_snapshot_if_current<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        expected_current: &'life2 [u8],
        replacement: Vec<u8>,
    ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn clear_session_snapshot_if_current<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        expected_current: &'life2 [u8],
    ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn persist_input_state<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        state: &'life2 InputStatePersistenceRecord,
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn load_input_state<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        input_id: &'life2 InputId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<StoredInputState>, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn load_machine_lifecycle_record<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn commit_machine_lifecycle<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        commit: MachineLifecycleCommit,
        input_states: &'life2 [InputStatePersistenceRecord],
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;

    // Provided methods
    fn auth_authority_key(&self) -> Option<String> { ... }
    fn persist_auth_oauth_flow_snapshot(
        &self,
        snapshot_json: &[u8],
    ) -> Result<(), RuntimeStoreError> { ... }
    fn load_auth_oauth_flow_snapshot(
        &self,
    ) -> Result<Option<Vec<u8>>, RuntimeStoreError> { ... }
    fn update_auth_oauth_flow_snapshot(
        &self,
        _update: &mut AuthOAuthFlowSnapshotUpdate<'_>,
    ) -> Result<(), RuntimeStoreError> { ... }
    fn commit_session_transcript_rewrite_snapshot<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        session_delta: SessionDelta,
        commit: &'life2 TranscriptRewriteCommit,
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn is_runtime_projection_quarantined<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
    ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn persist_ops_lifecycle<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        snapshot: &'life2 PersistedOpsSnapshot,
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn load_ops_lifecycle<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<PersistedOpsSnapshot>, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn delete_ops_lifecycle<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }

}
Expand description

Atomic persistence interface for runtime state.

Implementations:

  • InMemoryRuntimeStore — in-memory, no durability (ephemeral/testing)
  • SqliteRuntimeStore — SQLite-backed durable runtime state

Required Methods§

Source

fn commit_session_snapshot<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: SessionDelta, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically persist a session snapshot that is not a run boundary.

Session-control snapshots update durable session authority without producing a RunBoundaryReceipt.

Source

fn atomic_apply<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: Option<SessionDelta>, receipt: RunBoundaryReceipt, input_updates: Vec<InputStatePersistenceRecord>, session_store_key: Option<SessionId>, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically persist session delta + receipt + input state updates.

All three writes MUST commit in a single atomic operation. If any write fails, none should be visible. Atomically persist session delta + receipt + input state updates.

All writes MUST commit in a single atomic operation. If session_store_key is Some, validates that the snapshot belongs to that session and, for stores that physically share a SessionStore table, writes that table in the same transaction. Runtime snapshot authority remains keyed only by runtime_id; session_store_key must not create a raw session UUID runtime alias.

Source

fn load_input_states<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<StoredInputState>, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load all input states for a runtime.

Source

fn load_boundary_receipt<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, run_id: &'life2 RunId, sequence: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<RunBoundaryReceipt>, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load a specific boundary receipt.

Source

fn load_session_snapshot<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load the latest committed session snapshot for a runtime, if any.

Source

fn clear_session_snapshot<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove the latest committed session snapshot for a runtime.

This is used only as a fail-closed quarantine path after a compatibility projection write rejects a runtime snapshot that was already staged as runtime authority and the service cannot restore the previous snapshot.

Source

fn replace_session_snapshot_if_current<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected_current: &'life2 [u8], replacement: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Replace the latest committed session snapshot only if it still matches expected_current.

Used by fail-closed recovery after a compatibility projection rejected a runtime snapshot. Implementations must compare and write atomically so recovery cannot overwrite a newer runtime-authoritative snapshot.

Source

fn clear_session_snapshot_if_current<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected_current: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Remove the latest committed session snapshot only if it still matches expected_current.

This is the conditional variant of the fail-closed quarantine path.

Source

fn persist_input_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, state: &'life2 InputStatePersistenceRecord, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Persist a single input state (for durable-before-ack).

Source

fn load_input_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, input_id: &'life2 InputId, ) -> Pin<Box<dyn Future<Output = Result<Option<StoredInputState>, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load a single input state.

Source

fn load_machine_lifecycle_record<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load the last persisted machine lifecycle record bytes, if any.

Implementations return only the opaque bytes previously obtained from MachineLifecycleCommit::store_record. The runtime crate decodes these bytes through load_runtime_state or internal recovery helpers; stores must not promote compatibility rows or bare runtime states into lifecycle authority.

Source

fn commit_machine_lifecycle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, commit: MachineLifecycleCommit, input_states: &'life2 [InputStatePersistenceRecord], ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically commit machine-owned lifecycle state changes.

Writes runtime state, generated runtime binding facts, and all input state updates in a single atomic operation. MachineLifecycleCommit has no public constructor, so this cannot be used by compatibility callers to pick runtime truth.

Provided Methods§

Source

fn auth_authority_key(&self) -> Option<String>

Stable key for process-local auth/OAuth authority reuse across reopened handles for the same durable store.

Source

fn persist_auth_oauth_flow_snapshot( &self, snapshot_json: &[u8], ) -> Result<(), RuntimeStoreError>

Persist the runtime-owned OAuth login-flow payload snapshot.

The AuthMachine owns admission/consume semantics; this payload snapshot carries the PKCE verifier and device-code correlation data needed to rehydrate active flows after a persistent runtime process restart.

Source

fn load_auth_oauth_flow_snapshot( &self, ) -> Result<Option<Vec<u8>>, RuntimeStoreError>

Load the runtime-owned OAuth login-flow payload snapshot, if present.

Source

fn update_auth_oauth_flow_snapshot( &self, _update: &mut AuthOAuthFlowSnapshotUpdate<'_>, ) -> Result<(), RuntimeStoreError>

Atomically update the runtime-owned OAuth login-flow payload snapshot.

Stores that support OAuth snapshots must override this with a lock, transaction, or compare-and-swap boundary. A load/compute/persist fallback is not safe for admission, capacity, or consume claims.

Source

fn commit_session_transcript_rewrite_snapshot<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: SessionDelta, commit: &'life2 TranscriptRewriteCommit, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically persist a same-session transcript rewrite snapshot.

Store implementations that support transcript edits must compare the currently persisted session transcript revision with commit.parent_revision inside the same lock or transaction that writes session_delta.

Source

fn is_runtime_projection_quarantined<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Report whether the runtime-projection fallback for runtime_id is quarantined.

This is a durable single-owner fact: when clear_session_snapshot_if_current matches and DELETEs a rejected runtime snapshot, the same atomic boundary records the quarantine marker. A subsequent live snapshot write clears it. Recovery reads this to decide whether a store-only projection may stand in for an absent runtime snapshot. The default is fail-safe (false): stores that cannot record the marker durably never claim a snapshot is quarantined.

Source

fn persist_ops_lifecycle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, snapshot: &'life2 PersistedOpsSnapshot, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Persist a snapshot of the ops lifecycle registry state.

Source

fn load_ops_lifecycle<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Option<PersistedOpsSnapshot>, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load a previously persisted ops lifecycle snapshot.

Source

fn delete_ops_lifecycle<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a previously persisted ops lifecycle snapshot.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§