Iroh Blobs

https://docs.rs/iroh-blobs/latest/
Admin
Iroh Blobs provides blob and blob sequence transfer support for iroh, implementing a simple...
Tokens:891,347
Snippets:4,552
Trust Score:9.7
Update:8 hours ago
Show doc for...
Tokens:
Raw
### get::fsm::start

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/all.html

Starts a get operation for a single blob.

```APIDOC
## Function: get::fsm::start

### Description
Starts a get operation for a single blob.

### Signature
`pub fn start(...) -> ...`

### Parameters
- `...` (type) - Description not provided in source.

### Returns
- `...` - Description not provided in source.

```

--------------------------------

### start(connection: Connection, request: GetRequest, counters: RequestCounters) -> AtInitial

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/get/fsm/fn.start.html

The entry point of the get response machine. It takes a connection, a get request, and request counters, and returns the initial state of the state machine.

```APIDOC
## Function: start

### Description
The entry point of the get response machine. Initializes the state machine for fetching a blob.

### Signature
```rust
pub fn start(
    connection: Connection,
    request: GetRequest,
    counters: RequestCounters,
) -> AtInitial
```

### Parameters
- **connection** (`Connection`) - The connection to use for the get operation.
- **request** (`GetRequest`) - The get request specifying what to fetch.
- **counters** (`RequestCounters`) - Counters for tracking request metrics.

### Returns
- **`AtInitial`** - The initial state of the get response machine.
```

--------------------------------

### Basic setup of iroh-blobs with iroh

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/index.html

Shows how to create an iroh endpoint, an in-memory blob store, a blob ticket, and a router that accepts the iroh-blobs protocol. Requires the iroh and iroh-blobs crates. The example prints the ticket and waits for Ctrl-C before shutting down.

```rust
use iroh::{protocol::Router, Endpoint, endpoint::presets};
use iroh_blobs::{store::mem::MemStore, BlobsProtocol, ticket::BlobTicket};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // create an iroh endpoint that includes the standard address lookup mechanisms
    // we've built at number0
    let endpoint = Endpoint::bind(presets::N0).await?;

    // create a protocol handler using an in-memory blob store.
    let store = MemStore::new();
    let tag = store.add_slice(b"Hello world").await?;

    let _ = endpoint.online().await;
    let addr = endpoint.addr();
    let ticket = BlobTicket::new(addr, tag.hash, tag.format);

    // build the router
    let blobs = BlobsProtocol::new(&store, None);
    let router = Router::builder(endpoint)
        .accept(iroh_blobs::ALPN, blobs)
        .spawn();

    println!("We are now serving {}", ticket);

    // wait for control-c
    tokio::signal::ctrl_c().await;

    // clean shutdown of router and store
    router.shutdown().await?;
    Ok(())
}
```

--------------------------------

### fsm::start

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/get.rs.html

Entry point of the get response machine. Creates the initial state for a get request.

```APIDOC
## fsm::start

### Description
Entry point of the get response machine. Creates the initial state for a get request.

### Function Signature
```rust
pub fn start(
    connection: Connection,
    request: GetRequest,
    counters: RequestCounters,
) -> AtInitial
```

### Parameters
- **connection** (Connection) - Required - The iroh connection to the peer.
- **request** (GetRequest) - Required - Describes the data you want to get.
- **counters** (RequestCounters) - Required - Counters for tracking request statistics.

### Returns
- **AtInitial** - The initial state of the get response machine.
```

--------------------------------

### get::fsm::start_get_many

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/all.html

Starts a get operation for multiple blobs.

```APIDOC
## Function: get::fsm::start_get_many

### Description
Starts a get operation for multiple blobs.

### Signature
`pub fn start_get_many(...) -> ...`

### Parameters
- `...` (type) - Description not provided in source.

### Returns
- `...` - Description not provided in source.

```

--------------------------------

### fsm::start_get_many

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/get.rs.html

Start with a get many request. Opens a bidirectional stream and sends the request.

