Struct ipfs_sqlite_block_store::async_block_store::AsyncBlockStore

pub struct AsyncBlockStore<R> { /* fields omitted */ }

Implementations

impl<R: RuntimeAdapter> AsyncBlockStore<R>

pub fn new(runtime: R, store: BlockStore) -> Self

Wrap a block store in an asyc wrapper

runtime A runtime adapter for your runtime of choice store The BlockStore to wrap

returns the async store and a future that completes when the store is dropped.

pub fn wrap(runtime: R, inner: Arc<Mutex<BlockStore>>) -> Self

Wrap an existing Arc<Mutex>

pub fn inner(&self) -> &Arc<Mutex<BlockStore>>

get the inner Arc<Mutex>

pub fn temp_pin(&self) -> BoxFuture<'static, Result<AsyncTempPin>>

pub fn alias(
    &self,
    name: Vec<u8>,
    link: Option<Cid>
) -> BoxFuture<'static, Result<()>>

pub fn assign_temp_pin(
    &self,
    pin: AsyncTempPin,
    links: impl IntoIterator<Item = Cid> + Send + 'static
) -> BoxFuture<'static, Result<()>>

pub fn resolve(&self, name: Vec<u8>) -> BoxFuture<'static, Result<Option<Cid>>>

Resolves an alias to a cid.

pub fn alias_many(
    &self,
    aliases: impl IntoIterator<Item = (impl AsRef<[u8]>, Option<Cid>)> + Send + 'static
) -> BoxFuture<'static, Result<()>>

pub fn flush(&self) -> BoxFuture<'static, Result<()>>

pub fn gc(&self) -> BoxFuture<'static, Result<()>>

pub async fn incremental_gc(
    &self,
    min_blocks: usize,
    max_duration: Duration
) -> Result<bool>

pub fn incremental_delete_orphaned(
    &self,
    min_blocks: usize,
    max_duration: Duration
) -> BoxFuture<'static, Result<bool>>

pub fn get_block(&self, cid: Cid) -> BoxFuture<'static, Result<Option<Vec<u8>>>>

pub fn get_blocks<I: IntoIterator<Item = Cid> + Send + 'static>(
    &self,
    cids: I
) -> BoxFuture<'static, Result<impl Iterator<Item = (Cid, Option<Vec<u8>>)>>>

pub fn has_block(&self, cid: &Cid) -> BoxFuture<'static, Result<bool>>

pub fn has_blocks<I, O>(&self, cids: I) -> BoxFuture<'static, Result<O>> where
    I: IntoIterator<Item = Cid> + Send + 'static,
    O: FromIterator<(Cid, bool)> + Send + 'static, 

pub fn has_cid(&self, cid: Cid) -> BoxFuture<'static, Result<bool>>

pub fn get_missing_blocks<C: FromIterator<Cid> + Send + 'static>(
    &self,
    cid: Cid
) -> BoxFuture<'static, Result<C>>

pub fn get_descendants<C: FromIterator<Cid> + Send + 'static>(
    &self,
    cid: Cid
) -> BoxFuture<'static, Result<C>>

pub fn reverse_alias(
    &self,
    cid: Cid
) -> BoxFuture<'static, Result<Option<Vec<Vec<u8>>>>>

pub fn get_known_cids<C: FromIterator<Cid> + Send + 'static>(
    &self
) -> BoxFuture<'static, Result<C>>

pub fn get_block_cids<C: FromIterator<Cid> + Send + 'static>(
    &self
) -> BoxFuture<'static, Result<C>>

pub fn get_store_stats(&self) -> BoxFuture<'static, Result<StoreStats>>

pub fn put_blocks<B: Block + Send + 'static>(
    &self,
    blocks: impl IntoIterator<Item = B> + Send + 'static,
    alias: Option<AsyncTempPin>
) -> BoxFuture<'static, Result<()>>

pub fn put_block(
    &self,
    block: impl Block + Send + 'static,
    alias: Option<&AsyncTempPin>
) -> BoxFuture<'static, Result<()>>

pub async fn gc_loop(self, config: GcConfig) -> Result<()>

A gc loop that runs incremental gc in regular intervals

Gc will run as long as this future is polled. GC is a two step process. First, the metadata of expendable non-pinned blocks will be deleted, then the actual data will be removed. This will run the first step and the second step interleaved to minimize gc interruptions.

impl<R> AsyncBlockStore<R>

pub fn ref_count(&self) -> usize

number of references to this async wrapper

Trait Implementations

impl<R: Clone> Clone for AsyncBlockStore<R>

fn clone(&self) -> AsyncBlockStore<R>

Returns a copy of the value.

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

Performs copy-assignment from source.