Skip to main content

RuntimeStore

meerkat_runtime::store

Trait RuntimeStore 

Source 
pub trait RuntimeStore: Send + Sync {
    // Required methods
    fn commit_session_boundary<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        session_delta: SessionDelta,
        run_id: RunId,
        boundary: RunApplyBoundary,
        contributing_input_ids: Vec<InputId>,
        input_updates: Vec<InputState>,
    ) -> Pin<Box<dyn Future<Output = Result<RunBoundaryReceipt, 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<InputState>,
        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<InputState>, 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 InputState,
    ) -> 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<InputState>, RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn persist_runtime_state<'life0, 'life1, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        state: RuntimeState,
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: '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 atomic_lifecycle_commit<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        runtime_id: &'life1 LogicalRuntimeId,
        runtime_state: RuntimeState,
        input_states: &'life2 [InputState],
    ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
}
Expand description

Atomic persistence interface for runtime state.

Implementations:

  • InMemoryRuntimeStore — in-memory, no durability (ephemeral/testing)
  • RedbRuntimeStore — shared redb database, single-transaction atomicity (Phase 4)

Required Methods§

Source

fn commit_session_boundary<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: SessionDelta, run_id: RunId, boundary: RunApplyBoundary, contributing_input_ids: Vec<InputId>, input_updates: Vec<InputState>, ) -> Pin<Box<dyn Future<Output = Result<RunBoundaryReceipt, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically persist session delta + authoritative receipt + input state updates.

The receipt MUST be minted by the durable commit seam itself, not by the caller, so returned success carries the exact proof that was stored.

Source

fn atomic_apply<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: Option<SessionDelta>, receipt: RunBoundaryReceipt, input_updates: Vec<InputState>, 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, also writes the session snapshot to the sessions table (the same table SessionStore uses), providing a unified boundary commit across both stores.

Source

fn load_input_states<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<InputState>, 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 InputState, ) -> 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<InputState>, RuntimeStoreError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load a single input state.

Source

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

Persist the runtime state itself (for durable retire/stop semantics).

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 atomic_lifecycle_commit<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, runtime_state: RuntimeState, input_states: &'life2 [InputState], ) -> 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 lifecycle state changes (retire/reset/stop/destroy).

Writes runtime state + all input state updates in a single atomic operation. Used for lifecycle ops that don’t produce boundary receipts.

Implementors§