```APIDOC
## fsm::start_get_many

### Description
Start with a get many request. Opens a bidirectional stream and sends the request.

### Function Signature
```rust
pub async fn start_get_many(
    connection: Connection,
    request: GetManyRequest,
    counters: RequestCounters,
) -> std::result::Result<Result<AtStartChild, AtClosing>, GetError>
```

### Parameters
- **connection** (Connection) - Required - The iroh connection to the peer.
- **request** (GetManyRequest) - Required - The get many request describing the data to fetch.
- **counters** (RequestCounters) - Required - Counters for tracking request statistics.

### Returns
- **Result<Result<AtStartChild, AtClosing>, GetError>** - The next state of the machine or an error.
```

--------------------------------

### execute_get and execute_get_with_opts

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/api/remote.rs.html

Starts a get operation with progress channel, delegating to execute_get_with_opts.

```rust
pub fn execute_get(&self, conn: impl GetStreamPair, request: GetRequest) -> GetProgress {
    self.execute_get_with_opts(conn, request)
}
```

```rust
pub fn execute_get_with_opts(
    &self,
    conn: impl GetStreamPair,
    request: GetRequest,
) -> GetProgress {
    let (tx, rx) = tokio::sync::mpsc::channel(64);
    let tx2 = tx.clone();
    let sink = TokioMpscSenderSink(tx).with_map(GetProgressItem::Progress);
    let this = self.clone();
    let fut = async move {
        let res = this.execute_get_sink(conn, request, sink).await.into();
        tx2.send(res).await.ok();
    };
    GetProgress {
        rx,
        fut: Box::pin(fut),
    }
}
```

--------------------------------

### Rust example: Setting up BlobsProtocol with iroh Router

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/net_protocol.rs.html

Shows how to create a store, add data, bind an endpoint, create a BlobsProtocol handler, and add it to a Router. The data becomes globally available via a BlobTicket. Requires tokio for signal handling.

```rust
# async fn example() -> n0_error::Result<()> {
use iroh::{protocol::Router, Endpoint, endpoint::presets};
use iroh_blobs::{store, ticket::BlobTicket, BlobsProtocol};

// create a store
let store = store::fs::FsStore::load("blobs").await?;

// add some data
let t = store.add_slice(b"hello world").await?;

// create an iroh endpoint
let endpoint = Endpoint::bind(presets::N0).await?;
endpoint.online().await;
let addr = endpoint.addr();

// create a blobs protocol handler
let blobs = BlobsProtocol::new(&store, None);

// create a router and add the blobs protocol handler
let router = Router::builder(endpoint)
    .accept(iroh_blobs::ALPN, blobs)
    .spawn();

// this data is now globally available using the ticket
let ticket = BlobTicket::new(addr, t.hash, t.format);
println!("ticket: {}", ticket);

// wait for control-c to exit
tokio::signal::ctrl_c().await?;
#   Ok(())
# }
```

--------------------------------

### Handle get request implementation

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/provider.rs.html

Processes a get request, sending blobs for ranges starting at offset 0 and reading hash sequences for other offsets.

```rust
async fn handle_get_impl<W: SendStream>(
    store: Store,
    request: GetRequest,
    writer: &mut ProgressWriter<W>,
) -> Result<(), HandleGetError> {
    let hash = request.hash;
    debug!(%hash, "get received request");
    let mut hash_seq = None;
    for (offset, ranges) in request.ranges.iter_non_empty_infinite() {
        if offset == 0 {
            send_blob(&store, offset, hash, ranges.clone(), writer).await?;
        } else {
            // todo: this assumes that 1. the hashseq is complete and 2. it is
            // small enough to fit in memory.
            //
            // This should really read the hashseq from the store in chunks,
            // only where needed, so we can deal with holes and large hashseqs.
            let hash_seq = match &hash_seq {
                Some(b) => b,
                None => {
                    let bytes = store.get_bytes(hash).await?;
                    let hs =
                        HashSeq::try_from(bytes).map_err(|_| e!(HandleGetError::InvalidHashSeq))?;
                    hash_seq = Some(hs);
```

--------------------------------

### Downloader::download_with_opts

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/api/downloader/struct.Downloader.html

Starts a download using the provided DownloadOptions, returning a DownloadProgress handle.

```APIDOC
## Downloader::download_with_opts

### Description
Starts a download using the provided DownloadOptions, returning a DownloadProgress handle.

### Method
pub fn download_with_opts

### Signature
pub fn download_with_opts(&self, options: DownloadOptions) -> DownloadProgress

### Parameters
- **options** (DownloadOptions) - The options for the download, including request and providers.

### Returns
- **DownloadProgress** - A handle to monitor the download progress.
```

