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()),