Struct ServerStore 

pub struct ServerStore { /* private fields */ }

A client substrate over a remote gonzalo daemon.

Implementations

impl ServerStore

pub fn http(base_url: &str) -> Result<Self>

Talk to the daemon’s HTTP/JSON API rooted at base_url.

pub fn http_with_token(base_url: &str, token: impl Into<String>) -> Result<Self>

As ServerStore::http, sending a bearer token on every request.

pub async fn grpc(endpoint: String) -> Result<Self>

Talk to the daemon’s gRPC API at endpoint (e.g. http://host:50051).

pub async fn grpc_with_token( endpoint: String, token: impl Into<String>, ) -> Result<Self>

As ServerStore::grpc, sending a bearer token on every call.

Trait Implementations

impl BlobStore for ServerStore

fn has_blob<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 ContentHash, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Presence over the wire, without the bytes.

The trait default fetches the blob and discards it, which over a daemon means a full download per newly referenced blob on every commit — 600 KB a shard for a vector index (ADR 0028, #329). HEAD /v1/blobs/{hash} and the HasBlob RPC answer from the daemon’s own presence check instead.

A 404 is false, not an error: absence is the answer, not a failure.

fn put_blob<'life0, 'life1, 'async_trait>( &'life0 self, content: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<ContentHash>> + Send + 'async_trait>>

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

Store content addressed by its hash, write-if-absent, and return the hash. Idempotent: storing identical content again is a no-op.

fn get_blob<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 ContentHash, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>

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

Fetch blob content by hash, or None if absent.

fn list_blobs<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlobEntry>>> + Send + 'async_trait>>

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

Every stored blob with the time it was last written. Order is unspecified, and a hash may repeat — a caller that cares resolves a duplicate to its newest timestamp. Used by GC to enumerate candidates and decide which are old enough to sweep (ADR 0024, 0028).

fn delete_blob<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 ContentHash, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Delete the blob addressed by hash. Deleting an absent blob is an idempotent no-op — GC may race another sweeper or a re-put.

impl Store for ServerStore

fn delete_as<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, expected: Option<Revision>, author: Option<Identity>, ) -> Pin<Box<dyn Future<Output = Result<DeleteResult>> + Send + 'async_trait>>

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

Sends the delete with its author. The daemon honours a named deleter only for an admin credential or open mode; a non-admin token is always stamped as itself (ADR 0015, gonzalo#203).

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, ) -> Pin<Box<dyn Future<Output = Result<Option<Record>>> + Send + 'async_trait>>

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

Fetch a record by key. Returns None for an absent key and for a tombstoned one: a delete is invisible on this surface, and only get_raw shows the tombstone. See ADR 0021.

fn put<'life0, 'async_trait>( &'life0 self, record: Record, expected: Option<Revision>, ) -> Pin<Box<dyn Future<Output = Result<PutResult>> + Send + 'async_trait>>

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

Conditionally write record. expected is the revision the caller believes is current (None means “expect no existing record”). If the store’s current revision differs, returns PutResult::Conflict.

fn list<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 KeyPrefix, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordKey>>> + Send + 'async_trait>>

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

List keys matching prefix, excluding tombstoned keys. See list_raw for a listing that includes them.

fn get_raw<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, ) -> Pin<Box<dyn Future<Output = Result<Option<Record>>> + Send + 'async_trait>>

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

Like get, but also returns tombstones. For replication (sync, pull, collection) only: consumers must use get. A store must never implement this by calling get, which would hide the deletions replication exists to carry. See ADR 0021.

fn list_raw<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 KeyPrefix, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordKey>>> + Send + 'async_trait>>

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

Like list, but also includes tombstoned keys. For replication only. See ADR 0021.

fn put_raw<'life0, 'async_trait>( &'life0 self, record: Record, expected: Option<Revision>, ) -> Pin<Box<dyn Future<Output = Result<PutResult>> + Send + 'async_trait>>

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

Replication write: store record exactly as given, never re-stamping. A create (expected == None) that finds anything stored, tombstones included, is a Conflict carrying it. Sync and pull use this; consumers must use put. A store must never implement this by calling put, whose recreation rule would resurrect records mid-sync. See ADR 0021.

fn purge<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, expected: Revision, ) -> Pin<Box<dyn Future<Output = Result<DeleteResult>> + Send + 'async_trait>>

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

Physically remove the record at key only if its current revision is expected; otherwise DeleteResult::Conflict. Absent is an idempotent Deleted. The only physical removal in the system: used by tombstone collection, which must pass the tombstone’s revision so a record recreated in the meantime survives. See ADR 0021.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, expected: Option<Revision>, ) -> Pin<Box<dyn Future<Output = Result<DeleteResult, CoreError>> + Send + 'async_trait>>

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

delete_as without an author. Provided; stores implement delete_as.