--------------------------------

### start_get_many

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/get/fsm/fn.start_get_many.html

Starts a get many request, returning a state machine for handling the request.

```APIDOC
## Function start_get_many

### Description
Starts a get many request, returning a state machine for handling the request.

### Signature
```rust
pub async fn start_get_many(
    connection: Connection,
    request: GetManyRequest,
    counters: RequestCounters,
) -> Result<Result<AtStartChild, AtClosing>, GetError>
```

### Parameters
- **connection** (Connection) - The connection to use for the request.
- **request** (GetManyRequest) - The get many request to send.
- **counters** (RequestCounters) - Counters for tracking request metrics.

### Returns
- **Result<Result<AtStartChild, AtClosing>, GetError>** - A result containing either a state machine at the start child state or closing state, or an error.
```

--------------------------------

### Options::new

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/store/fs/options/struct.Options.html

Creates a new Options instance with the given root path and default settings.

```APIDOC
## Options::new

### Description
Creates a new Options instance with the given root path and default settings.

### Method
`pub fn new(root: &Path) -> Self`

### Parameters
- **root** (`&Path`) - Required - The root path for the filesystem store.

### Returns
- `Self` - A new Options instance.

```

--------------------------------

### FsStore::load

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/store/fs/struct.FsStore.html

Creates a new FsStore using default options, creating required directories and loading an existing database if present.

```APIDOC
## FsStore::load

### Description
Creates a new FsStore using default options. It creates the required directories and loads an existing database if one is found at the configured location.

### Method
Associated function

### Signature
`pub fn load(path: impl AsRef<Path>) -> Result<Self>`

### Parameters
- **path** (impl AsRef<Path>) - Required - The path where the store database is located.

### Returns
- **Result<Self>** - The created FsStore instance or an error.

```

--------------------------------

### Collection::read_fsm

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/format/collection/struct.Collection.html

Reads the collection from a get fsm. Returns the fsm at the start of the first child blob (if any), the links array, and the collection.

```APIDOC
## Method: Collection::read_fsm

### Description
Reads the collection from a get fsm. Returns the fsm at the start of the first child blob (if any), the links array, and the collection.

### Signature
```rust
pub async fn read_fsm(
    fsm_at_start_root: AtStartRoot,
) -> Result<(EndBlobNext, HashSeq, Collection)>
```

### Parameters
- `fsm_at_start_root` (AtStartRoot) - The fsm at the start of the root blob.

### Returns
- `Result<(EndBlobNext, HashSeq, Collection)>` - A tuple containing the fsm at the start of the first child blob (if any), the links array, and the collection.
```

--------------------------------

### FsStore::load_with_opts

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/store/fs/struct.FsStore.html

Creates a new FsStore with custom options and location, creating the database if it does not exist and loading an existing one if found.

```APIDOC
## FsStore::load_with_opts

### Description
Creates a new FsStore with custom options and location. It creates the database if it does not exist and loads an existing database if one is found at the configured location.

### Method
Associated function

### Signature
`pub fn load_with_opts(opts: StoreOptions) -> Result<Self>`

### Parameters
- **opts** (StoreOptions) - Required - Custom options for the store, including the location of the database.

### Returns
- **Result<Self>** - The created FsStore instance or an error.

```

--------------------------------

### get

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/api/tags/struct.Tags.html

Gets the value of a single tag by name.

```APIDOC
## get

### Description
Gets the value of a single tag by name.

### Method
async fn get(&self, name: impl AsRef<[u8]>) -> RequestResult<Option<TagInfo>>

### Parameters
- **name** (impl AsRef<[u8]>) - Required - The name of the tag to retrieve.

### Returns
- **RequestResult<Option<TagInfo>>** - The tag information if found, or None if not present.
```

--------------------------------

### Example: reading a blob with Blobs::reader

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/api/blobs/struct.Blobs.html

Shows how to create a reader for a blob using MemStore and read its content into a string. Requires tokio AsyncReadExt.

