Development Documentation (main branch) - For stable release docs, see docs.rs/eidetica
Skip to main content

Backend

eidetica::instance::backend

Trait Backend 

Source 
pub trait Backend:
    Send
    + Sync
    + Debug {

Show 15 methods    // Required methods
    fn get<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 ID,
    ) -> Pin<Box<dyn Future<Output = Result<Entry>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn snapshot<'life0, 'life1, 'async_trait>(
        &'life0 self,
        tree: &'life1 ID,
    ) -> Pin<Box<dyn Future<Output = Result<Snapshot>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn store_snapshot<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        tree: &'life1 ID,
        store: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<Snapshot>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn store_snapshot_at<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tree: &'life1 ID,
        store: &'life2 str,
        main_snapshot: &'life3 Snapshot,
    ) -> Pin<Box<dyn Future<Output = Result<Snapshot>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn store_at<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tree: &'life1 ID,
        store: &'life2 str,
        snapshot: &'life3 Snapshot,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn find_merge_base<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tree: &'life1 ID,
        store: &'life2 str,
        entry_ids: &'life3 [ID],
    ) -> Pin<Box<dyn Future<Output = Result<ID>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn get_path_from_to<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        tree: &'life1 ID,
        store: &'life2 str,
        from_id: &'life3 ID,
        to_ids: &'life4 [ID],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn get_cached_crdt_state<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tree: &'life1 ID,
        entry_id: &'life2 ID,
        store: &'life3 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn cache_crdt_state<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        tree: &'life1 ID,
        entry_id: &'life2 ID,
        store: &'life3 str,
        state: Vec<u8>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn put<'life0, 'async_trait>(
        &'life0 self,
        entry: Entry,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn write_entry<'life0, 'async_trait>(
        &'life0 self,
        verification: VerificationStatus,
        entry: Entry,
        source: WriteSource,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_instance_metadata<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Option<InstanceMetadata>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_instance_metadata<'life0, 'life1, 'async_trait>(
        &'life0 self,
        metadata: &'life1 InstanceMetadata,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;

    // Provided methods
    fn local_engine(&self) -> Option<Arc<dyn BackendImpl>> { ... }
    fn remote_connection(&self) -> Option<RemoteConnection> { ... }

}
Expand description

The storage operations Transaction/Store/Database/Instance perform, independent of whether storage is in-process or served by a daemon.

Tree-scoped methods take the tree explicitly; the remote implementation uses the argument directly (callers already pass the owning database’s root), so no per-handle root needs to be bound. The only per-handle state a remote backend carries is its acting identity (see RemoteBackend).

Required Methods§

Source

fn get<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<Entry>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve an entry by ID.

Source

fn snapshot<'life0, 'life1, 'async_trait>( &'life0 self, tree: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<Snapshot>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Raw Snapshot of tree (no Verified-frontier filtering — that stays in Database).

Source

fn store_snapshot<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Snapshot>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Raw Snapshot of store within tree.

Source

fn store_snapshot_at<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, main_snapshot: &'life3 Snapshot, ) -> Pin<Box<dyn Future<Output = Result<Snapshot>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Store snapshot reachable as of a specific main-tree snapshot.

Source

fn store_at<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, snapshot: &'life3 Snapshot, ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Every entry of store reachable from snapshot.

Source

fn find_merge_base<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, entry_ids: &'life3 [ID], ) -> Pin<Box<dyn Future<Output = Result<ID>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Lowest common ancestor of entry_ids within store.

Source

fn get_path_from_to<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, from_id: &'life3 ID, to_ids: &'life4 [ID], ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Every entry on the path from from_id to each of to_ids within store.

Source

fn get_cached_crdt_state<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, entry_id: &'life2 ID, store: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Cached materialized CRDT state for (entry_id, store) within tree, if present. tree keys the daemon-side cache and gates the wire RPC; the local engine ignores it (it serves the trusted shared scope).

Source

fn cache_crdt_state<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, entry_id: &'life2 ID, store: &'life3 str, state: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Cache materialized CRDT state for (entry_id, store) within tree.

Source

fn put<'life0, 'async_trait>( &'life0 self, entry: Entry, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Persist an entry. Local stores it directly; remote submits it via DatabaseOp::SubmitSignedEntry (stored Unverified, server-verified).

Source

fn write_entry<'life0, 'async_trait>( &'life0 self, verification: VerificationStatus, entry: Entry, source: WriteSource, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Durably persist a signed entry, applying verification locally or submitting it over the wire. source informs local callback dispatch (handled by Instance::put_entry) and is unused on remote.

Source

fn get_instance_metadata<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<InstanceMetadata>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Public instance metadata (device identity, system database IDs).

Source

fn set_instance_metadata<'life0, 'life1, 'async_trait>( &'life0 self, metadata: &'life1 InstanceMetadata, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist public instance metadata.

Provided Methods§

Source

fn local_engine(&self) -> Option<Arc<dyn BackendImpl>>

The concrete in-process storage engine, if this is a local backend.

Off-seam local-only operations (instance secrets, verification-status mutation, all_roots/get_tree raw dumps, scope-keyed cache) are reached through this accessor, so they are usable only where a concrete local backend exists. Returns None for remote backends.

Source

fn remote_connection(&self) -> Option<RemoteConnection>

The remote connection, if this is a remote backend. Returns None for local backends.

Implementors§