undo get -> fetch rename

not worth it at this point

Author: rklaehn

examples/fetch-fsm.rs

@@ -7,7 +7,7 @@ use std::net::SocketAddr;
 
 use anyhow::{Context, Result};
 use iroh_blobs::{
-    fetch::fsm::{AtInitial, ConnectedNext, EndBlobNext},
+    get::fsm::{AtInitial, ConnectedNext, EndBlobNext},
     hashseq::HashSeq,
     protocol::GetRequest,
     Hash,
@@ -63,14 +63,14 @@ async fn main() -> Result<()> {
         // create a request for a collection
         let request = GetRequest::all(hash);
         // create the initial state of the finite state machine
-        let initial = iroh_blobs::fetch::fsm::start(connection, request);
+        let initial = iroh_blobs::get::fsm::start(connection, request);
 
         write_collection(initial).await
     } else {
         // create a request for a single blob
         let request = GetRequest::single(hash);
         // create the initial state of the finite state machine
-        let initial = iroh_blobs::fetch::fsm::start(connection, request);
+        let initial = iroh_blobs::get::fsm::start(connection, request);
 
         write_blob(initial).await
     }
@@ -119,7 +119,7 @@ async fn write_collection(initial: AtInitial) -> Result<()> {
     }
 
     // move to the header
-    let header: iroh_blobs::fetch::fsm::AtBlobHeader = start_root.next();
+    let header: iroh_blobs::get::fsm::AtBlobHeader = start_root.next();
     let (root_end, hashes_bytes) = header.concatenate_into_vec().await?;
     let next = root_end.next();
     let EndBlobNext::MoreChildren(at_meta) = next else {

examples/fetch-stream.rs

@@ -11,7 +11,7 @@ use bytes::Bytes;
 use futures_lite::{Stream, StreamExt};
 use genawaiter::sync::{Co, Gen};
 use iroh_blobs::{
-    fetch::fsm::{AtInitial, BlobContentNext, ConnectedNext, EndBlobNext},
+    get::fsm::{AtInitial, BlobContentNext, ConnectedNext, EndBlobNext},
     hashseq::HashSeq,
     protocol::GetRequest,
     Hash,
@@ -68,7 +68,7 @@ async fn main() -> Result<()> {
         let request = GetRequest::all(hash);
 
         // create the initial state of the finite state machine
-        let initial = iroh_blobs::fetch::fsm::start(connection, request);
+        let initial = iroh_blobs::get::fsm::start(connection, request);
 
         // create a stream that yields all the data of the blob
         stream_children(initial).boxed_local()
@@ -77,7 +77,7 @@ async fn main() -> Result<()> {
         let request = GetRequest::single(hash);
 
         // create the initial state of the finite state machine
-        let initial = iroh_blobs::fetch::fsm::start(connection, request);
+        let initial = iroh_blobs::get::fsm::start(connection, request);
 
         // create a stream that yields all the data of the blob
         stream_blob(initial).boxed_local()
@@ -166,7 +166,7 @@ fn stream_children(initial: AtInitial) -> impl Stream<Item = io::Result<Bytes>>
             ));
         }
         // move to the header
-        let header: iroh_blobs::fetch::fsm::AtBlobHeader = start_root.next();
+        let header: iroh_blobs::get::fsm::AtBlobHeader = start_root.next();
         let (root_end, hashes_bytes) = header.concatenate_into_vec().await?;
 
         // parse the hashes from the hash sequence bytes

examples/local-swarm-discovery.rs

@@ -140,7 +140,7 @@ mod progress {
         ProgressStyle,
     };
     use iroh_blobs::{
-        fetch::{
+        get::{
             progress::{BlobProgress, DownloadProgress},
             Stats,
         },

src/downloader.rs

@@ -55,7 +55,7 @@ use tokio_util::{either::Either, sync::CancellationToken, time::delay_queue};
 use tracing::{debug, error, error_span, trace, warn, Instrument};
 
 use crate::{
-    fetch::{progress::DownloadProgress, Stats},
+    get::{progress::DownloadProgress, Stats},
     metrics::Metrics,
     store::Store,
     util::{local_pool::LocalPoolHandle, progress::ProgressSender},

src/downloader/get.rs

@@ -7,8 +7,8 @@ use iroh::endpoint;
 
 use super::{progress::BroadcastProgressSender, DownloadKind, FailureAction, GetStartFut, Getter};
 use crate::{
-    fetch::Error,
-    store::{fetch_to_db_in_steps, FetchState, FetchStateNeedsConn, Store},
+    get::Error,
+    store::{get_to_db_in_steps, FetchState, FetchStateNeedsConn, Store},
 };
 
 impl From<Error> for FailureAction {
@@ -43,7 +43,7 @@ impl<S: Store> Getter for IoGetter<S> {
     ) -> GetStartFut<Self::NeedsConn> {
         let store = self.store.clone();
         async move {
-            match fetch_to_db_in_steps(store, kind.hash_and_format(), progress_sender).await {
+            match get_to_db_in_steps(store, kind.hash_and_format(), progress_sender).await {
                 Err(err) => Err(err.into()),
                 Ok(FetchState::Complete(stats)) => Ok(super::GetOutput::Complete(stats)),
                 Ok(FetchState::NeedsConn(needs_conn)) => {
@@ -71,13 +71,13 @@ impl super::NeedsConn<endpoint::Connection> for FetchStateNeedsConn {
 }
 
 #[cfg(feature = "metrics")]
-fn track_metrics(res: &Result<crate::fetch::Stats, Error>) {
+fn track_metrics(res: &Result<crate::get::Stats, Error>) {
     use iroh_metrics::{inc, inc_by};
 
     use crate::metrics::Metrics;
     match res {
         Ok(stats) => {
-            let crate::fetch::Stats {
+            let crate::get::Stats {
                 bytes_written,
                 bytes_read: _,
                 elapsed,

src/downloader/progress.rs

@@ -11,7 +11,7 @@ use parking_lot::Mutex;
 
 use super::DownloadKind;
 use crate::{
-    fetch::progress::{DownloadProgress, TransferState},
+    get::progress::{DownloadProgress, TransferState},
     util::progress::{AsyncChannelProgressSender, IdGenerator, ProgressSendError, ProgressSender},
 };
 

src/downloader/test.rs

@@ -10,7 +10,7 @@ use iroh::SecretKey;
 
 use super::*;
 use crate::{
-    fetch::progress::{BlobId, BlobProgress, TransferState},
+    get::progress::{BlobId, BlobProgress, TransferState},
     util::{
         local_pool::LocalPool,
         progress::{AsyncChannelProgressSender, IdGenerator},

src/format/collection.rs

@@ -8,7 +8,7 @@ use iroh_io::AsyncSliceReaderExt;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    fetch::{fsm, Stats},
+    get::{fsm, Stats},
     hashseq::HashSeq,
     store::MapEntry,
     util::TempTag,
@@ -142,7 +142,7 @@ impl Collection {
     ///
     /// Returns the collection, a map from blob offsets to bytes, and the stats.
     pub async fn read_fsm_all(
-        fsm_at_start_root: crate::fetch::fsm::AtStartRoot,
+        fsm_at_start_root: crate::get::fsm::AtStartRoot,
     ) -> anyhow::Result<(Collection, BTreeMap<u64, Bytes>, Stats)> {
         let (next, links, collection) = Self::read_fsm(fsm_at_start_root).await?;
         let mut res = BTreeMap::new();

src/fetch.rs renamed to src/get.rs

@@ -116,9 +116,9 @@ impl From<endpoint::WriteError> for Error {
     }
 }
 
-impl From<crate::fetch::fsm::ConnectedNextError> for Error {
-    fn from(value: crate::fetch::fsm::ConnectedNextError) -> Self {
-        use crate::fetch::fsm::ConnectedNextError::*;
+impl From<crate::get::fsm::ConnectedNextError> for Error {
+    fn from(value: crate::get::fsm::ConnectedNextError) -> Self {
+        use crate::get::fsm::ConnectedNextError::*;
         match value {
             e @ PostcardSer(_) => {
                 // serialization errors indicate something wrong with the request itself
@@ -138,9 +138,9 @@ impl From<crate::fetch::fsm::ConnectedNextError> for Error {
     }
 }
 
-impl From<crate::fetch::fsm::AtBlobHeaderNextError> for Error {
-    fn from(value: crate::fetch::fsm::AtBlobHeaderNextError) -> Self {
-        use crate::fetch::fsm::AtBlobHeaderNextError::*;
+impl From<crate::get::fsm::AtBlobHeaderNextError> for Error {
+    fn from(value: crate::get::fsm::AtBlobHeaderNextError) -> Self {
+        use crate::get::fsm::AtBlobHeaderNextError::*;
         match value {
             e @ NotFound => {
                 // > This indicates that the provider does not have the requested data.
@@ -156,9 +156,9 @@ impl From<crate::fetch::fsm::AtBlobHeaderNextError> for Error {
     }
 }
 
-impl From<crate::fetch::fsm::DecodeError> for Error {
-    fn from(value: crate::fetch::fsm::DecodeError) -> Self {
-        use crate::fetch::fsm::DecodeError::*;
+impl From<crate::get::fsm::DecodeError> for Error {
+    fn from(value: crate::get::fsm::DecodeError) -> Self {
+        use crate::get::fsm::DecodeError::*;
 
         match value {
             e @ NotFound => Error::NotFound(e.into()),

src/fetch/error.rs renamed to src/get/error.rs

@@ -32,9 +32,9 @@
 pub mod cli;
 #[cfg(feature = "downloader")]
 pub mod downloader;
-pub mod fetch;
 #[cfg(feature = "formats")]
 pub mod format;
+pub mod get;
 pub mod hashseq;
 pub mod metrics;
 #[cfg(feature = "net_protocol")]

src/fetch/progress.rs renamed to src/get/progress.rs

@@ -43,8 +43,8 @@ use tracing::{debug, warn};
 
 use crate::{
     downloader::{DownloadRequest, Downloader},
-    fetch::{progress::DownloadProgress, Stats},
     format::collection::Collection,
+    get::{progress::DownloadProgress, Stats},
     net_protocol::{Blobs, BlobsInner},
     provider::{AddProgress, BatchAddPathProgress},
     store::{
@@ -1008,7 +1008,7 @@ impl<D: crate::store::Store> Handler<D> {
         let mut remaining_nodes = nodes.len();
         let mut nodes_iter = nodes.into_iter();
         'outer: loop {
-            match crate::store::fetch_to_db_in_steps(
+            match crate::store::get_to_db_in_steps(
                 self.store().clone(),
                 hash_and_format,
                 progress.clone(),

src/fetch/request.rs renamed to src/get/request.rs

@@ -82,8 +82,8 @@ use tokio_util::io::{ReaderStream, StreamReader};
 use tracing::warn;
 
 use crate::{
-    fetch::progress::DownloadProgress as BytesDownloadProgress,
     format::collection::{Collection, SimpleStore},
+    get::progress::DownloadProgress as BytesDownloadProgress,
     rpc::proto::{blobs::BlobDownloadRequest, RpcService},
     store::{
         BaoBlobSize, ConsistencyCheckProgress, ExportFormat, ExportMode,
@@ -675,7 +675,7 @@ pub struct DownloadOutcome {
     /// The size of the data we downloaded from the network
     pub downloaded_size: u64,
     /// Statistics about the download
-    pub stats: crate::fetch::Stats,
+    pub stats: crate::get::Stats,
 }
 
 /// Progress stream for blob download operations.

src/lib.rs

@@ -112,7 +112,7 @@ pub struct AddPathResponse(pub AddProgress);
 
 /// Progress response for [`BlobDownloadRequest`]
 #[derive(Debug, Clone, Serialize, Deserialize, derive_more::From, derive_more::Into)]
-pub struct DownloadResponse(pub crate::fetch::progress::DownloadProgress);
+pub struct DownloadResponse(pub crate::get::progress::DownloadProgress);
 
 /// A request to the node to download and share the data specified by the hash.
 #[derive(Debug, Clone, Serialize, Deserialize)]

src/rpc.rs

@@ -10,8 +10,8 @@ pub mod readonly_mem;
 #[cfg(feature = "fs-store")]
 pub mod fs;
 
-mod fetch_to_db;
-pub use fetch_to_db::{fetch_to_db, fetch_to_db_in_steps, FetchState, FetchStateNeedsConn};
+mod get_to_db;
+pub use get_to_db::{get_to_db, get_to_db_in_steps, FetchState, FetchStateNeedsConn};
 mod export;
 #[cfg(feature = "formats-collection")]
 pub use export::export_collection;

src/rpc/client/blobs.rs

@@ -15,7 +15,7 @@ use tokio::sync::oneshot;
 use tracing::trace;
 
 use crate::{
-    fetch::{
+    get::{
         self,
         fsm::{AtBlobHeader, AtEndBlob, ConnectedNext, EndBlobNext},
         progress::{BlobId, DownloadProgress},
@@ -42,7 +42,7 @@ type GetFuture = Pin<Box<dyn Future<Output = Result<Stats, Error>> + 'static>>;
 /// Progress is reported as [`DownloadProgress`] through a [`ProgressSender`]. Note that the
 /// [`DownloadProgress::AllDone`] event is not emitted from here, but left to an upper layer to send,
 /// if desired.
-pub async fn fetch_to_db<
+pub async fn get_to_db<
     D: BaoStore,
     C: FnOnce() -> F,
     F: Future<Output = anyhow::Result<Connection>>,
@@ -52,7 +52,7 @@ pub async fn fetch_to_db<
     hash_and_format: &HashAndFormat,
     progress_sender: impl ProgressSender<Msg = DownloadProgress> + IdGenerator,
 ) -> Result<Stats, Error> {
-    match fetch_to_db_in_steps(db.clone(), *hash_and_format, progress_sender).await? {
+    match get_to_db_in_steps(db.clone(), *hash_and_format, progress_sender).await? {
         FetchState::Complete(res) => Ok(res),
         FetchState::NeedsConn(state) => {
             let conn = get_conn().await.map_err(Error::Io)?;
@@ -71,7 +71,7 @@ pub async fn fetch_to_db<
 /// proceed with the download.
 ///
 /// Progress reporting works in the same way as documented in [`fetch_to_db`].
-pub async fn fetch_to_db_in_steps<
+pub async fn get_to_db_in_steps<
     D: BaoStore,
     P: ProgressSender<Msg = DownloadProgress> + IdGenerator,
 >(
@@ -194,7 +194,7 @@ async fn get_blob<D: BaoStore>(
             let request = GetRequest::new(*hash, RangeSpecSeq::from_ranges([required_ranges]));
             // full request
             let conn = co.get_conn().await;
-            let request = fetch::fsm::start(conn, request);
+            let request = get::fsm::start(conn, request);
             // create a new bidi stream
             let connected = request.next().await?;
             // next step. we have requested a single hash, so this must be StartRoot
@@ -210,7 +210,7 @@ async fn get_blob<D: BaoStore>(
         None => {
             // full request
             let conn = co.get_conn().await;
-            let request = fetch::fsm::start(conn, GetRequest::single(*hash));
+            let request = get::fsm::start(conn, GetRequest::single(*hash));
             // create a new bidi stream
             let connected = request.next().await?;
             // next step. we have requested a single hash, so this must be StartRoot
@@ -452,7 +452,7 @@ async fn get_hash_seq<D: BaoStore>(
             log!("requesting chunks {:?}", missing_iter);
             let request = GetRequest::new(*root_hash, RangeSpecSeq::from_ranges(missing_iter));
             let conn = co.get_conn().await;
-            let request = fetch::fsm::start(conn, request);
+            let request = get::fsm::start(conn, request);
             // create a new bidi stream
             let connected = request.next().await?;
             log!("connected");
@@ -498,7 +498,7 @@ async fn get_hash_seq<D: BaoStore>(
             tracing::debug!("don't have collection - doing full download");
             // don't have the collection, so probably got nothing
             let conn = co.get_conn().await;
-            let request = fetch::fsm::start(conn, GetRequest::all(*root_hash));
+            let request = get::fsm::start(conn, GetRequest::all(*root_hash));
             // create a new bidi stream
             let connected = request.next().await?;
             // next step. we have requested a single hash, so this must be StartRoot