Struct BlockStoreRetry 

pub struct BlockStoreRetry<S>
where
    S: BlockStore,
{
    pub store: S,
    pub maximum_retries: u32,
    pub attempt_window: Duration,
    pub minimum_delay: Duration,
    pub backoff: Option<Backoff>,
}

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 to a specified window with optional Backoff, and at most maximum_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).

Fields

store: S

A BlockStore implementation that the BlockStoreRetry proxies reads to in order to implement retry behavior

maximum_retries: u32

The maximum number of additional attempts to make if a read to the wrapped store should fail

attempt_window: Duration

The maximum time that a read is allowed to take before it is considered failed

minimum_delay: Duration

The minimum time between attempts

backoff: Option<Backoff>

If a Backoff is configured, the attempt window will grow with each attempt based on the configuration

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> + ConditionalSend + '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 + ConditionalSend + '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 + ConditionalSend + '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 duplicate of the value.

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

Performs copy-assignment from source.

impl<S> From<S> for BlockStoreRetry<S>

where S: BlockStore,

fn from(store: S) -> Self

Converts to this type from the input type.