fix!: enable async I/O code independent of blocking_io

Author: djc

gix-protocol/tests/protocol/fetch/arguments.rs

@@ -2,6 +2,10 @@ use bstr::ByteSlice;
 use gix_transport::Protocol;
 
 use crate::fetch;
+#[cfg(feature = "async-client")]
+use gix_transport::client::git::async_io::Connection;
+#[cfg(feature = "blocking-client")]
+use gix_transport::client::git::blocking_io::Connection;
 
 fn arguments_v1(features: impl IntoIterator<Item = &'static str>) -> fetch::Arguments {
     fetch::Arguments::new(Protocol::V1, features.into_iter().map(|n| (n, None)).collect(), false)
@@ -140,12 +144,9 @@ mod impls {
     }
 }
 
-fn transport(
-    out: &mut Vec<u8>,
-    stateful: bool,
-) -> Transport<gix_transport::client::git::Connection<&'static [u8], &mut Vec<u8>>> {
+fn transport(out: &mut Vec<u8>, stateful: bool) -> Transport<Connection<&'static [u8], &mut Vec<u8>>> {
     Transport {
-        inner: gix_transport::client::git::Connection::new(
+        inner: Connection::new(
             &[],
             out,
             Protocol::V1, // does not matter

gix-protocol/tests/protocol/fetch/mod.rs

@@ -302,9 +302,9 @@ pub fn transport<W: futures_io::AsyncWrite + Unpin>(
     path: &str,
     desired_version: gix_transport::Protocol,
     mode: gix_transport::client::git::ConnectMode,
-) -> gix_transport::client::git::Connection<Cursor, W> {
+) -> gix_transport::client::git::async_io::Connection<Cursor, W> {
     let response = fixture_bytes(path);
-    gix_transport::client::git::Connection::new(
+    gix_transport::client::git::async_io::Connection::new(
         Cursor::new(response),
         out,
         desired_version,
@@ -321,9 +321,9 @@ pub fn transport<W: std::io::Write>(
     path: &str,
     version: gix_transport::Protocol,
     mode: gix_transport::client::git::ConnectMode,
-) -> gix_transport::client::git::Connection<Cursor, W> {
+) -> gix_transport::client::git::blocking_io::Connection<Cursor, W> {
     let response = fixture_bytes(path);
-    gix_transport::client::git::Connection::new(
+    gix_transport::client::git::blocking_io::Connection::new(
         Cursor::new(response),
         out,
         version,

gix-transport/src/client/async_io/connect.rs

@@ -2,7 +2,7 @@ pub use crate::client::non_io_types::connect::{Error, Options};
 
 #[cfg(feature = "async-std")]
 pub(crate) mod function {
-    use crate::client::{async_io::Transport, git, non_io_types::connect::Error};
+    use crate::client::{async_io::Transport, git::async_io::Connection, non_io_types::connect::Error};
 
     /// A general purpose connector connecting to a repository identified by the given `url`.
     ///
@@ -26,7 +26,7 @@ pub(crate) mod function {
                 }
                 let path = std::mem::take(&mut url.path);
                 Box::new(
-                    git::Connection::new_tcp(
+                    Connection::new_tcp(
                         url.host().expect("host is present in url"),
                         url.port,
                         path,

gix-transport/src/client/blocking_io/http/mod.rs

@@ -19,7 +19,8 @@ use crate::{
             http::options::{HttpVersion, SslVersionRangeInclusive},
             ExtendedBufRead, HandleProgress, RequestWriter, SetServiceResponse,
         },
-        capabilities, Capabilities, MessageKind,
+        capabilities::blocking_recv::Outcome,
+        MessageKind,
     },
     packetline::{blocking_io::StreamingPeekableIter, PacketLineRef},
     Protocol, Service,
@@ -402,11 +403,11 @@ impl<H: Http> blocking_io::Transport for Transport<H> {
             line_reader.as_read().read_to_end(&mut Vec::new())?;
         }
 
-        let capabilities::recv::Outcome {
+        let Outcome {
             capabilities,
             refs,
             protocol: actual_protocol,
-        } = Capabilities::from_lines_with_version_detection(line_reader)?;
+        } = Outcome::from_lines_with_version_detection(line_reader)?;
         self.actual_version = actual_protocol;
         self.service = Some(service);
         Ok(SetServiceResponse {

gix-transport/src/client/capabilities.rs

@@ -167,7 +167,7 @@ impl Capabilities {
 
 #[cfg(feature = "blocking-client")]
 ///
-pub mod recv {
+pub mod blocking_recv {
     use std::io;
 
     use bstr::ByteVec;
@@ -178,7 +178,7 @@ pub mod recv {
         Protocol,
     };
 
-    /// Success outcome of [`Capabilities::from_lines_with_version_detection`].
+    /// Success outcome of [`Outcome::from_lines_with_version_detection`].
     pub struct Outcome<'a> {
         /// The [`Capabilities`] the remote advertised.
         pub capabilities: Capabilities,
@@ -191,7 +191,7 @@ pub mod recv {
         pub protocol: Protocol,
     }
 
-    impl Capabilities {
+    impl Outcome<'_> {
         /// Read the capabilities and version advertisement from the given packetline reader.
         ///
         /// If [`Protocol::V1`] was requested, or the remote decided to downgrade, the remote refs
@@ -253,10 +253,10 @@ pub mod recv {
     }
 }
 
-#[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
+#[cfg(feature = "async-client")]
 #[allow(missing_docs)]
 ///
-pub mod recv {
+pub mod async_recv {
     use bstr::ByteVec;
     use futures_io::AsyncRead;
 
@@ -266,7 +266,7 @@ pub mod recv {
         Protocol,
     };
 
-    /// Success outcome of [`Capabilities::from_lines_with_version_detection`].
+    /// Success outcome of [`Outcome::from_lines_with_version_detection`].
     pub struct Outcome<'a> {
         /// The [`Capabilities`] the remote advertised.
         pub capabilities: Capabilities,
@@ -279,7 +279,7 @@ pub mod recv {
         pub protocol: Protocol,
     }
 
-    impl Capabilities {
+    impl Outcome<'_> {
         /// Read the capabilities and version advertisement from the given packetline reader.
         ///
         /// If [`Protocol::V1`] was requested, or the remote decided to downgrade, the remote refs

gix-transport/src/client/git/async_io.rs

@@ -9,9 +9,8 @@ use crate::{
     client::{
         self,
         async_io::{RequestWriter, SetServiceResponse},
-        capabilities,
+        capabilities::async_recv::Outcome,
         git::{self, ConnectionState},
-        Capabilities,
     },
     packetline::{
         async_io::{StreamingPeekableIter, Writer},
@@ -97,11 +96,11 @@ where
             line_writer.flush().await?;
         }
 
-        let capabilities::recv::Outcome {
+        let Outcome {
             capabilities,
             refs,
             protocol: actual_protocol,
-        } = Capabilities::from_lines_with_version_detection(&mut self.line_provider).await?;
+        } = Outcome::from_lines_with_version_detection(&mut self.line_provider).await?;
         Ok(SetServiceResponse {
             actual_protocol,
             capabilities,
@@ -164,9 +163,12 @@ mod async_net {
 
     use async_std::net::TcpStream;
 
-    use crate::client::{git, Error};
+    use crate::client::{
+        git::{async_io::Connection, ConnectMode},
+        Error,
+    };
 
-    impl git::Connection<TcpStream, TcpStream> {
+    impl Connection<TcpStream, TcpStream> {
         /// Create a new TCP connection using the `git` protocol of `desired_version`, and make a connection to `host`
         /// at `port` for accessing the repository at `path` on the server side.
         /// If `trace` is `true`, all packetlines received or sent will be passed to the facilities of the `gix-trace` crate.
@@ -176,20 +178,20 @@ mod async_net {
             path: bstr::BString,
             desired_version: crate::Protocol,
             trace: bool,
-        ) -> Result<git::Connection<TcpStream, TcpStream>, Error> {
+        ) -> Result<Self, Error> {
             let read = async_std::io::timeout(
                 Duration::from_secs(5),
                 TcpStream::connect(&(host, port.unwrap_or(9418))),
             )
             .await?;
             let write = read.clone();
-            Ok(git::Connection::new(
+            Ok(Self::new(
                 read,
                 write,
                 desired_version,
                 path,
                 None::<(String, _)>,
-                git::ConnectMode::Daemon,
+                ConnectMode::Daemon,
                 trace,
             ))
         }

gix-transport/src/client/git/blocking_io.rs

@@ -6,9 +6,8 @@ use crate::{
     client::{
         self,
         blocking_io::{RequestWriter, SetServiceResponse},
-        capabilities,
+        capabilities::blocking_recv::Outcome,
         git::{self, ConnectionState},
-        Capabilities,
     },
     packetline::{
         blocking_io::{StreamingPeekableIter, Writer},
@@ -92,11 +91,11 @@ where
             line_writer.flush()?;
         }
 
-        let capabilities::recv::Outcome {
+        let Outcome {
             capabilities,
             refs,
             protocol: actual_protocol,
-        } = Capabilities::from_lines_with_version_detection(&mut self.line_provider)?;
+        } = Outcome::from_lines_with_version_detection(&mut self.line_provider)?;
         Ok(SetServiceResponse {
             actual_protocol,
             capabilities,

gix-transport/src/client/git/mod.rs

@@ -161,12 +161,10 @@ mod message {
     }
 }
 
-#[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
-pub(crate) mod async_io;
-#[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
-pub use async_io::Connection;
+///
+#[cfg(feature = "async-client")]
+pub mod async_io;
 
+///
 #[cfg(feature = "blocking-client")]
-pub(crate) mod blocking_io;
-#[cfg(feature = "blocking-client")]
-pub use blocking_io::{connect, Connection};
+pub mod blocking_io;

gix-transport/src/client/mod.rs

@@ -1,5 +1,5 @@
 ///
-#[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
+#[cfg(feature = "async-client")]
 pub mod async_io;
 
 mod traits;