Struct iroh_blobs::store::fs::Store

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

Storage that is using a redb database for small files and files for large files.

Implementations

impl Store

pub async fn transform_entries( &self, transform: impl Fn(Hash, EntryData) -> Option<EntryData> + Send + Sync ) -> Result<()>

Transform all entries in the store. This is for testing and can be used to get the store in a wrong state.

pub fn owned_data_path(&self, hash: &Hash) -> PathBuf

Owned data path

pub fn owned_outboard_path(&self, hash: &Hash) -> PathBuf

Owned outboard path

impl Store

pub async fn load(root: impl AsRef<Path>) -> Result<Self>

Load or create a new store.

pub async fn new(path: PathBuf, options: Options) -> Result<Self>

Create a new store with custom options.

pub async fn update_inline_options( &self, inline_options: InlineOptions, reapply: bool ) -> Result<()>

Update the inline options.

When reapply is true, the new options will be applied to all existing entries.

pub async fn dump(&self) -> Result<()>

Dump the entire content of the database to stdout.

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 Map for Store

type Entry = BaoFileHandle

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 = BaoFileHandle

An entry that is possibly writable

async fn get_or_create(&self, hash: Hash, _size: u64) -> Result<Self::EntryMut>

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

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 get_mut(&self, hash: &Hash) -> Result<Option<Self::EntryMut>>

Get an existing entry as an EntryMut.

async fn insert_complete(&self, entry: Self::EntryMut) -> Result<()>

Upgrade a partial entry to a complete entry.

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.

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 partial_blobs(&self) -> Result<DbIter<Hash>>

list partial blobs in the database

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.

impl Store for Store

async fn import_file( &self, path: 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_bytes(&self, data: Bytes, format: BlobFormat) -> Result<TempTag>

Import data from memory.

async fn import_stream( &self, data: impl Stream<Item = Result<Bytes>> + Unpin + Send + 'static, 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

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

physically delete the given hashes from the 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

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

Create a temporary pin for this store

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

Sync the store.

async fn shutdown(&self)

Shutdown 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