```rust
use iroh_blobs::{store::mem::MemStore, api::blobs::Blobs};
use tokio::io::AsyncReadExt;

let store = MemStore::new();
let tag = store.add_slice(b"Hello, world!").await?;
let mut reader = store.reader(tag.hash);
let mut buf = String::new();
reader.read_to_string(&mut buf).await?;
assert_eq!(buf, "Hello, world!");
}
```

--------------------------------

### AtInitial::next

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/get/fsm/struct.AtInitial.html

Initiates a new bidi stream to use for the get response.

```APIDOC
## AtInitial::next

### Description
Initiates a new bidi stream to use for the get response.

### Method
Async method

### Signature
pub async fn next(self) -> Result<AtConnected, InitialNextError>

### Parameters
- **self** - Consumes the AtInitial instance.

### Returns
- **Result<AtConnected, InitialNextError>** - On success, returns an AtConnected state; on failure, returns an InitialNextError.
```

--------------------------------

### take

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/api/blobs/struct.BlobReader.html

Creates an adaptor which reads at most `limit` bytes from the source.

```APIDOC
## take

### Description
Creates an adaptor which reads at most `limit` bytes from it.

### Method
fn take(self, limit: u64) -> Take<Self>

### Parameters
- **limit** (u64) - Required - The maximum number of bytes to read.

### Constraints
- Self: Sized

### Returns
- **Take<Self>** - An adaptor that limits the number of bytes read.

### Source
[Source](https://docs.rs/irpc/0.17.0/x86_64-unknown-linux-gnu/src/irpc/util.rs.html#317)
```

--------------------------------

### Read collection from get FSM (read_fsm)

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/format/collection.rs.html

Reads a collection and its links from a get FSM. Returns the collection, links, and next FSM state. Used internally by read_fsm_all.

```rust
let meta_link = children
    .pop_front()
    .ok_or_else(|| n0_error::anyerr!("meta link not found"))?;
let curr = at_meta.next(meta_link);
let (curr, names) = curr.concatenate_into_vec().await?;
let names = postcard::from_bytes::<CollectionMeta>(&names).anyerr()?;
n0_error::ensure_any!(
    names.check_header(),
    "expected header {:?}, got {:?}",
    Self::HEADER,
    names.header
);
let collection = Collection::from_parts(children, names);
(curr.next(), collection)
```

--------------------------------

### Read collection and all children from get FSM (read_fsm_all)

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/format/collection.rs.html

Reads a collection and all its children from a get FSM. Returns the collection, a map from blob offsets to bytes, and stats. Iterates over child blobs and concatenates their data.

```rust
pub async fn read_fsm_all(
    fsm_at_start_root: crate::get::fsm::AtStartRoot,
) -> Result<(Collection, BTreeMap<u64, Bytes>, Stats)> {
    let (next, links, collection) = Self::read_fsm(fsm_at_start_root).await?;
    let mut res = BTreeMap::new();
    let mut curr = next;
    let end = loop {
        match curr {
            fsm::EndBlobNext::MoreChildren(more) => {
                let child_offset = more.offset() - 1;
                let Some(hash) = links.get(usize::try_from(child_offset).anyerr()?) else {
                    break more.finish();
                };
                let header = more.next(hash);
                let (next, blob) = header.concatenate_into_vec().await?;
                res.insert(child_offset - 1, blob.into());
                curr = next.next();
            }
            fsm::EndBlobNext::Closing(closing) => break closing,
        }
    };
    let stats = end.next().await?;
    Ok((collection, res, stats))
}
```

--------------------------------

### AtInitial::new

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/get/fsm/struct.AtInitial.html

Creates a new get response with the given connection, request, and counters.

```APIDOC
## AtInitial::new

### Description
Creates a new get response with the given connection, request, and counters.

### Method
Constructor

### Signature
pub fn new(connection: Connection, request: GetRequest, counters: RequestCounters) -> Self

### Parameters
- **connection** (Connection) - Required - An existing connection to use for the get response.
- **request** (GetRequest) - Required - The request to be sent.
- **counters** (RequestCounters) - Required - Request counters for tracking.

### Returns
- **Self** - A new AtInitial instance.
```

--------------------------------

### id

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/util/struct.AsyncReadRecvStream.html

Gets the stream ID.

