Skip to main content

RuntimeStore

meerkat_runtime::store

Trait RuntimeStore 

Source 
pub trait RuntimeStore: Send + Sync {

Show 15 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<StoredInputState>,
        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 persist_input_state<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        state: &'life2 StoredInputState,
    ) -> 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_runtime_state<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<RuntimeState>, 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 [StoredInputState],
    ) -> 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 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 { ... }

}
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<StoredInputState>, 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 persist_input_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, state: &'life2 StoredInputState, ) -> 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_runtime_state<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Option<RuntimeState>, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load the last persisted runtime state, if any.

Source

fn commit_machine_lifecycle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, commit: MachineLifecycleCommit, input_states: &'life2 [StoredInputState], ) -> 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 + 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 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.

Implementors§