Struct noosphere_storage::BlockStoreRetry

pub struct BlockStoreRetry<S>where
    S: BlockStore,{ /* private fields */ }

Implements retry and timeout logic for accessing blocks from a BlockStore. Any BlockStore can be wrapped by BlockStoreRetry to get retry and timeout logic for free. Each attempt to lookup a block is time limited by the timeout value, and at most max_retries will be made to load the block.

Local BlockStore implementations won’t benefit a lot from this, but network implementations such as [IpfsStore] can be made more reliable with a modest retry policy (and timeouts will help make sure we don’t hang indefinitely waiting for an implementation like Kubo to get its act together).

Implementations

impl<S> BlockStoreRetry<S>where S: BlockStore,

pub fn new(store: S, max_retries: u32, timeout: Duration) -> Self

Trait Implementations

impl<S> BlockStore for BlockStoreRetry<S>where S: BlockStore,

fn put_block<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, cid: &'life1 Cid, block: &'life2 [u8] ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Given a block and its Cid, persist the block in storage.

fn get_block<'life0, 'life1, 'async_trait>( &'life0 self, cid: &'life1 Cid ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given the Cid of a block, retrieve the block bytes from storage.

fn put_links<'life0, 'life1, 'life2, 'async_trait, C>( &'life0 mut self, cid: &'life1 Cid, block: &'life2 [u8] ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where C: Codec + Default + 'async_trait, Ipld: References<C>, Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Given a CID and a block, store the links (any Cid that is part of the encoded data) in a suitable location for later retrieval. This method is optional, and its default implementation is a no-op. It should be implemented when possible to enable optimized traversal of a DAG given its root.

fn put<'life0, 'async_trait, C, T>( &'life0 mut self, data: T ) -> Pin<Box<dyn Future<Output = Result<Cid>> + Send + 'async_trait>>where C: Codec + Default + 'async_trait, T: Encode<C> + BlockStoreSend + 'async_trait, Ipld: References<C>, Self: Send + 'async_trait, 'life0: 'async_trait,

Given some data structure that implements Encode for a given Codec, encode it as a block and persist it to storage for later retrieval by Cid.

fn get<'life0, 'life1, 'async_trait, C, T>( &'life0 self, cid: &'life1 Cid ) -> Pin<Box<dyn Future<Output = Result<Option<T>>> + Send + 'async_trait>>where C: Codec + Default + 'async_trait, T: Decode<C> + 'async_trait, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given the Cid of a block that refers to a type that implements Decode for some Codec, retrieve the block, decode it as the type and return the result.

fn save<'life0, 'async_trait, C, T>( &'life0 mut self, data: T ) -> Pin<Box<dyn Future<Output = Result<Cid>> + Send + 'async_trait>>where C: Codec + Default + 'async_trait, T: Serialize + BlockStoreSend + 'async_trait, Ipld: Encode<C> + References<C>, Self: Send + 'async_trait, 'life0: 'async_trait,

Given some data structure that implements Serialize, convert it to an IPLD-compatible representation, encode it as a block with the desired Codec and persist it to the storage backend by its Cid

fn load<'life0, 'life1, 'async_trait, C, T>( &'life0 self, cid: &'life1 Cid ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>where C: Codec + Default + 'async_trait, T: DeserializeOwned + BlockStoreSend + 'async_trait, u64: From<C>, Ipld: Decode<C>, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a Cid that refers to some data structure that implements Deserialize, read the block bytes from storage, decode it as IPLD using the specified Codec and and deserialize it to the intended data structure, returning the result.

fn require_block<'life0, 'life1, 'async_trait>( &'life0 self, cid: &'life1 Cid ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>>> + Send + 'async_trait>>where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Same as load, but returns an error if no block is found locally for the given Cid

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

Flushes pending writes if there are any

impl<S> Clone for BlockStoreRetry<S>where S: BlockStore + Clone,

fn clone(&self) -> BlockStoreRetry<S>

Returns a copy of the value.

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

Performs copy-assignment from source.