refactor!: split async and blocking implementations for Handshake::fetch_or_extract_refmap()

Author: djc

gitoxide-core/src/pack/receive.rs

@@ -87,11 +87,17 @@ where
         fetch_refspecs: fetch_refspecs.clone(),
         extra_refspecs: vec![],
     };
-    let refmap = handshake
-        .fetch_or_extract_refmap(user_agent.clone(), true, context)?
-        .fetch(&mut progress, &mut transport.inner, trace_packetlines)
+
+    let fetch_refmap = handshake.fetch_or_extract_refmap(user_agent.clone(), true, context)?;
+
+    #[cfg(feature = "async-client")]
+    let refmap = fetch_refmap
+        .fetch_async(&mut progress, &mut transport.inner, trace_packetlines)
         .await?;
 
+    #[cfg(feature = "blocking-client")]
+    let refmap = fetch_refmap.fetch_blocking(&mut progress, &mut transport.inner, trace_packetlines)?;
+
     if refmap.mappings.is_empty() && !refmap.remote_refs.is_empty() {
         return Err(Error::NoMapping {
             refspecs: refmap.refspecs.clone(),

gix-protocol/src/handshake/mod.rs

@@ -72,9 +72,9 @@ pub(crate) mod hero {
     #[cfg(feature = "fetch")]
     mod fetch {
         #[cfg(feature = "async-client")]
-        use crate::transport::client::async_io::Transport;
+        use crate::transport::client::async_io;
         #[cfg(feature = "blocking-client")]
-        use crate::transport::client::blocking_io::Transport;
+        use crate::transport::client::blocking_io;
         use crate::{fetch::RefMap, Handshake};
         use gix_features::progress::Progress;
         use std::borrow::Cow;
@@ -89,12 +89,12 @@ pub(crate) mod hero {
 
         impl FetchRefMap<'_> {
             /// Fetch the refmap, either by returning the existing one or invoking the command.
+            #[cfg(feature = "async-client")]
             #[allow(clippy::result_large_err)]
-            #[maybe_async::maybe_async]
-            pub async fn fetch(
+            pub async fn fetch_async(
                 self,
                 mut progress: impl Progress,
-                transport: &mut impl Transport,
+                transport: &mut impl async_io::Transport,
                 trace_packetlines: bool,
             ) -> Result<crate::fetch::RefMap, crate::fetch::refmap::init::Error> {
                 let (cmd, cx) = match self {
@@ -103,7 +103,26 @@ pub(crate) mod hero {
                 };
 
                 let capabilities = cmd.capabilities;
-                let remote_refs = cmd.invoke(transport, &mut progress, trace_packetlines).await?;
+                let remote_refs = cmd.invoke_async(transport, &mut progress, trace_packetlines).await?;
+                RefMap::from_refs(remote_refs, capabilities, cx)
+            }
+
+            /// Fetch the refmap, either by returning the existing one or invoking the command.
+            #[cfg(feature = "blocking-client")]
+            #[allow(clippy::result_large_err)]
+            pub fn fetch_blocking(
+                self,
+                mut progress: impl Progress,
+                transport: &mut impl blocking_io::Transport,
+                trace_packetlines: bool,
+            ) -> Result<crate::fetch::RefMap, crate::fetch::refmap::init::Error> {
+                let (cmd, cx) = match self {
+                    FetchRefMap::Map(map) => return Ok(map),
+                    FetchRefMap::Command(cmd, cx) => (cmd, cx),
+                };
+
+                let capabilities = cmd.capabilities;
+                let remote_refs = cmd.invoke_blocking(transport, &mut progress, trace_packetlines)?;
                 RefMap::from_refs(remote_refs, capabilities, cx)
             }
         }

gix-protocol/src/ls_refs.rs

@@ -36,13 +36,12 @@ pub(crate) mod function {
     use bstr::{BString, ByteVec};
     use gix_features::progress::Progress;
     use gix_transport::client::Capabilities;
-    use maybe_async::maybe_async;
 
     use super::Error;
     #[cfg(feature = "async-client")]
-    use crate::transport::client::async_io::{Transport, TransportV2Ext};
+    use crate::transport::client::async_io::{self, TransportV2Ext as _};
     #[cfg(feature = "blocking-client")]
-    use crate::transport::client::blocking_io::{Transport, TransportV2Ext};
+    use crate::transport::client::blocking_io::{self, TransportV2Ext as _};
     use crate::{
         handshake::{refs::from_v2_refs, Ref},
         Command,
@@ -103,10 +102,10 @@ pub(crate) mod function {
         ///
         /// `progress` is used to provide feedback.
         /// If `trace` is `true`, all packetlines received or sent will be passed to the facilities of the `gix-trace` crate.
-        #[maybe_async]
-        pub async fn invoke(
+        #[cfg(feature = "async-client")]
+        pub async fn invoke_async(
             self,
-            mut transport: impl Transport,
+            mut transport: impl async_io::Transport,
             progress: &mut impl Progress,
             trace: bool,
         ) -> Result<Vec<Ref>, Error> {
@@ -133,5 +132,38 @@ pub(crate) mod function {
                 .await?;
             Ok(from_v2_refs(&mut remote_refs).await?)
         }
+
+        /// Invoke a ls-refs V2 command on `transport`.
+        ///
+        /// `progress` is used to provide feedback.
+        /// If `trace` is `true`, all packetlines received or sent will be passed to the facilities of the `gix-trace` crate.
+        #[cfg(feature = "blocking-client")]
+        pub fn invoke_blocking(
+            self,
+            mut transport: impl blocking_io::Transport,
+            progress: &mut impl Progress,
+            trace: bool,
+        ) -> Result<Vec<Ref>, Error> {
+            Command::LsRefs.validate_argument_prefixes(
+                gix_transport::Protocol::V2,
+                self.capabilities,
+                &self.arguments,
+                &self.features,
+            )?;
+
+            progress.step();
+            progress.set_name("list refs".into());
+            let mut remote_refs = transport.invoke(
+                Command::LsRefs.as_str(),
+                self.features.into_iter(),
+                if self.arguments.is_empty() {
+                    None
+                } else {
+                    Some(self.arguments.into_iter())
+                },
+                trace,
+            )?;
+            Ok(from_v2_refs(&mut remote_refs)?)
+        }
     }
 }

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

@@ -106,9 +106,17 @@ mod fetch_fn {
             None => match delegate.action() {
                 Ok(RefsAction::Skip) => Vec::new(),
                 Ok(RefsAction::Continue) => {
-                    LsRefsCommand::new(None, &capabilities, ("agent", Some(Cow::Owned(agent.clone()))))
-                        .invoke(&mut transport, &mut progress, trace)
-                        .await?
+                    #[cfg(feature = "async-client")]
+                    {
+                        LsRefsCommand::new(None, &capabilities, ("agent", Some(Cow::Owned(agent.clone()))))
+                            .invoke_async(&mut transport, &mut progress, trace)
+                            .await?
+                    }
+                    #[cfg(feature = "blocking-client")]
+                    {
+                        LsRefsCommand::new(None, &capabilities, ("agent", Some(Cow::Owned(agent.clone()))))
+                            .invoke_blocking(&mut transport, &mut progress, trace)?
+                    }
                 }
                 Err(err) => {
                     indicate_end_of_interaction(transport, trace).await?;

gix/src/remote/connection/ref_map.rs

@@ -157,15 +157,20 @@ where
             extra_refspecs,
         };
 
-        let ref_map = handshake
-            .fetch_or_extract_refmap(
-                self.remote.repo.config.user_agent_tuple(),
-                prefix_from_spec_as_filter_on_remote,
-                context,
-            )?
-            .fetch(progress, &mut self.transport.inner, self.trace)
+        let fetch_refmap = handshake.fetch_or_extract_refmap(
+            self.remote.repo.config.user_agent_tuple(),
+            prefix_from_spec_as_filter_on_remote,
+            context,
+        )?;
+
+        #[cfg(feature = "async-network-client")]
+        let ref_map = fetch_refmap
+            .fetch_async(progress, &mut self.transport.inner, self.trace)
             .await?;
 
+        #[cfg(feature = "blocking-network-client")]
+        let ref_map = fetch_refmap.fetch_blocking(progress, &mut self.transport.inner, self.trace)?;
+
         self.handshake = Some(handshake);
         Ok(ref_map)
     }