fmt

Author: rklaehn

examples/random_store.rs

@@ -5,14 +5,14 @@ use clap::{Parser, Subcommand};
 use iroh::{SecretKey, Watcher};
 use iroh_base::ticket::NodeTicket;
 use iroh_blobs::{
-    HashAndFormat,
     api::downloader::Shuffled,
     provider::Event,
     store::fs::FsStore,
     test::{add_hash_sequences, create_random_blobs},
+    HashAndFormat,
 };
 use n0_future::StreamExt;
-use rand::{Rng, SeedableRng, rngs::StdRng};
+use rand::{rngs::StdRng, Rng, SeedableRng};
 use tokio::{signal::ctrl_c, sync::mpsc};
 use tracing::info;
 

src/api.rs

@@ -5,7 +5,7 @@
 use std::{io, net::SocketAddr, ops::Deref, sync::Arc};
 
 use iroh::Endpoint;
-use irpc::rpc::{Handler, listen};
+use irpc::rpc::{listen, Handler};
 use n0_snafu::SpanTrace;
 use nested_enum_utils::common_fields;
 use proto::{Request, ShutdownRequest, SyncDbRequest};

src/api/blobs.rs

@@ -15,19 +15,19 @@ use std::{
 
 pub use bao_tree::io::mixed::EncodedItem;
 use bao_tree::{
-    BaoTree, ChunkNum, ChunkRanges,
     io::{
-        BaoContentItem, Leaf,
         fsm::{ResponseDecoder, ResponseDecoderNext},
+        BaoContentItem, Leaf,
     },
+    BaoTree, ChunkNum, ChunkRanges,
 };
 use bytes::Bytes;
 use genawaiter::sync::Gen;
 use iroh_io::{AsyncStreamReader, TokioStreamReader};
 use irpc::channel::{mpsc, oneshot};
-use n0_future::{Stream, StreamExt, future, stream};
+use n0_future::{future, stream, Stream, StreamExt};
 use quinn::SendStream;
-use range_collections::{RangeSet2, range_set::RangeSetRange};
+use range_collections::{range_set::RangeSetRange, RangeSet2};
 use ref_cast::RefCast;
 use tokio::io::AsyncWriteExt;
 use tracing::trace;
@@ -43,21 +43,21 @@ pub use super::proto::{
     ImportBaoRequest as ImportBaoOptions, ImportMode, ObserveRequest as ObserveOptions,
 };
 use super::{
-    ApiClient, RequestResult, Tags,
     proto::{
         BatchResponse, BlobStatusRequest, ClearProtectedRequest, CreateTempTagRequest,
         ExportBaoRequest, ExportRangesItem, ImportBaoRequest, ImportByteStreamRequest,
         ImportBytesRequest, ImportPathRequest, ListRequest, Scope,
     },
     remote::HashSeqChunk,
     tags::TagInfo,
+    ApiClient, RequestResult, Tags,
 };
 use crate::{
-    BlobFormat, Hash, HashAndFormat,
     api::proto::{BatchRequest, ImportByteStreamUpdate},
     provider::StreamContext,
     store::IROH_BLOCK_SIZE,
     util::temp_tag::TempTag,
+    BlobFormat, Hash, HashAndFormat,
 };
 
 /// Options for adding bytes.
@@ -772,12 +772,12 @@ pub struct ImportBaoHandle {
 impl ImportBaoHandle {
     pub(crate) async fn new(
         fut: impl Future<
-            Output = irpc::Result<(
-                mpsc::Sender<BaoContentItem>,
-                oneshot::Receiver<super::Result<()>>,
-            )>,
-        > + Send
-        + 'static,
+                Output = irpc::Result<(
+                    mpsc::Sender<BaoContentItem>,
+                    oneshot::Receiver<super::Result<()>>,
+                )>,
+            > + Send
+            + 'static,
     ) -> irpc::Result<Self> {
         let (tx, rx) = fut.await?;
         Ok(Self { tx, rx })

src/api/downloader.rs

@@ -1,24 +1,30 @@
 //! API for downloads from multiple nodes.
 use std::{
-    collections::{HashMap, HashSet}, fmt::Debug, future::{Future, IntoFuture}, io, ops::Deref, sync::Arc, time::{Duration, SystemTime}
+    collections::{HashMap, HashSet},
+    fmt::Debug,
+    future::{Future, IntoFuture},
+    io,
+    ops::Deref,
+    sync::Arc,
+    time::{Duration, SystemTime},
 };
 
 use anyhow::bail;
 use genawaiter::sync::Gen;
-use iroh::{Endpoint, NodeId, endpoint::Connection};
+use iroh::{endpoint::Connection, Endpoint, NodeId};
 use irpc::{channel::mpsc, rpc_requests};
-use n0_future::{BufferedStreamExt, Stream, StreamExt, future, stream};
+use n0_future::{future, stream, BufferedStreamExt, Stream, StreamExt};
 use rand::seq::SliceRandom;
-use serde::{Deserialize, Serialize, de::Error};
+use serde::{de::Error, Deserialize, Serialize};
 use tokio::{sync::Mutex, task::JoinSet};
 use tokio_util::time::FutureExt;
 use tracing::{info, instrument::Instrument, warn};
 
-use super::{Store, remote::GetConnection};
+use super::{remote::GetConnection, Store};
 use crate::{
-    BlobFormat, Hash, HashAndFormat,
     protocol::{GetManyRequest, GetRequest},
     util::sink::{Drain, IrpcSenderRefSink, Sink, TokioMpscSenderSink},
+    BlobFormat, Hash, HashAndFormat,
 };
 
 #[derive(Debug, Clone)]

src/api/proto.rs

@@ -24,8 +24,8 @@ use std::{
 
 use arrayvec::ArrayString;
 use bao_tree::{
+    io::{mixed::EncodedItem, BaoContentItem, Leaf},
     ChunkRanges,
-    io::{BaoContentItem, Leaf, mixed::EncodedItem},
 };
 use bytes::Bytes;
 use irpc::{
@@ -38,7 +38,7 @@ use serde::{Deserialize, Serialize};
 pub(crate) mod bitfield;
 pub use bitfield::Bitfield;
 
-use crate::{BlobFormat, Hash, HashAndFormat, store::util::Tag, util::temp_tag::TempTag};
+use crate::{store::util::Tag, util::temp_tag::TempTag, BlobFormat, Hash, HashAndFormat};
 
 pub(crate) trait HashSpecific {
     fn hash(&self) -> Hash;

src/api/proto/bitfield.rs

@@ -6,8 +6,8 @@ use serde::{Deserialize, Deserializer, Serialize};
 use smallvec::SmallVec;
 
 use crate::store::util::{
-    RangeSetExt,
     observer::{Combine, CombineInPlace},
+    RangeSetExt,
 };
 
 pub(crate) fn is_validated(size: NonZeroU64, ranges: &ChunkRanges) -> bool {
@@ -275,7 +275,7 @@ impl UpdateResult {
 #[cfg(test)]
 mod tests {
     use bao_tree::{ChunkNum, ChunkRanges};
-    use proptest::prelude::{Strategy, prop};
+    use proptest::prelude::{prop, Strategy};
     use smallvec::SmallVec;
     use test_strategy::proptest;
 

src/api/remote.rs

@@ -4,19 +4,19 @@
 use genawaiter::sync::{Co, Gen};
 use iroh::endpoint::SendStream;
 use irpc::util::{AsyncReadVarintExt, WriteVarintExt};
-use n0_future::{Stream, StreamExt, io};
+use n0_future::{io, Stream, StreamExt};
 use n0_snafu::SpanTrace;
 use nested_enum_utils::common_fields;
 use ref_cast::RefCast;
 use snafu::{Backtrace, IntoError, Snafu};
 
 use super::blobs::Bitfield;
 use crate::{
-    api::{ApiClient, blobs::WriteProgress},
-    get::{BadRequestSnafu, GetError, GetResult, LocalFailureSnafu, Stats, fsm::DecodeError},
+    api::{blobs::WriteProgress, ApiClient},
+    get::{fsm::DecodeError, BadRequestSnafu, GetError, GetResult, LocalFailureSnafu, Stats},
     protocol::{
-        GetManyRequest, MAX_MESSAGE_SIZE, ObserveItem, ObserveRequest, PushRequest, Request,
-        RequestType,
+        GetManyRequest, ObserveItem, ObserveRequest, PushRequest, Request, RequestType,
+        MAX_MESSAGE_SIZE,
     },
     util::sink::{Sink, TokioMpscSenderSink},
 };
@@ -820,28 +820,33 @@ pub enum ExecuteError {
     },
 }
 
-use std::{collections::BTreeMap, future::{Future, IntoFuture}, num::NonZeroU64, sync::Arc};
+use std::{
+    collections::BTreeMap,
+    future::{Future, IntoFuture},
+    num::NonZeroU64,
+    sync::Arc,
+};
 
 use bao_tree::{
-    ChunkNum, ChunkRanges,
     io::{BaoContentItem, Leaf},
+    ChunkNum, ChunkRanges,
 };
 use iroh::endpoint::Connection;
 use tracing::{debug, trace};
 
 use crate::{
-    Hash, HashAndFormat,
-    api::{self, Store, blobs::Blobs},
+    api::{self, blobs::Blobs, Store},
     get::fsm::{AtBlobHeader, AtEndBlob, BlobContentNext, ConnectedNext, EndBlobNext},
     hashseq::{HashSeq, HashSeqIter},
     protocol::{ChunkRangesSeq, GetRequest},
     store::IROH_BLOCK_SIZE,
+    Hash, HashAndFormat,
 };
 
 /// Trait to lazily get a connection
 pub trait GetConnection {
     fn connection(&mut self)
-    -> impl Future<Output = Result<Connection, anyhow::Error>> + Send + '_;
+        -> impl Future<Output = Result<Connection, anyhow::Error>> + Send + '_;
 }
 
 /// If we already have a connection, the impl is trivial
@@ -1055,7 +1060,7 @@ mod tests {
 
     use crate::{
         protocol::{ChunkRangesSeq, GetRequest},
-        store::fs::{FsStore, tests::INTERESTING_SIZES},
+        store::fs::{tests::INTERESTING_SIZES, FsStore},
         tests::{add_test_hash_seq, add_test_hash_seq_incomplete},
         util::ChunkRangesExt,
     };

src/api/tags.rs

@@ -13,10 +13,10 @@ pub use super::proto::{
     TagInfo,
 };
 use super::{
-    ApiClient, Tag, TempTag,
     proto::{CreateTempTagRequest, Scope},
+    ApiClient, Tag, TempTag,
 };
-use crate::{HashAndFormat, api::proto::ListTempTagsRequest};
+use crate::{api::proto::ListTempTagsRequest, HashAndFormat};
 
 /// The API for interacting with tags and temp tags.
 #[derive(Debug, Clone, ref_cast::RefCast)]

src/format/collection.rs

@@ -7,11 +7,11 @@ use bytes::Bytes;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    BlobFormat, Hash,
-    api::{Store, blobs::AddBytesOptions},
-    get::{Stats, fsm},
+    api::{blobs::AddBytesOptions, Store},
+    get::{fsm, Stats},
     hashseq::HashSeq,
     util::temp_tag::TempTag,
+    BlobFormat, Hash,
 };
 
 /// A collection of blobs

src/get.rs

@@ -23,7 +23,7 @@ use std::{
 };
 
 use anyhow::Result;
-use bao_tree::{ChunkNum, io::fsm::BaoContentItem};
+use bao_tree::{io::fsm::BaoContentItem, ChunkNum};
 use fsm::RequestCounters;
 use iroh::endpoint::{self, RecvStream, SendStream};
 use iroh_io::TokioStreamReader;
@@ -33,7 +33,7 @@ use serde::{Deserialize, Serialize};
 use snafu::{Backtrace, IntoError, ResultExt, Snafu};
 use tracing::{debug, error};
 
-use crate::{Hash, protocol::ChunkRangesSeq, store::IROH_BLOCK_SIZE};
+use crate::{protocol::ChunkRangesSeq, store::IROH_BLOCK_SIZE, Hash};
 
 mod error;
 pub mod request;
@@ -91,8 +91,8 @@ pub mod fsm {
     use std::{io, result};
 
     use bao_tree::{
-        BaoTree, ChunkRanges, TreeNode,
         io::fsm::{OutboardMut, ResponseDecoder, ResponseDecoderNext},
+        BaoTree, ChunkRanges, TreeNode,
     };
     use derive_more::From;
     use iroh::endpoint::Connection;
@@ -102,7 +102,7 @@ pub mod fsm {
     use crate::{
         get::error::BadRequestSnafu,
         protocol::{
-            GetManyRequest, GetRequest, MAX_MESSAGE_SIZE, NonEmptyRequestRangeSpecIter, Request,
+            GetManyRequest, GetRequest, NonEmptyRequestRangeSpecIter, Request, MAX_MESSAGE_SIZE,
         },
     };