Struct S3Store 

pub struct S3Store { /* private fields */ }

Implementations

impl S3Store

pub fn new(client: Client, bucket: impl Into<String>) -> Self

Build a store from an explicit client and bucket. Use S3Store::connect for the common env/endpoint path.

pub fn with_ancestor_cap(self, cap: usize) -> Result<Self>

Override the ancestor cap (spec §3.9). A cap of 0 is rejected.

pub async fn connect( bucket: impl Into<String>, endpoint: Option<String>, region: Option<String>, ) -> Self

Connect using the ambient AWS config (env, profile, IRSA, etc.). If endpoint is Some, target an S3-compatible server (MinIO/Garage, etc.) with path-style addressing; if region is Some, override the ambient region (else the AWS env/profile region applies).

pub async fn collection_marked( &self, namespace: &str, collection: &str, ) -> Result<bool>

Whether list may treat an unmarked key in this collection as live — true once the collection carries the marked flag (ADR 0025).

A bucket written before markers existed has tombstones with no marker, and trusting their absence there would resurrect deleted records. So trust is earned per collection, by a pass that read every key and backfilled what was missing.

pub async fn mark_collection( &self, namespace: &str, collection: &str, ) -> Result<()>

Record that every tombstone in this collection carries a marker.

Only for a caller that just read every key in the collection and wrote the markers that were missing — the flag is what later listings trust instead of reading.

pub async fn marker_exists(&self, key: &RecordKey) -> Result<bool>

Whether key currently carries a tombstone marker.

For inspecting the layout — tests and operational debugging. list reads markers out of the listing it already made instead, which is the entire point of putting them in the key space (ADR 0025).

Trait Implementations

impl BlobStore for S3Store

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.

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,

Whether hash is stored.

impl Store for S3Store

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 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 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 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,

Conditionally delete the record at key. expected is the revision the caller believes is current: None deletes unconditionally; Some(rev) deletes only if the current revision matches, else DeleteResult::Conflict. Deleting an absent key is a no-op Deleted. Some(author) records who deleted (stores that write tombstones stamp it on the tombstone’s meta.author). See ADR 0018 and ADR 0021.

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.