```APIDOC
## id

### Description
Get the stream id.

### Method
fn id(&self) -> u64

### Returns
- **u64** - The stream ID.

```

--------------------------------

### mem.rs module imports and store setup

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/store/mem.rs.html

The beginning of the mem.rs file includes the module documentation and all necessary imports for the in-memory blob store. It also defines the Options struct and the MemStore struct with its conversion and deref implementations.

```rust
//! Mutable in-memory blob store.
//!
//! Being a memory store, this store has to import all data into memory before it can
//! serve it. So the amount of data you can serve is limited by your available memory.
//! Other than that this is a fully featured store that provides all features such as
//! tags and garbage collection.
//!
//! For many use cases this can be quite useful, since it does not require write access
//! to the file system.
use std::{
    collections::{BTreeMap, HashMap, HashSet},
    future::Future,
    io::{self, Write},
    num::NonZeroU64,
    ops::Deref,
    sync::Arc,
};

use bao_tree::{
    blake3,
    io::{
        mixed::{traverse_ranges_validated, EncodedItem, ReadBytesAt},
        outboard::PreOrderMemOutboard,
        sync::{Outboard, ReadAt, WriteAt},
        BaoContentItem, EncodeError, Leaf,
    },
    BaoTree, ChunkNum, ChunkRanges, TreeNode,
};
use bytes::Bytes;
use irpc::channel::mpsc;
use n0_error::{Result, StdResultExt};
use n0_future::{
    future::yield_now,
    task::{JoinError, JoinSet},
    time::SystemTime,
};
use range_collections::range_set::RangeSetRange;
use tokio::sync::watch;
use tracing::{error, info, instrument, trace, Instrument};

use super::util::{BaoTreeSender, PartialMemStorage};
use crate::{
    api::{
        self,
        blobs::{AddProgressItem, Bitfield, BlobStatus, ExportProgressItem},
        proto::{
            BatchMsg, BatchResponse, BlobDeleteRequest, BlobStatusMsg, BlobStatusRequest, Command,
            CreateTagMsg, CreateTagRequest, CreateTempTagMsg, DeleteBlobsMsg, DeleteTagsMsg,
            DeleteTagsRequest, ExportBaoMsg, ExportBaoRequest, ExportPathMsg, ExportPathRequest,
            ExportRangesItem, ExportRangesMsg, ExportRangesRequest, ImportBaoMsg, ImportBaoRequest,
            ImportByteStreamMsg, ImportByteStreamUpdate, ImportBytesMsg, ImportBytesRequest,
            ImportPathMsg, ImportPathRequest, ListBlobsMsg, ListTagsMsg, ListTagsRequest,
            ObserveMsg, ObserveRequest, RenameTagMsg, RenameTagRequest, Scope, SetTagMsg,
            SetTagRequest, ShutdownMsg, SyncDbMsg, WaitIdleMsg,
        },
        tags::TagInfo,
        ApiClient,
    },
    protocol::ChunkRangesExt,
    store::{
        gc::{run_gc, GcConfig},
        util::{SizeInfo, SparseMemFile, Tag},
        IROH_BLOCK_SIZE,
    },
    util::temp_tag::{TagDrop, TempTagScope, TempTags},
    BlobFormat, Hash, HashAndFormat,
};

#[derive(Debug, Default)]
pub struct Options {
    pub gc_config: Option<GcConfig>,
}

#[derive(Debug, Clone)]
#[repr(transparent)]
pub struct MemStore {
    client: ApiClient,
}

impl From<MemStore> for crate::api::Store {
    fn from(value: MemStore) -> Self {
        crate::api::Store::from_sender(value.client)
    }
}

impl AsRef<crate::api::Store> for MemStore {
    fn as_ref(&self) -> &crate::api::Store {
        crate::api::Store::ref_from_sender(&self.client)
    }
}

impl Deref for MemStore {
    type Target = crate::api::Store;

    fn deref(&self) -> &Self::Target {
        crate::api::Store::ref_from_sender(&self.client)
    }
}

impl Default for MemStore {
    fn default() -> Self {
        Self::new()
    }
}

#[derive(derive_more::From)]
enum TaskResult {
    Unit(()),
    Import(Result<ImportEntry>),
    Scope(Scope),
}

impl MemStore {
    pub fn from_sender(client: ApiClient) -> Self {
        Self { client }
    }

    pub fn new() -> Self {
        Self::new_with_opts(Options::default())
    }

    pub fn new_with_opts(opts: Options) -> Self {
        let (sender, receiver) = tokio::sync::mpsc::channel(32);
        n0_future::task::spawn(
            Actor {
                commands: receiver,
                tasks: JoinSet::new(),
                state: State {
                    data: HashMap::new(),
                    tags: BTreeMap::new(),
                    empty_hash: BaoFileHandle::new_partial(Hash::EMPTY),
                },
                options: Arc::new(Options::default()),
                temp_tags: Default::default(),
                protected: Default::default(),
                idle_waiters: Default::default(),
            }
            .run(),
        );

        let store = Self::from_sender(sender.into());
        if let Some(gc_config) = opts.gc_config {
            n0_future::task::spawn(run_gc(store.deref().clone(), gc_config));
        }

        store
    }
}

struct Actor {
    commands: tokio::sync::mpsc::Receiver<Command>,
    tasks: JoinSet<TaskResult>,
    state: State,
    #[allow(dead_code)]
    options: Arc<Options>,
    // temp tags
    temp_tags: TempTags,
    // idle waiters

```

