From 33fb08b417874bfdce79c8a5d3972aee1ca7ba8b Mon Sep 17 00:00:00 2001 From: Ruediger Klaehn Date: Thu, 14 Nov 2024 10:30:06 +0200 Subject: [PATCH] chore: Consistently format imports... using cargo fmt --all -- --config unstable_features=true --config imports_granularity=Crate,group_imports=StdExternalCrate,reorder_imports=true,format_code_in_doc_comments=true --- examples/errors.rs | 3 ++- examples/macro.rs | 7 +++--- examples/modularize.rs | 20 ++++++++------- examples/split/client/src/main.rs | 12 +++------ examples/split/server/src/main.rs | 8 +++--- examples/split/types/src/lib.rs | 3 ++- examples/store.rs | 3 ++- quic-rpc-derive/src/lib.rs | 3 ++- src/client.rs | 17 +++++++------ src/lib.rs | 39 +++++++++++++++-------------- src/macros.rs | 1 - src/message.rs | 12 +++++---- src/pattern/bidi_streaming.rs | 12 ++++----- src/pattern/client_streaming.rs | 12 ++++----- src/pattern/rpc.rs | 12 ++++----- src/pattern/server_streaming.rs | 12 ++++----- src/pattern/try_server_streaming.rs | 12 ++++----- src/server.rs | 26 ++++++++++--------- src/transport/boxed.rs | 5 ++-- src/transport/combined.rs | 10 +++++--- src/transport/flume.rs | 8 +++--- src/transport/hyper.rs | 10 +++++--- src/transport/iroh_net.rs | 9 +++---- src/transport/mapped.rs | 11 ++++---- src/transport/misc/mod.rs | 6 ++--- src/transport/mod.rs | 9 ++++--- src/transport/quinn.rs | 23 ++++++++++------- tests/math.rs | 9 ++++--- 28 files changed, 163 insertions(+), 151 deletions(-) diff --git a/examples/errors.rs b/examples/errors.rs index fabf864..a8e015e 100644 --- a/examples/errors.rs +++ b/examples/errors.rs @@ -1,7 +1,8 @@ +use std::result; + use derive_more::{Display, From, TryInto}; use quic_rpc::{message::RpcMsg, RpcClient, RpcServer, Service}; use serde::{Deserialize, Serialize}; -use std::result; #[derive(Debug, Serialize, Deserialize)] struct WriteRequest(String, Vec); diff --git a/examples/macro.rs b/examples/macro.rs index 88e76d2..1a5f2b6 100644 --- a/examples/macro.rs +++ b/examples/macro.rs @@ -1,7 +1,8 @@ mod store_rpc { + use std::fmt::Debug; + use quic_rpc::rpc_service; use serde::{Deserialize, Serialize}; - use std::fmt::Debug; pub type Cid = [u8; 32]; @@ -51,9 +52,7 @@ mod store_rpc { use async_stream::stream; use futures_lite::{Stream, StreamExt}; use futures_util::SinkExt; -use quic_rpc::client::RpcClient; -use quic_rpc::server::run_server_loop; -use quic_rpc::transport::flume; +use quic_rpc::{client::RpcClient, server::run_server_loop, transport::flume}; use store_rpc::*; #[derive(Clone)] diff --git a/examples/modularize.rs b/examples/modularize.rs index e574c1b..700fc93 100644 --- a/examples/modularize.rs +++ b/examples/modularize.rs @@ -8,13 +8,12 @@ //! unchanged. use anyhow::Result; +use app::AppService; use futures_lite::StreamExt; use futures_util::SinkExt; use quic_rpc::{client::BoxedConnector, transport::flume, Listener, RpcClient, RpcServer}; use tracing::warn; -use app::AppService; - #[tokio::main] async fn main() -> Result<()> { // Spawn an inmemory connection. @@ -99,12 +98,13 @@ mod app { //! //! It could also easily compose services from other crates or internal modules. - use super::iroh; use anyhow::Result; use derive_more::{From, TryInto}; use quic_rpc::{message::RpcMsg, server::RpcChannel, Listener, RpcClient, Service}; use serde::{Deserialize, Serialize}; + use super::iroh; + #[derive(Debug, Serialize, Deserialize, From, TryInto)] pub enum Request { Iroh(iroh::Request), @@ -271,6 +271,8 @@ mod calc { //! This is a library providing a service, and a client. E.g. iroh-bytes or iroh-hypermerge. //! It does not use any `super` imports, it is completely decoupled. + use std::fmt::Debug; + use anyhow::{bail, Result}; use derive_more::{From, TryInto}; use futures_lite::{Stream, StreamExt}; @@ -280,7 +282,6 @@ mod calc { RpcClient, Service, }; use serde::{Deserialize, Serialize}; - use std::fmt::Debug; #[derive(Debug, Serialize, Deserialize)] pub struct AddRequest(pub i64, pub i64); @@ -385,6 +386,12 @@ mod clock { //! This is a library providing a service, and a client. E.g. iroh-bytes or iroh-hypermerge. //! It does not use any `super` imports, it is completely decoupled. + use std::{ + fmt::Debug, + sync::{Arc, RwLock}, + time::Duration, + }; + use anyhow::Result; use derive_more::{From, TryInto}; use futures_lite::{stream::Boxed as BoxStream, Stream, StreamExt}; @@ -395,11 +402,6 @@ mod clock { RpcClient, Service, }; use serde::{Deserialize, Serialize}; - use std::{ - fmt::Debug, - sync::{Arc, RwLock}, - time::Duration, - }; use tokio::sync::Notify; #[derive(Debug, Serialize, Deserialize)] diff --git a/examples/split/client/src/main.rs b/examples/split/client/src/main.rs index f68406d..9544ed4 100644 --- a/examples/split/client/src/main.rs +++ b/examples/split/client/src/main.rs @@ -1,15 +1,11 @@ #![allow(unknown_lints, non_local_definitions)] -use std::net::SocketAddr; -use std::sync::Arc; +use std::{net::SocketAddr, sync::Arc}; use anyhow::Result; -use futures::sink::SinkExt; -use futures::stream::StreamExt; -use quic_rpc::transport::quinn::QuinnConnector; -use quic_rpc::RpcClient; -use quinn::crypto::rustls::QuicClientConfig; -use quinn::{ClientConfig, Endpoint}; +use futures::{sink::SinkExt, stream::StreamExt}; +use quic_rpc::{transport::quinn::QuinnConnector, RpcClient}; +use quinn::{crypto::rustls::QuicClientConfig, ClientConfig, Endpoint}; use types::compute::*; // types::create_compute_client!(ComputeClient); diff --git a/examples/split/server/src/main.rs b/examples/split/server/src/main.rs index ec28ad0..1f1dd8a 100644 --- a/examples/split/server/src/main.rs +++ b/examples/split/server/src/main.rs @@ -1,11 +1,9 @@ +use std::{net::SocketAddr, sync::Arc}; + use async_stream::stream; use futures::stream::{Stream, StreamExt}; -use quic_rpc::server::run_server_loop; -use quic_rpc::transport::quinn::QuinnListener; +use quic_rpc::{server::run_server_loop, transport::quinn::QuinnListener}; use quinn::{Endpoint, ServerConfig}; -use std::net::SocketAddr; -use std::sync::Arc; - use types::compute::*; #[derive(Clone)] diff --git a/examples/split/types/src/lib.rs b/examples/split/types/src/lib.rs index a80922f..a25a6fd 100644 --- a/examples/split/types/src/lib.rs +++ b/examples/split/types/src/lib.rs @@ -1,7 +1,8 @@ pub mod compute { + use std::fmt::Debug; + use quic_rpc::rpc_service; use serde::{Deserialize, Serialize}; - use std::fmt::Debug; /// compute the square of a number #[derive(Debug, Serialize, Deserialize)] diff --git a/examples/store.rs b/examples/store.rs index 6339218..b99edea 100644 --- a/examples/store.rs +++ b/examples/store.rs @@ -1,4 +1,6 @@ #![allow(clippy::enum_variant_names)] +use std::{fmt::Debug, result}; + use async_stream::stream; use derive_more::{From, TryInto}; use futures_lite::{Stream, StreamExt}; @@ -9,7 +11,6 @@ use quic_rpc::{ *, }; use serde::{Deserialize, Serialize}; -use std::{fmt::Debug, result}; type Cid = [u8; 32]; #[derive(Debug, Serialize, Deserialize)] diff --git a/quic-rpc-derive/src/lib.rs b/quic-rpc-derive/src/lib.rs index 5c1b47b..fee1096 100644 --- a/quic-rpc-derive/src/lib.rs +++ b/quic-rpc-derive/src/lib.rs @@ -1,7 +1,8 @@ +use std::collections::{BTreeMap, HashSet}; + use proc_macro::TokenStream; use proc_macro2::{Span, TokenStream as TokenStream2}; use quote::{quote, ToTokens}; -use std::collections::{BTreeMap, HashSet}; use syn::{ parse::{Parse, ParseStream}, parse_macro_input, diff --git a/src/client.rs b/src/client.rs index a88da1f..2afec98 100644 --- a/src/client.rs +++ b/src/client.rs @@ -1,14 +1,6 @@ //! Client side api //! //! The main entry point is [RpcClient]. -use crate::{ - transport::{boxed::BoxableConnector, mapped::MappedConnector, StreamTypes}, - Connector, Service, -}; -use futures_lite::Stream; -use futures_sink::Sink; - -use pin_project::pin_project; use std::{ fmt::Debug, marker::PhantomData, @@ -16,6 +8,15 @@ use std::{ task::{Context, Poll}, }; +use futures_lite::Stream; +use futures_sink::Sink; +use pin_project::pin_project; + +use crate::{ + transport::{boxed::BoxableConnector, mapped::MappedConnector, StreamTypes}, + Connector, Service, +}; + /// Type alias for a boxed connection to a specific service /// /// This is a convenience type alias for a boxed connection to a specific service. diff --git a/src/lib.rs b/src/lib.rs index 89ebc29..329dc3a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -13,9 +13,9 @@ //! # Example //! ``` //! # async fn example() -> anyhow::Result<()> { -//! use quic_rpc::{message::RpcMsg, Service, RpcClient, RpcServer}; -//! use serde::{Serialize, Deserialize}; //! use derive_more::{From, TryInto}; +//! use quic_rpc::{message::RpcMsg, RpcClient, RpcServer, Service}; +//! use serde::{Deserialize, Serialize}; //! //! // Define your messages //! #[derive(Debug, Serialize, Deserialize)] @@ -39,13 +39,13 @@ //! } //! //! impl Service for PingService { -//! type Req = PingRequest; -//! type Res = PingResponse; +//! type Req = PingRequest; +//! type Res = PingResponse; //! } //! //! // Define interaction patterns for each request type //! impl RpcMsg for Ping { -//! type Response = Pong; +//! type Response = Pong; //! } //! //! // create a transport channel, here a memory channel for testing @@ -53,7 +53,7 @@ //! //! // client side //! // create the rpc client given the channel and the service type -//! let mut client = RpcClient::::new(client); +//! let mut client = RpcClient::::new(client); //! //! // call the service //! let res = client.rpc(Ping).await?; @@ -64,12 +64,12 @@ //! //! let handler = Handler; //! loop { -//! // accept connections -//! let (msg, chan) = server.accept().await?.read_first().await?; -//! // dispatch the message to the appropriate handler -//! match msg { -//! PingRequest::Ping(ping) => chan.rpc(ping, handler, Handler::ping).await?, -//! } +//! // accept connections +//! let (msg, chan) = server.accept().await?.read_first().await?; +//! // dispatch the message to the appropriate handler +//! match msg { +//! PingRequest::Ping(ping) => chan.rpc(ping, handler, Handler::ping).await?, +//! } //! } //! //! // the handler. For a more complex example, this would contain any state @@ -78,21 +78,22 @@ //! struct Handler; //! //! impl Handler { -//! // the handle fn for a Ping request. +//! // the handle fn for a Ping request. //! -//! // The return type is the response type for the service. -//! // Note that this must take self by value, not by reference. -//! async fn ping(self, _req: Ping) -> Pong { -//! Pong -//! } +//! // The return type is the response type for the service. +//! // Note that this must take self by value, not by reference. +//! async fn ping(self, _req: Ping) -> Pong { +//! Pong +//! } //! } //! # Ok(()) //! # } //! ``` #![deny(missing_docs)] #![deny(rustdoc::broken_intra_doc_links)] -use serde::{de::DeserializeOwned, Serialize}; use std::fmt::{Debug, Display}; + +use serde::{de::DeserializeOwned, Serialize}; pub mod client; pub mod message; pub mod server; diff --git a/src/macros.rs b/src/macros.rs index 03cf475..2f2ba6c 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -111,7 +111,6 @@ /// server_handle.await??; /// Ok(()) /// } -/// /// ``` /// /// The generation of the macros in `CreateDispatch` and `CreateClient` diff --git a/src/message.rs b/src/message.rs index d7c9caf..688303f 100644 --- a/src/message.rs +++ b/src/message.rs @@ -1,13 +1,15 @@ //! Service definition //! //! Traits to define the behaviour of messages for services -use crate::Service; use std::fmt::Debug; -pub use crate::pattern::bidi_streaming::{BidiStreaming, BidiStreamingMsg}; -pub use crate::pattern::client_streaming::{ClientStreaming, ClientStreamingMsg}; -pub use crate::pattern::rpc::{Rpc, RpcMsg}; -pub use crate::pattern::server_streaming::{ServerStreaming, ServerStreamingMsg}; +pub use crate::pattern::{ + bidi_streaming::{BidiStreaming, BidiStreamingMsg}, + client_streaming::{ClientStreaming, ClientStreamingMsg}, + rpc::{Rpc, RpcMsg}, + server_streaming::{ServerStreaming, ServerStreamingMsg}, +}; +use crate::Service; /// Declares the interaction pattern for a message and a service. /// diff --git a/src/pattern/bidi_streaming.rs b/src/pattern/bidi_streaming.rs index 53e6275..6ea94d5 100644 --- a/src/pattern/bidi_streaming.rs +++ b/src/pattern/bidi_streaming.rs @@ -1,5 +1,11 @@ //! Bidirectional stream interaction pattern. +use std::{ + error, + fmt::{self, Debug}, + result, +}; + use futures_lite::{Stream, StreamExt}; use futures_util::{FutureExt, SinkExt}; @@ -11,12 +17,6 @@ use crate::{ RpcClient, Service, }; -use std::{ - error, - fmt::{self, Debug}, - result, -}; - /// Bidirectional streaming interaction pattern /// /// After the initial request, the client can send updates and the server can diff --git a/src/pattern/client_streaming.rs b/src/pattern/client_streaming.rs index 729b8c7..055aaab 100644 --- a/src/pattern/client_streaming.rs +++ b/src/pattern/client_streaming.rs @@ -1,5 +1,11 @@ //! Client streaming interaction pattern. +use std::{ + error, + fmt::{self, Debug}, + result, +}; + use futures_lite::{future::Boxed, Future, StreamExt}; use futures_util::{FutureExt, SinkExt, TryFutureExt}; @@ -11,12 +17,6 @@ use crate::{ Connector, RpcClient, Service, }; -use std::{ - error, - fmt::{self, Debug}, - result, -}; - /// Client streaming interaction pattern /// /// After the initial request, the client can send updates, but there is only diff --git a/src/pattern/rpc.rs b/src/pattern/rpc.rs index 9337113..044069c 100644 --- a/src/pattern/rpc.rs +++ b/src/pattern/rpc.rs @@ -1,5 +1,11 @@ //! RPC interaction pattern. +use std::{ + error, + fmt::{self, Debug}, + result, +}; + use futures_lite::{Future, StreamExt}; use futures_util::{FutureExt, SinkExt}; @@ -10,12 +16,6 @@ use crate::{ Connector, RpcClient, Service, }; -use std::{ - error, - fmt::{self, Debug}, - result, -}; - /// Rpc interaction pattern /// /// There is only one request and one response. diff --git a/src/pattern/server_streaming.rs b/src/pattern/server_streaming.rs index d1889e4..26d2846 100644 --- a/src/pattern/server_streaming.rs +++ b/src/pattern/server_streaming.rs @@ -1,5 +1,11 @@ //! Server streaming interaction pattern. +use std::{ + error, + fmt::{self, Debug}, + result, +}; + use futures_lite::{Stream, StreamExt}; use futures_util::{FutureExt, SinkExt, TryFutureExt}; @@ -11,12 +17,6 @@ use crate::{ RpcClient, Service, }; -use std::{ - error, - fmt::{self, Debug}, - result, -}; - /// Server streaming interaction pattern /// /// After the initial request, the server can send a stream of responses. diff --git a/src/pattern/try_server_streaming.rs b/src/pattern/try_server_streaming.rs index 46d705d..e3ebb06 100644 --- a/src/pattern/try_server_streaming.rs +++ b/src/pattern/try_server_streaming.rs @@ -1,5 +1,11 @@ //! Fallible server streaming interaction pattern. +use std::{ + error, + fmt::{self, Debug}, + result, +}; + use futures_lite::{Future, Stream, StreamExt}; use futures_util::{FutureExt, SinkExt, TryFutureExt}; use serde::{Deserialize, Serialize}; @@ -12,12 +18,6 @@ use crate::{ Connector, RpcClient, Service, }; -use std::{ - error, - fmt::{self, Debug}, - result, -}; - /// A guard message to indicate that the stream has been created. /// /// This is so we can dinstinguish between an error creating the stream and diff --git a/src/server.rs b/src/server.rs index 1d35425..76644b2 100644 --- a/src/server.rs +++ b/src/server.rs @@ -1,18 +1,6 @@ //! Server side api //! //! The main entry point is [RpcServer] -use crate::{ - transport::{ - self, - boxed::BoxableListener, - mapped::{ErrorOrMapError, MappedRecvStream, MappedSendSink, MappedStreamTypes}, - ConnectionErrors, StreamTypes, - }, - Listener, RpcMessage, Service, -}; -use futures_lite::{Future, Stream, StreamExt}; -use futures_util::{SinkExt, TryStreamExt}; -use pin_project::pin_project; use std::{ error, fmt::{self, Debug}, @@ -21,8 +9,22 @@ use std::{ result, task::{self, Poll}, }; + +use futures_lite::{Future, Stream, StreamExt}; +use futures_util::{SinkExt, TryStreamExt}; +use pin_project::pin_project; use tokio::sync::oneshot; +use crate::{ + transport::{ + self, + boxed::BoxableListener, + mapped::{ErrorOrMapError, MappedRecvStream, MappedSendSink, MappedStreamTypes}, + ConnectionErrors, StreamTypes, + }, + Listener, RpcMessage, Service, +}; + /// Stream types on the server side /// /// On the server side, we receive requests and send responses. diff --git a/src/transport/boxed.rs b/src/transport/boxed.rs index 62ff4a9..d8f65ae 100644 --- a/src/transport/boxed.rs +++ b/src/transport/boxed.rs @@ -2,6 +2,7 @@ use std::{ fmt::Debug, + future::Future, pin::Pin, task::{Context, Poll}, }; @@ -10,11 +11,9 @@ use futures_lite::FutureExt; use futures_sink::Sink; use futures_util::{future::BoxFuture, SinkExt, Stream, StreamExt, TryStreamExt}; use pin_project::pin_project; -use std::future::Future; - -use crate::RpcMessage; use super::{ConnectionErrors, StreamTypes}; +use crate::RpcMessage; type BoxedFuture<'a, T> = Pin + Send + Sync + 'a>>; enum SendSinkInner { diff --git a/src/transport/combined.rs b/src/transport/combined.rs index 1829a3f..60e6843 100644 --- a/src/transport/combined.rs +++ b/src/transport/combined.rs @@ -1,8 +1,4 @@ //! Transport that combines two other transports -use super::{ConnectionErrors, Connector, Listener, LocalAddr, StreamTypes}; -use futures_lite::Stream; -use futures_sink::Sink; -use pin_project::pin_project; use std::{ error, fmt, fmt::Debug, @@ -10,6 +6,12 @@ use std::{ task::{Context, Poll}, }; +use futures_lite::Stream; +use futures_sink::Sink; +use pin_project::pin_project; + +use super::{ConnectionErrors, Connector, Listener, LocalAddr, StreamTypes}; + /// A connection that combines two other connections #[derive(Debug, Clone)] pub struct CombinedConnector { diff --git a/src/transport/flume.rs b/src/transport/flume.rs index 2671953..8db6d03 100644 --- a/src/transport/flume.rs +++ b/src/transport/flume.rs @@ -1,17 +1,17 @@ //! Memory transport implementation using [flume] //! //! [flume]: https://docs.rs/flume/ +use core::fmt; +use std::{error, fmt::Display, marker::PhantomData, pin::Pin, result, task::Poll}; + use futures_lite::{Future, Stream}; use futures_sink::Sink; +use super::StreamTypes; use crate::{ transport::{ConnectionErrors, Connector, Listener, LocalAddr}, RpcMessage, }; -use core::fmt; -use std::{error, fmt::Display, marker::PhantomData, pin::Pin, result, task::Poll}; - -use super::StreamTypes; /// Error when receiving from a channel /// diff --git a/src/transport/hyper.rs b/src/transport/hyper.rs index 131c576..41cc207 100644 --- a/src/transport/hyper.rs +++ b/src/transport/hyper.rs @@ -6,8 +6,6 @@ use std::{ sync::Arc, task::Poll, }; -use crate::transport::{ConnectionErrors, Connector, Listener, LocalAddr, StreamTypes}; -use crate::RpcMessage; use bytes::Bytes; use flume::{Receiver, Sender}; use futures_lite::{Stream, StreamExt}; @@ -18,10 +16,14 @@ use hyper::{ service::{make_service_fn, service_fn}, Body, Client, Request, Response, Server, StatusCode, Uri, }; -use tokio::sync::mpsc; -use tokio::task::JoinHandle; +use tokio::{sync::mpsc, task::JoinHandle}; use tracing::{debug, event, trace, Level}; +use crate::{ + transport::{ConnectionErrors, Connector, Listener, LocalAddr, StreamTypes}, + RpcMessage, +}; + struct HyperConnectionInner { client: Box, config: Arc, diff --git a/src/transport/iroh_net.rs b/src/transport/iroh_net.rs index e992818..6926a5d 100644 --- a/src/transport/iroh_net.rs +++ b/src/transport/iroh_net.rs @@ -1,10 +1,5 @@ //! iroh-net transport implementation based on [iroh-net](https://crates.io/crates/iroh-net) -use crate::{ - transport::{ConnectionErrors, Connector, Listener, LocalAddr}, - RpcMessage, -}; - use std::{ collections::BTreeSet, fmt, @@ -32,6 +27,10 @@ use super::{ util::{FramedBincodeRead, FramedBincodeWrite}, StreamTypes, }; +use crate::{ + transport::{ConnectionErrors, Connector, Listener, LocalAddr}, + RpcMessage, +}; const MAX_FRAME_LENGTH: usize = 1024 * 1024 * 16; diff --git a/src/transport/mapped.rs b/src/transport/mapped.rs index fbdee41..649ac1f 100644 --- a/src/transport/mapped.rs +++ b/src/transport/mapped.rs @@ -9,9 +9,8 @@ use futures_lite::{Stream, StreamExt}; use futures_util::SinkExt; use pin_project::pin_project; -use crate::{RpcError, RpcMessage}; - use super::{ConnectionErrors, Connector, StreamTypes}; +use crate::{RpcError, RpcMessage}; /// A connection that maps input and output types #[derive(Debug)] @@ -249,15 +248,15 @@ where #[cfg(feature = "flume-transport")] mod tests { + use serde::{Deserialize, Serialize}; + use testresult::TestResult; + + use super::*; use crate::{ server::{BoxedChannelTypes, RpcChannel}, transport::Listener, RpcClient, RpcServer, }; - use serde::{Deserialize, Serialize}; - use testresult::TestResult; - - use super::*; #[derive(Debug, Clone, Serialize, Deserialize, derive_more::From, derive_more::TryInto)] enum Request { diff --git a/src/transport/misc/mod.rs b/src/transport/misc/mod.rs index 756d6c3..59bd19c 100644 --- a/src/transport/misc/mod.rs +++ b/src/transport/misc/mod.rs @@ -1,14 +1,14 @@ //! Miscellaneous transport utilities +use std::convert::Infallible; + use futures_lite::stream; use futures_sink::Sink; +use super::StreamTypes; use crate::{ transport::{ConnectionErrors, Listener}, RpcMessage, }; -use std::convert::Infallible; - -use super::StreamTypes; /// A dummy listener that does nothing /// diff --git a/src/transport/mod.rs b/src/transport/mod.rs index 022bf0d..e88b2bf 100644 --- a/src/transport/mod.rs +++ b/src/transport/mod.rs @@ -17,16 +17,17 @@ //! types are defined by implementing the [`StreamTypes`] trait. //! //! Errors for both sides are defined by implementing the [`ConnectionErrors`] trait. +use std::{ + fmt::{self, Debug, Display}, + net::SocketAddr, +}; + use boxed::{BoxableConnector, BoxableListener, BoxedConnector, BoxedListener}; use futures_lite::{Future, Stream}; use futures_sink::Sink; use mapped::MappedConnector; use crate::{RpcError, RpcMessage}; -use std::{ - fmt::{self, Debug, Display}, - net::SocketAddr, -}; pub mod boxed; pub mod combined; diff --git a/src/transport/quinn.rs b/src/transport/quinn.rs index db5c3bb..34ac38f 100644 --- a/src/transport/quinn.rs +++ b/src/transport/quinn.rs @@ -1,18 +1,19 @@ //! QUIC transport implementation based on [quinn](https://crates.io/crates/quinn) -use crate::{ - transport::{ConnectionErrors, Connector, Listener, LocalAddr}, - RpcMessage, +use std::{ + fmt, io, + marker::PhantomData, + net::SocketAddr, + pin::Pin, + result, + sync::Arc, + task::{Context, Poll}, }; + use futures_lite::{Future, Stream, StreamExt}; use futures_sink::Sink; use futures_util::FutureExt; use pin_project::pin_project; -use serde::de::DeserializeOwned; -use serde::Serialize; -use std::net::SocketAddr; -use std::sync::Arc; -use std::task::{Context, Poll}; -use std::{fmt, io, marker::PhantomData, pin::Pin, result}; +use serde::{de::DeserializeOwned, Serialize}; use tokio::sync::oneshot; use tracing::{debug_span, Instrument}; @@ -20,6 +21,10 @@ use super::{ util::{FramedBincodeRead, FramedBincodeWrite}, StreamTypes, }; +use crate::{ + transport::{ConnectionErrors, Connector, Listener, LocalAddr}, + RpcMessage, +}; const MAX_FRAME_LENGTH: usize = 1024 * 1024 * 16; diff --git a/tests/math.rs b/tests/math.rs index 892bd55..fd85166 100644 --- a/tests/math.rs +++ b/tests/math.rs @@ -5,6 +5,11 @@ feature = "iroh-net-transport", ))] #![allow(dead_code)] +use std::{ + io::{self, Write}, + result, +}; + use async_stream::stream; use derive_more::{From, TryInto}; use futures_buffered::BufferedStreamExt; @@ -20,10 +25,6 @@ use quic_rpc::{ Connector, Listener, RpcClient, RpcServer, Service, }; use serde::{Deserialize, Serialize}; -use std::{ - io::{self, Write}, - result, -}; use thousands::Separable; /// compute the square of a number