[async-client] Try to bring 'Send' back but…

…it was clear early on that we cannot send readers tied to a lifetime
as all safe unblockers will require 'static.

It's not a real issue right now but certainly interesting to solve
cheaply, potentially diverging the protocol implementaitons for
blocking & async.

Alternatively there is no other options but to get Arc<Mutex<…>>

Author: Byron

git-packetline/src/read/sidebands/async_io.rs

@@ -160,7 +160,7 @@ pub struct ReadLineFuture<'a, 'b, T: AsyncRead, F> {
 
 impl<'a, 'b, T, F> Future for ReadLineFuture<'a, 'b, T, F>
 where
-    T: AsyncRead + Unpin,
+    T: AsyncRead + Unpin + Send,
     F: FnMut(bool, &[u8]) + Unpin,
 {
     type Output = std::io::Result<usize>;

git-packetline/src/write/async_io.rs

@@ -21,7 +21,7 @@ enum State {
     WriteData(usize),
 }
 
-impl<T: AsyncWrite + Unpin> Writer<T> {
+impl<T: AsyncWrite + Unpin + Send> Writer<T> {
     /// Create a new instance from the given `write`
     pub fn new(write: T) -> Self {
         Writer {
@@ -54,7 +54,7 @@ impl<T> Writer<T> {
     }
 }
 
-impl<T: AsyncWrite + Unpin> AsyncWrite for Writer<T> {
+impl<T: AsyncWrite + Unpin + Send> AsyncWrite for Writer<T> {
     fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
         let mut this = self.project();
         loop {

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

@@ -3,11 +3,11 @@ use futures_lite::io::AsyncWriteExt;
 use git_transport::{client, client::TransportV2Ext};
 
 impl Arguments {
-    pub(crate) async fn send<'a, T: client::Transport + 'a>(
+    pub(crate) async fn send<'a, T: client::Transport + 'a + Send>(
         &mut self,
         transport: &'a mut T,
         add_done_argument: bool,
-    ) -> Result<Box<dyn client::ExtendedBufRead + Unpin + 'a>, client::Error> {
+    ) -> Result<Box<dyn client::ExtendedBufRead + Unpin + 'a + Send>, client::Error> {
         if self.haves.is_empty() {
             assert!(add_done_argument, "If there are no haves, is_done must be true.");
         }

git-protocol/src/fetch/delegate.rs

@@ -127,7 +127,7 @@ mod async_io {
     /// Everything is tucked away behind type-safety so 'nothing can go wrong'©. Runtime assertions assure invalid
     /// features or arguments don't make it to the server in the first place.
     /// Please note that this trait mostly corresponds to what V2 would look like, even though V1 is supported as well.
-    #[async_trait(?Send)]
+    #[async_trait]
     pub trait Delegate: DelegateWithoutIO {
         /// Receive a pack provided from the given `input`.
         ///
@@ -137,7 +137,7 @@ mod async_io {
         /// to check additional acks.
         async fn receive_pack(
             &mut self,
-            input: impl AsyncBufRead + Unpin + 'async_trait,
+            input: impl AsyncBufRead + Unpin + 'async_trait + Send,
             progress: impl Progress,
             refs: &[Ref],
             previous: &Response,

git-protocol/src/fetch/function.rs

@@ -20,7 +20,7 @@ use std::io;
 /// _Note_ that depending on the `delegate`, the actual action performed can be `ls-refs`, `clone` or `fetch`.
 #[maybe_async]
 pub async fn fetch<F>(
-    mut transport: impl client::Transport,
+    mut transport: impl client::Transport + Send,
     delegate: &mut impl Delegate,
     mut authenticate: F,
     mut progress: impl Progress,
@@ -172,7 +172,7 @@ where
 
 fn setup_remote_progress(
     progress: &mut impl Progress,
-    reader: &mut Box<dyn git_transport::client::ExtendedBufRead + Unpin + '_>,
+    reader: &mut Box<dyn git_transport::client::ExtendedBufRead + Unpin + '_ + Send>,
 ) {
     reader.set_progress_handler(Some(Box::new({
         let mut remote_progress = progress.add_child("remote");

git-protocol/src/fetch/tests/arguments.rs

@@ -88,7 +88,7 @@ mod impls {
         }
     }
 
-    #[async_trait(?Send)]
+    #[async_trait]
     impl<T: client::Transport + Send> client::Transport for Transport<T> {
         async fn handshake(&mut self, service: Service) -> Result<SetServiceResponse<'_>, Error> {
             self.inner.handshake(service).await

git-protocol/tests/fetch/mod.rs

@@ -94,11 +94,11 @@ mod async_io {
     };
     use std::io;
 
-    #[async_trait(?Send)]
+    #[async_trait]
     impl fetch::Delegate for CloneDelegate {
         async fn receive_pack(
             &mut self,
-            mut input: impl AsyncBufRead + Unpin + 'async_trait,
+            mut input: impl AsyncBufRead + Unpin + 'async_trait + Send,
             _progress: impl Progress,
             _refs: &[Ref],
             _previous: &Response,
@@ -108,11 +108,11 @@ mod async_io {
         }
     }
 
-    #[async_trait(?Send)]
+    #[async_trait]
     impl fetch::Delegate for LsRemoteDelegate {
         async fn receive_pack(
             &mut self,
-            _input: impl AsyncBufRead + Unpin + 'async_trait,
+            _input: impl AsyncBufRead + Unpin + 'async_trait + Send,
             _progress: impl Progress,
             _refs: &[Ref],
             _previous: &Response,

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

@@ -12,12 +12,12 @@ use std::{
 /// A function `f(is_error, text)` receiving progress or error information.
 /// As it is not a future itself, it must not block. If IO is performed within the function, be sure to spawn
 /// it onto an executor.
-pub type HandleProgress = Box<dyn FnMut(bool, &[u8])>;
+pub type HandleProgress = Box<dyn FnMut(bool, &[u8]) + Send>;
 
 /// This trait exists to get a version of a `git_packetline::Provider` without type parameters.
 /// For the sake of usability, it also implements [`std::io::BufRead`] making it trivial to (eventually)
 /// read pack files while keeping the possibility to read individual lines with low overhead.
-#[async_trait(?Send)]
+#[async_trait]
 pub trait ExtendedBufRead: AsyncBufRead {
     /// Set the handler to which progress will be delivered.
     ///
@@ -33,8 +33,8 @@ pub trait ExtendedBufRead: AsyncBufRead {
     fn stopped_at(&self) -> Option<MessageKind>;
 }
 
-#[async_trait(?Send)]
-impl<'a, T: ExtendedBufRead + ?Sized + 'a + Unpin> ExtendedBufRead for Box<T> {
+#[async_trait]
+impl<'a, T: ExtendedBufRead + ?Sized + 'a + Unpin + Send> ExtendedBufRead for Box<T> {
     fn set_progress_handler(&mut self, handle_progress: Option<HandleProgress>) {
         self.deref_mut().set_progress_handler(handle_progress)
     }
@@ -52,8 +52,8 @@ impl<'a, T: ExtendedBufRead + ?Sized + 'a + Unpin> ExtendedBufRead for Box<T> {
     }
 }
 
-#[async_trait(?Send)]
-impl<'a, T: AsyncRead + Unpin> ExtendedBufRead for git_packetline::read::WithSidebands<'a, T, HandleProgress> {
+#[async_trait]
+impl<'a, T: AsyncRead + Unpin + Send> ExtendedBufRead for git_packetline::read::WithSidebands<'a, T, HandleProgress> {
     fn set_progress_handler(&mut self, handle_progress: Option<HandleProgress>) {
         self.set_progress_handler(handle_progress)
     }

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

@@ -14,8 +14,8 @@ pin_project! {
     pub struct RequestWriter<'a> {
         on_into_read: MessageKind,
         #[pin]
-        pub(crate) writer: git_packetline::Writer<Box<dyn AsyncWrite + Unpin + 'a>>,
-        pub(crate) reader: Box<dyn ExtendedBufRead + Unpin + 'a>,
+        pub(crate) writer: git_packetline::Writer<Box<dyn AsyncWrite + Unpin + 'a + Send>>,
+        pub(crate) reader: Box<dyn ExtendedBufRead + Unpin + 'a + Send>,
     }
 }
 impl<'a> futures_io::AsyncWrite for RequestWriter<'a> {
@@ -37,13 +37,13 @@ impl<'a> RequestWriter<'a> {
     /// Create a new instance from a `writer` (commonly a socket), a `reader` into which to transform once the
     /// writes are finished, along with configuration for the `write_mode` and information about which message to write
     /// when this instance is converted into a `reader` to read the request's response.
-    pub fn new_from_bufread<W: AsyncWrite + Unpin + 'a>(
+    pub fn new_from_bufread<W: AsyncWrite + Unpin + 'a + Send>(
         writer: W,
-        reader: Box<dyn ExtendedBufRead + Unpin + 'a>,
+        reader: Box<dyn ExtendedBufRead + Unpin + 'a + Send>,
         write_mode: WriteMode,
         on_into_read: MessageKind,
     ) -> Self {
-        let mut writer = git_packetline::Writer::new(Box::new(writer) as Box<dyn AsyncWrite + Unpin>);
+        let mut writer = git_packetline::Writer::new(Box::new(writer) as Box<dyn AsyncWrite + Unpin + Send>);
         match write_mode {
             WriteMode::Binary => writer.enable_binary_mode(),
             WriteMode::OneLfTerminatedLinePerWriteCall => writer.enable_text_mode(),
@@ -82,7 +82,7 @@ impl<'a> RequestWriter<'a> {
         .map(|_| ())
     }
     /// Discard the ability to write and turn this instance into the reader for obtaining the other side's response.
-    pub async fn into_read(mut self) -> std::io::Result<Box<dyn ExtendedBufRead + Unpin + 'a>> {
+    pub async fn into_read(mut self) -> std::io::Result<Box<dyn ExtendedBufRead + Unpin + 'a + Send>> {
         self.write_message(self.on_into_read).await?;
         Ok(self.reader)
     }

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

@@ -22,7 +22,7 @@ pub struct SetServiceResponse<'a> {
 /// It does, however, know just enough to be able to provide a higher-level interface than would otherwise be possible.
 /// Thus the consumer of this trait will not have to deal with packet lines at all.
 /// **Note that**  whenever a `Read` trait or `Write` trait is produced, it must be exhausted.
-#[async_trait(?Send)]
+#[async_trait]
 pub trait Transport: TransportWithoutIO {
     /// Initiate connection to the given service.
     /// Returns the service capabilities according according to the actual [Protocol] it supports,
@@ -37,8 +37,8 @@ pub trait Transport: TransportWithoutIO {
 }
 
 // Would be nice if the box implementation could auto-forward to all implemented traits.
-#[async_trait(?Send)]
-impl<T: Transport + ?Sized> Transport for Box<T> {
+#[async_trait]
+impl<T: Transport + ?Sized + Send> Transport for Box<T> {
     async fn handshake(&mut self, service: Service) -> Result<SetServiceResponse<'_>, Error> {
         self.deref_mut().handshake(service).await
     }
@@ -49,27 +49,27 @@ impl<T: Transport + ?Sized> Transport for Box<T> {
 }
 
 /// An extension trait to add more methods to everything implementing [`Transport`].
-#[async_trait(?Send)]
+#[async_trait]
 pub trait TransportV2Ext {
     /// Invoke a protocol V2 style `command` with given `capabilities` and optional command specific `arguments`.
     /// The `capabilities` were communicated during the handshake.
     /// _Note:_ panics if [handshake][Transport::handshake()] wasn't performed beforehand.
     async fn invoke<'a>(
         &mut self,
         command: &str,
-        capabilities: impl Iterator<Item = (&'a str, Option<&'a str>)> + 'a,
-        arguments: Option<impl Iterator<Item = bstr::BString> + 'a>,
-    ) -> Result<Box<dyn ExtendedBufRead + Unpin + '_>, Error>;
+        capabilities: impl Iterator<Item = (&'a str, Option<&'a str>)> + 'a + Send,
+        arguments: Option<impl Iterator<Item = bstr::BString> + 'a + Send>,
+    ) -> Result<Box<dyn ExtendedBufRead + Unpin + '_ + Send>, Error>;
 }
 
-#[async_trait(?Send)]
-impl<T: Transport> TransportV2Ext for T {
+#[async_trait]
+impl<T: Transport + Send> TransportV2Ext for T {
     async fn invoke<'a>(
         &mut self,
         command: &str,
-        capabilities: impl Iterator<Item = (&'a str, Option<&'a str>)> + 'a,
-        arguments: Option<impl Iterator<Item = BString> + 'a>,
-    ) -> Result<Box<dyn ExtendedBufRead + Unpin + '_>, Error> {
+        capabilities: impl Iterator<Item = (&'a str, Option<&'a str>)> + 'a + Send,
+        arguments: Option<impl Iterator<Item = BString> + 'a + Send>,
+    ) -> Result<Box<dyn ExtendedBufRead + Unpin + '_ + Send>, Error> {
         let mut writer = self.request(WriteMode::OneLfTerminatedLinePerWriteCall, MessageKind::Flush)?;
         writer.write_all(format!("command={}", command).as_bytes()).await?;
         for (name, value) in capabilities {