Merge pull request #2236 from djc/additive-transport

transport: make I/O mode features additive

Author: Byron

gitoxide-core/src/net.rs

@@ -1,5 +1,10 @@
 use std::str::FromStr;
 
+#[cfg(feature = "async-client")]
+use gix::protocol::transport::client::async_io as io_mode;
+#[cfg(feature = "blocking-client")]
+use gix::protocol::transport::client::blocking_io as io_mode;
+
 #[derive(Default, Clone, Eq, PartialEq, Debug)]
 pub enum Protocol {
     V1,
@@ -39,17 +44,14 @@ mod impls {
 #[gix::protocol::maybe_async::maybe_async]
 pub async fn connect<Url, E>(
     url: Url,
-    options: gix::protocol::transport::client::connect::Options,
-) -> Result<
-    gix::protocol::SendFlushOnDrop<Box<dyn gix::protocol::transport::client::Transport + Send>>,
-    gix::protocol::transport::client::connect::Error,
->
+    options: io_mode::connect::Options,
+) -> Result<gix::protocol::SendFlushOnDrop<Box<dyn io_mode::Transport + Send>>, io_mode::connect::Error>
 where
     Url: TryInto<gix::url::Url, Error = E>,
     gix::url::parse::Error: From<E>,
 {
     Ok(gix::protocol::SendFlushOnDrop::new(
-        gix::protocol::transport::connect(url, options).await?,
+        io_mode::connect::connect(url, options).await?,
         false,
     ))
 }

gitoxide-core/src/pack/receive.rs

@@ -4,6 +4,10 @@ use std::{
     sync::{atomic::AtomicBool, Arc},
 };
 
+#[cfg(feature = "async-client")]
+use gix::protocol::transport::client::async_io::connect;
+#[cfg(feature = "blocking-client")]
+use gix::protocol::transport::client::blocking_io::connect;
 use gix::{config::tree::Key, protocol::maybe_async, remote::fetch::Error, DynNestedProgress};
 pub use gix::{
     hash::ObjectId,
@@ -47,7 +51,7 @@ where
 {
     let mut transport = net::connect(
         url,
-        gix::protocol::transport::client::connect::Options {
+        connect::Options {
             version: protocol.unwrap_or_default().into(),
             ..Default::default()
         },

gix-protocol/src/fetch/arguments/async_io.rs

@@ -1,15 +1,18 @@
 use futures_lite::io::AsyncWriteExt;
-use gix_transport::{client, client::TransportV2Ext};
+use gix_transport::client::{
+    self,
+    async_io::{ExtendedBufRead, Transport, TransportV2Ext},
+};
 
 use crate::{fetch::Arguments, Command};
 
 impl Arguments {
     /// Send fetch arguments to the server, and indicate this is the end of negotiations only if `add_done_argument` is present.
-    pub async fn send<'a, T: client::Transport + 'a>(
+    pub async fn send<'a, T: Transport + 'a>(
         &mut self,
         transport: &'a mut T,
         add_done_argument: bool,
-    ) -> Result<Box<dyn client::ExtendedBufRead<'a> + Unpin + 'a>, client::Error> {
+    ) -> Result<Box<dyn ExtendedBufRead<'a> + Unpin + 'a>, client::Error> {
         if self.haves.is_empty() {
             assert!(add_done_argument, "If there are no haves, is_done must be true.");
         }

gix-protocol/src/fetch/arguments/blocking_io.rs

@@ -1,16 +1,19 @@
 use std::io::Write;
 
-use gix_transport::{client, client::TransportV2Ext};
+use gix_transport::client::{
+    self,
+    blocking_io::{ExtendedBufRead, Transport, TransportV2Ext},
+};
 
 use crate::{fetch::Arguments, Command};
 
 impl Arguments {
     /// Send fetch arguments to the server, and indicate this is the end of negotiations only if `add_done_argument` is present.
-    pub fn send<'a, T: client::Transport + 'a>(
+    pub fn send<'a, T: Transport + 'a>(
         &mut self,
         transport: &'a mut T,
         add_done_argument: bool,
-    ) -> Result<Box<dyn client::ExtendedBufRead<'a> + Unpin + 'a>, client::Error> {
+    ) -> Result<Box<dyn ExtendedBufRead<'a> + Unpin + 'a>, client::Error> {
         if self.haves.is_empty() {
             assert!(add_done_argument, "If there are no haves, is_done must be true.");
         }

gix-protocol/src/fetch/function.rs

@@ -5,6 +5,10 @@ use std::{
 
 use gix_features::progress::DynNestedProgress;
 
+#[cfg(feature = "async-client")]
+use crate::transport::client::async_io::{ExtendedBufRead, HandleProgress, Transport};
+#[cfg(feature = "blocking-client")]
+use crate::transport::client::blocking_io::{ExtendedBufRead, HandleProgress, Transport};
 use crate::{
     fetch::{
         negotiate, Arguments, Context, Error, Negotiate, NegotiateOutcome, Options, Outcome, ProgressId, Shallow, Tags,
@@ -56,7 +60,7 @@ pub async fn fetch<P, T, E>(
 where
     P: gix_features::progress::NestedProgress,
     P::SubProgress: 'static,
-    T: gix_transport::client::Transport,
+    T: Transport,
     E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
 {
     let _span = gix_trace::coarse!("gix_protocol::fetch()");
@@ -251,10 +255,9 @@ fn add_shallow_args(
 
 fn setup_remote_progress<'a>(
     progress: &mut dyn gix_features::progress::DynNestedProgress,
-    reader: &mut Box<dyn crate::transport::client::ExtendedBufRead<'a> + Unpin + 'a>,
+    reader: &mut Box<dyn ExtendedBufRead<'a> + Unpin + 'a>,
     should_interrupt: &'a AtomicBool,
 ) {
-    use crate::transport::client::ExtendedBufRead;
     reader.set_progress_handler(Some(Box::new({
         let mut remote_progress = progress.add_child_with_id("remote".to_string(), ProgressId::RemoteProgress.into());
         move |is_err: bool, data: &[u8]| {
@@ -265,5 +268,5 @@ fn setup_remote_progress<'a>(
                 ProgressAction::Continue
             }
         }
-    }) as crate::transport::client::HandleProgress<'a>));
+    }) as HandleProgress<'a>));
 }

gix-protocol/src/fetch/handshake.rs

@@ -1,7 +1,11 @@
 use gix_features::progress::Progress;
-use gix_transport::{client, Service};
+use gix_transport::Service;
 use maybe_async::maybe_async;
 
+#[cfg(feature = "async-client")]
+use crate::transport::client::async_io::Transport;
+#[cfg(feature = "blocking-client")]
+use crate::transport::client::blocking_io::Transport;
 use crate::{
     credentials,
     handshake::{Error, Outcome},
@@ -21,7 +25,7 @@ pub async fn upload_pack<AuthFn, T>(
 ) -> Result<Outcome, Error>
 where
     AuthFn: FnMut(credentials::helper::Action) -> credentials::protocol::Result,
-    T: client::Transport,
+    T: Transport,
 {
     crate::handshake(transport, Service::UploadPack, authenticate, extra_parameters, progress).await
 }

gix-protocol/src/fetch/refmap/init.rs

@@ -3,13 +3,16 @@ use std::collections::HashSet;
 use bstr::{BString, ByteVec};
 use gix_features::progress::Progress;
 
+#[cfg(feature = "async-client")]
+use crate::transport::client::async_io::Transport;
+#[cfg(feature = "blocking-client")]
+use crate::transport::client::blocking_io::Transport;
 use crate::{
     fetch,
     fetch::{
         refmap::{Mapping, Source, SpecIndex},
         RefMap,
     },
-    transport::client::Transport,
 };
 
 /// The error returned by [`RefMap::new()`].

gix-protocol/src/fetch/response/async_io.rs

@@ -1,5 +1,6 @@
 use std::io;
 
+use crate::transport::client::async_io::ExtendedBufRead;
 use gix_transport::{client, Protocol};
 
 use crate::fetch::{
@@ -10,7 +11,7 @@ use crate::fetch::{
 
 async fn parse_v2_section<T>(
     line: &mut String,
-    reader: &mut (impl client::ExtendedBufRead<'_> + Unpin),
+    reader: &mut (impl ExtendedBufRead<'_> + Unpin),
     res: &mut Vec<T>,
     parse: impl Fn(&str) -> Result<T, response::Error>,
 ) -> Result<bool, response::Error> {
@@ -44,7 +45,7 @@ impl Response {
     /// that `git` has to use to predict how many acks are supposed to be read. We also genuinely hope that this covers it all….
     pub async fn from_line_reader(
         version: Protocol,
-        reader: &mut (impl client::ExtendedBufRead<'_> + Unpin),
+        reader: &mut (impl ExtendedBufRead<'_> + Unpin),
         client_expects_pack: bool,
         wants_to_negotiate: bool,
     ) -> Result<Response, response::Error> {

gix-protocol/src/fetch/response/blocking_io.rs

@@ -1,6 +1,7 @@
 use std::io;
 
-use gix_transport::{client, Protocol};
+use crate::transport::client::blocking_io::ExtendedBufRead;
+use crate::transport::{client::MessageKind, Protocol};
 
 use crate::fetch::{
     response,
@@ -10,7 +11,7 @@ use crate::fetch::{
 
 fn parse_v2_section<'a, T>(
     line: &mut String,
-    reader: &mut impl client::ExtendedBufRead<'a>,
+    reader: &mut impl ExtendedBufRead<'a>,
     res: &mut Vec<T>,
     parse: impl Fn(&str) -> Result<T, response::Error>,
 ) -> Result<bool, response::Error> {
@@ -20,7 +21,7 @@ fn parse_v2_section<'a, T>(
         line.clear();
     }
     // End of message, or end of section?
-    Ok(if reader.stopped_at() == Some(client::MessageKind::Delimiter) {
+    Ok(if reader.stopped_at() == Some(MessageKind::Delimiter) {
         // try reading more sections
         reader.reset(Protocol::V2);
         false
@@ -44,7 +45,7 @@ impl Response {
     /// that `git` has to use to predict how many acks are supposed to be read. We also genuinely hope that this covers it all….
     pub fn from_line_reader<'a>(
         version: Protocol,
-        reader: &mut impl client::ExtendedBufRead<'a>,
+        reader: &mut impl ExtendedBufRead<'a>,
         client_expects_pack: bool,
         wants_to_negotiate: bool,
     ) -> Result<Response, response::Error> {
@@ -71,7 +72,7 @@ impl Response {
                             // maybe we saw a shallow flush packet, let's reset and retry
                             debug_assert_eq!(
                                 reader.stopped_at(),
-                                Some(client::MessageKind::Flush),
+                                Some(MessageKind::Flush),
                                 "If this isn't a flush packet, we don't know what's going on"
                             );
                             reader.readline_str(&mut line)?;

gix-protocol/src/handshake/function.rs

@@ -1,8 +1,12 @@
 use gix_features::{progress, progress::Progress};
-use gix_transport::{client, client::SetServiceResponse, Service};
+use gix_transport::{client, Service};
 use maybe_async::maybe_async;
 
 use super::{Error, Outcome};
+#[cfg(feature = "async-client")]
+use crate::transport::client::async_io::{SetServiceResponse, Transport};
+#[cfg(feature = "blocking-client")]
+use crate::transport::client::blocking_io::{SetServiceResponse, Transport};
 use crate::{credentials, handshake::refs};
 
 /// Perform a handshake with the server on the other side of `transport`, with `authenticate` being used if authentication
@@ -20,7 +24,7 @@ pub async fn handshake<AuthFn, T>(
 ) -> Result<Outcome, Error>
 where
     AuthFn: FnMut(credentials::helper::Action) -> credentials::protocol::Result,
-    T: client::Transport,
+    T: Transport,
 {
     let _span = gix_features::trace::detail!("gix_protocol::handshake()", service = ?service, extra_parameters = ?extra_parameters);
     let (server_protocol_version, refs, capabilities) = {