Struct iroh_blobs::store::readonly_mem::Store

pub struct Store(/* private fields */);

A readonly in memory database for iroh-blobs.

This is basically just a HashMap, so it does not allow for any modifications unless you have a mutable reference to it.

It is therefore useful mostly for testing and sharing static data.

Implementations

impl Store

pub fn new( entries: impl IntoIterator<Item = (impl Into<String>, impl AsRef<[u8]>)> ) -> (Self, BTreeMap<String, Hash>)

Create a new Store from a sequence of entries.

Returns the database and a map of names to computed blake3 hashes. In case of duplicate names, the last entry is used.

pub fn insert(&mut self, data: impl AsRef<[u8]>) -> Hash

Insert a new entry into the database, and return the hash of the entry.

If the database was shared before, this will make a copy.

pub fn insert_many( &mut self, items: impl IntoIterator<Item = impl AsRef<[u8]>> ) -> Option<Hash>

Insert multiple entries into the database, and return the hash of the last entry.

pub fn get_content(&self, hash: &Hash) -> Option<Bytes>

Get the bytes associated with a hash, if they exist.

Trait Implementations

impl Clone for Store

fn clone(&self) -> Store

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Store

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Store

fn default() -> Store

Returns the “default value” for a type.

impl<K, V> FromIterator<(K, V)> for Store

where K: Into<String>, V: AsRef<[u8]>,

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl Map for Store

type Entry = Entry

The entry type. An entry is a cheaply cloneable handle that can be used to open readers for both the data and the outboard

async fn get(&self, hash: &Hash) -> Result<Option<Self::Entry>>

Get an entry for a hash.

impl MapMut for Store

type EntryMut = Entry

An entry that is possibly writable

async fn get_mut(&self, hash: &Hash) -> Result<Option<Self::EntryMut>>

Get an existing entry as an EntryMut.

async fn get_or_create(&self, _hash: Hash, _size: u64) -> Result<Entry>

Get an existing partial entry, or create a new one.

fn entry_status_sync(&self, hash: &Hash) -> Result<EntryStatus>

Sync version of entry_status, for the doc sync engine until we can get rid of it.

async fn entry_status(&self, hash: &Hash) -> Result<EntryStatus>

Find out if the data behind a hash is complete, partial, or not present.

async fn insert_complete(&self, _entry: Entry) -> Result<()>

Upgrade a partial entry to a complete entry.

impl ReadableStore for Store

async fn blobs(&self) -> Result<DbIter<Hash>>

list all blobs in the database. This includes both raw blobs that have been imported, and hash sequences that have been created internally.

async fn tags(&self) -> Result<DbIter<(Tag, HashAndFormat)>>

list all tags (collections or other explicitly added things) in the database

fn temp_tags( &self ) -> Box<dyn Iterator<Item = HashAndFormat> + Send + Sync + 'static>

Temp tags

async fn consistency_check( &self, _repair: bool, _tx: BoxedProgressSender<ConsistencyCheckProgress> ) -> Result<()>

Perform a consistency check on the database

async fn export( &self, hash: Hash, target: PathBuf, mode: ExportMode, progress: ExportProgressCb ) -> Result<()>

This trait method extracts a file to a local path.

async fn partial_blobs(&self) -> Result<DbIter<Hash>>

list partial blobs in the database

impl Store for Store

async fn import_bytes( &self, bytes: Bytes, format: BlobFormat ) -> Result<TempTag>

import a byte slice

async fn import_file( &self, data: PathBuf, mode: ImportMode, format: BlobFormat, progress: impl ProgressSender<Msg = ImportProgress> + IdGenerator ) -> Result<(TempTag, u64)>

This trait method imports a file from a local path.

async fn import_stream( &self, data: impl Stream<Item = Result<Bytes>> + Unpin + Send, format: BlobFormat, progress: impl ProgressSender<Msg = ImportProgress> + IdGenerator ) -> Result<(TempTag, u64)>

Import data from a stream of bytes.

async fn set_tag(&self, _name: Tag, _hash: Option<HashAndFormat>) -> Result<()>

Set a tag

async fn create_tag(&self, _hash: HashAndFormat) -> Result<Tag>

Create a new tag

fn temp_tag(&self, inner: HashAndFormat) -> TempTag

Create a temporary pin for this store

async fn gc_run<G, Gut>(&self, config: GcConfig, protected_cb: G)

where G: Fn() -> Gut, Gut: Future<Output = BTreeSet<Hash>> + Send,

Start the GC loop

async fn delete(&self, _hashes: Vec<Hash>) -> Result<()>

physically delete the given hashes from the store.

async fn shutdown(&self)

Shutdown the store.

async fn sync(&self) -> Result<()>

Sync the store.

fn import_reader( &self, data: impl AsyncRead + Send + Unpin + 'static, format: BlobFormat, progress: impl ProgressSender<Msg = ImportProgress> + IdGenerator ) -> impl Future<Output = Result<(TempTag, u64)>> + Send

Import data from an async byte reader.

fn import_verifiable_stream<'a>( &'a self, hash: Hash, total_size: u64, offset: u64, reader: impl AsyncStreamReader + 'a ) -> impl Future<Output = Result<()>> + 'a

Import a blob from a verified stream, as emitted by MapEntry::write_verifiable_stream;

fn validate( &self, repair: bool, tx: BoxedProgressSender<ValidateProgress> ) -> impl Future<Output = Result<()>> + Send

Validate the database