--------------------------------

### nth

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/get/request/struct.GetBlobResult.html

Gets the nth item of the stream.

```APIDOC
## nth

### Description
Gets the nth item of the stream.

### Method
nth

### Signature
fn nth(&mut self, n: usize) -> NthFuture<'_, Self>

### Parameters
- **self** - The stream to get the item from.
- **n** (usize) - The index of the item to get.

### Returns
- **NthFuture<'_, Self>** - A future that resolves to the nth item, or None if the stream is too short.

### Example
```rust
let item = get_blob_result.nth(2).await;
```
```

--------------------------------

### len

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/format/collection/struct.Collection.html

Gets the number of blobs in this collection.

```APIDOC
## len

### Description
Gets the number of blobs in this collection.

### Method
len

### Signature
`pub fn len(&self) -> usize`

### Parameters
- **self** (&self) - Required - The collection.

### Returns
- **usize** - The number of blobs in the collection.
```

--------------------------------

### Options

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/store/fs/options/struct.Options.html

Configuration options for the file store. Available on crate feature `fs-store` only.

```APIDOC
## Struct Options

### Description
Options for the file store.

### Fields
- **path** (PathOptions) - Path options.
- **inline** (InlineOptions) - Inline storage options.
- **batch** (BatchOptions) - Transaction batching options.
- **gc** (Option<GcConfig>) - Gc configuration.

### Availability
Available on **crate feature `fs-store`** only.

### Source
[Source](https://docs.rs/iroh-blobs/latest/src/iroh_blobs/store/fs/options.rs.html#106-115)

### Example
```rust
pub struct Options {
    pub path: PathOptions,
    pub inline: InlineOptions,
    pub batch: BatchOptions,
    pub gc: Option<GcConfig>,
}
```
```

--------------------------------

### provider::handle_get

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/all.html

Handles a get request.

```APIDOC
## Function: provider::handle_get

### Description
Handles a get request.

### Signature
`pub fn handle_get(...) -> ...`

### Parameters
- `...` (type) - Description not provided in source.

### Returns
- `...` - Description not provided in source.

```

--------------------------------

### MemStore::new

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/store/mem/struct.MemStore.html

Creates a new MemStore with default options. This is the simplest way to create an in-memory store.

```APIDOC
## MemStore::new

### Description
Creates a new MemStore with default options. This is the simplest way to create an in-memory store.

### Method
new

### Signature
pub fn new() -> Self

### Parameters
None

### Returns
- **Self** - A new MemStore instance.
```

--------------------------------

### FsStore::load and load_with_opts

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/store/fs.rs.html

Loads or creates a store, with load using default options and load_with_opts allowing custom options and db path.

