Struct ObjectStoreIo 

pub(crate) struct ObjectStoreIo {
    store: ObjectStore,
    object_prefix: String,
    probe_prefix: String,
}

Reads and writes the WAL objects under one prefix.

Fields

store: ObjectStore

object_prefix: String

probe_prefix: String

Holds the keys of Self::probe_conditional_create, outside object_prefix so that no listing of the objects returns one.

Implementations

impl ObjectStoreIo

pub(crate) fn new(store: ObjectStore, prefix: impl AsRef<str>) -> Result<Self>

Binds store to the objects under prefix. The store must support conditional creates, which is what keeps a retried write from overwriting a durable object.

pub(crate) async fn probe_conditional_create(&self) -> Result<()>

Checks that the store refuses a conditional create of an object that exists. The capability checked by Self::new is declared per service, and a store behind the S3 service may accept the condition and overwrite the object anyway, which would let a retried write replace a durable object. The probe creates a key of its own, unique to this call, twice, and then deletes it.

pub(crate) async fn put_if_absent( &self, object_seq: u64, content: Bytes, ) -> Result<PutResult>

Creates the object object_seq unless it already exists, see Self::put_path_if_absent.

async fn put_path_if_absent( &self, path: String, content: Bytes, ) -> Result<PutResult>

Creates path unless it already exists. A retry with the same content is accepted, different content is rejected: a create the store stored but whose response was lost can be retried, by the caller or by the retry layer, and then finds its own object.

When the store reports that the object exists but the read that compares its content fails, the read failure is returned, so that its retry hint says whether comparing again may settle the outcome. Any other create failure is returned as the write failure it is.

pub(crate) async fn get(&self, object_seq: u64) -> Result<Bytes>

Reads the object object_seq.

pub(crate) async fn get_range( &self, object_seq: u64, offset: u64, len: u64, ) -> Result<Bytes>

Reads len bytes of the object object_seq starting at offset. The range must lie inside the object; one that reaches past its end fails.

pub(crate) async fn delete(&self, object_seq: u64) -> Result<()>

Deletes the object object_seq. Deleting an object that does not exist succeeds.

pub(crate) async fn list(&self) -> Result<Vec<ListedObject>>

Lists the objects under the prefix, ordered by object sequence. Keys that do not follow the object layout are ignored.

pub(crate) fn list_ahead(&self) -> BoxStream<'static, Result<ListedObject>>

Lists the objects under the prefix like list, but from a task of its own and in the order the object store returns them, so the listing goes on while the caller consumes the objects listed so far. A listing that fails, however it fails, ends the stream with an error, before any object it listed that the caller has not taken yet; dropping the stream stops the listing.

fn listing( self, ) -> (impl Future<Output = Result<()>> + Send + 'static, Receiver<ListedObject>)

Returns the listing of the objects under the prefix and the receiver it sends them to; it waits while the receiver holds LISTING_AHEAD_OBJECTS of them.

pub(crate) fn object_path(&self, object_seq: u64) -> String

pub(crate) fn storage(&self) -> String

Describes the object store the objects live in by its scheme, its bucket when it has one and its root, none of which is a credential.

fn listed_object(&self, entry: &Entry) -> Option<ListedObject>

fn parse_object_seq(&self, path: &str) -> Option<u64>

Trait Implementations

impl Clone for ObjectStoreIo

fn clone(&self) -> ObjectStoreIo

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl WalObjectIo for ObjectStoreIo

fn put_if_absent<'life0, 'async_trait>( &'life0 self, object_seq: u64, content: Bytes, ) -> Pin<Box<dyn Future<Output = Result<PutResult>> + Send + 'async_trait>>

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

fn get<'life0, 'async_trait>( &'life0 self, object_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<Bytes>> + Send + 'async_trait>>

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

fn get_range<'life0, 'async_trait>( &'life0 self, object_seq: u64, offset: u64, len: u64, ) -> Pin<Box<dyn Future<Output = Result<Bytes>> + Send + 'async_trait>>

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

fn delete<'life0, 'async_trait>( &'life0 self, object_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

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

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

fn list_ahead(&self) -> BoxStream<'_, Result<ListedObject>>

See ObjectStoreIo::list_ahead; by default the objects list returns.

fn object_path(&self, object_seq: u64) -> String

fn storage(&self) -> String

Describes the object store the objects live in, for messages.