```rust
impl FsStore {
    /// Load or create a new store.
    pub async fn load(root: impl AsRef<Path>) -> Result<Self> {
        let path = root.as_ref();
        let db_path = path.join("blobs.db");
        let options = Options::new(path);
        Self::load_with_opts(db_path, options).await
    }

    /// Load or create a new store with custom options, returning an additional sender for file store specific commands.
    pub async fn load_with_opts(db_path: PathBuf, options: Options) -> Result<FsStore> {
        static THREAD_NR: AtomicU64 = AtomicU64::new(0);
        let rt = tokio::runtime::Builder::new_multi_thread()
            .thread_name_fn(|| {
                format!(
                    "iroh-blob-store-{}",
                    THREAD_NR.fetch_add(1, Ordering::Relaxed)
                )
            })
            .enable_time()
            .build()?;
        let handle = rt.handle().clone();
        let (commands_tx, commands_rx) = tokio::sync::mpsc::channel(100);
        let (fs_commands_tx, fs_commands_rx) = tokio::sync::mpsc::channel(100);
        let gc_config = options.gc.clone();
        let actor = handle
            .spawn(Actor::new(
                db_path,
                rt.into(),
                commands_rx,
                fs_commands_rx,
                fs_commands_tx.clone(),
                Arc::new(options),
            ))
            .await
            .anyerr()??;
        handle.spawn(actor.run());
        let store = FsStore::new(commands_tx.into(), fs_commands_tx);
        if let Some(config) = gc_config {
            handle.spawn(run_gc(store.deref().clone(), config));
        }
        Ok(store)
    }
}
```

--------------------------------

### AtInitial state and next method for get response

Source: https://docs.rs/iroh-blobs/latest/src/iroh_blobs/get.rs.html

Defines the initial state of the get response machine, holding the connection, request, and counters. The next method opens a bidi stream and returns an AtConnected state, mapping errors to InitialNextError.

```rust
    /// Initial state of the get response machine
    #[derive(Debug)]
    pub struct AtInitial {
        connection: Connection,
        request: GetRequest,
        counters: RequestCounters,
    }

    impl AtInitial {
        /// Create a new get response
        ///
        /// `connection` is an existing connection
        /// `request` is the request to be sent
        pub fn new(connection: Connection, request: GetRequest, counters: RequestCounters) -> Self {
            Self {
                connection,
                request,
                counters,
            }
        }

        /// Initiate a new bidi stream to use for the get response
        pub async fn next(self) -> Result<AtConnected, InitialNextError> {
            let start = Instant::now();
            let (writer, reader) = self
                .connection
                .open_bi()
                .await
                .map_err(|e| e!(InitialNextError::Open, e.into()))?;
            Ok(AtConnected {
                start,
                reader,
                writer,
                request: self.request,
                counters: self.counters,
            })
        }
    }
```

--------------------------------

### handle_get

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/provider/index.html

Handle a get request for a single blob.

```APIDOC
## Function: handle_get

### Description
Handle a get request for a single blob.

### Signature
`pub async fn handle_get(...)`

### Parameters
- `stream` (StreamPair) - The stream pair for the request.
- `db` (Store) - The blob store.
- `handlers` (Handlers) - The request handlers.
- `progress` (ProgressSender) - Sender for progress events.
- `stats` (Stats) - Transfer statistics.

### Returns
Result indicating success or failure.
```

--------------------------------

### provider::handle_get_many

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/all.html

Handles a get many request.

```APIDOC
## Function: provider::handle_get_many

### Description
Handles a get many request.

### Signature
`pub fn handle_get_many(...) -> ...`

### Parameters
- `...` (type) - Description not provided in source.

### Returns
- `...` - Description not provided in source.

```

--------------------------------

### Downloader::new_with_opts

Source: https://docs.rs/iroh-blobs/latest/iroh_blobs/api/downloader/struct.Downloader.html

Creates a new Downloader instance with custom connection pool options.

```APIDOC
## Downloader::new_with_opts

### Description
Creates a new Downloader instance with custom connection pool options.

### Method
pub fn new_with_opts

### Signature
pub fn new_with_opts(store: &Store, endpoint: &Endpoint, pool_options: Options) -> Self

### Parameters
- **store** (&Store) - The store to use for downloaded data.
- **endpoint** (&Endpoint) - The endpoint to use for network communication.
- **pool_options** (Options) - Options for the connection pool.

### Returns
- **Self** - A new Downloader instance.
```
Tokens:
Raw