feat!: make it possible to trace incoming and outgoing packetlines.

Due to the way this is (and has to be) setup, unfortunately one
has to integrate that with two crates, instead of just one.

This changes touches multiple crates, most of which receive a single
boolean as last argument to indicate whether the tracing should
happen in the first place.

Author: Byron

Cargo.lock

@@ -116,6 +116,7 @@ impl<W> protocol::fetch::DelegateBlocking for CloneDelegate<W> {
 mod blocking_io {
     use std::{io, io::BufRead, path::PathBuf};
 
+    use gix::config::tree::Key;
     use gix::{
         bstr::BString,
         protocol,
@@ -180,6 +181,12 @@ mod blocking_io {
             progress,
             protocol::FetchConnection::TerminateOnSuccessfulCompletion,
             gix::env::agent(),
+            std::env::var_os(
+                gix::config::tree::Gitoxide::TRACE_PACKET
+                    .environment_override()
+                    .expect("set"),
+            )
+            .is_some(),
         )?;
         Ok(())
     }
@@ -196,6 +203,7 @@ mod async_io {
 
     use async_trait::async_trait;
     use futures_io::AsyncBufRead;
+    use gix::config::tree::Key;
     use gix::{
         bstr::{BString, ByteSlice},
         odb::pack,
@@ -264,6 +272,12 @@ mod async_io {
                 progress,
                 protocol::FetchConnection::TerminateOnSuccessfulCompletion,
                 gix::env::agent(),
+                std::env::var_os(
+                    gix::config::tree::Gitoxide::TRACE_PACKET
+                        .environment_override()
+                        .expect("set"),
+                )
+                .is_some(),
             ))
         })
         .await?;

gitoxide-core/src/pack/receive.rs

@@ -76,6 +76,7 @@ impl Client {
         let mut input = gix_packetline::StreamingPeekableIter::new(
             process.stdout.take().expect("configured stdout when spawning"),
             &[gix_packetline::PacketLineRef::Flush],
+            false, /* packet tracing */
         );
         let mut read = input.as_read();
         let mut buf = String::new();

gix-filter/src/driver/process/client.rs

@@ -63,8 +63,11 @@ impl Server {
         pick_version: &mut dyn FnMut(&[usize]) -> Option<usize>,
         available_capabilities: &[&str],
     ) -> Result<Self, handshake::Error> {
-        let mut input =
-            gix_packetline::StreamingPeekableIter::new(stdin.lock(), &[gix_packetline::PacketLineRef::Flush]);
+        let mut input = gix_packetline::StreamingPeekableIter::new(
+            stdin.lock(),
+            &[gix_packetline::PacketLineRef::Flush],
+            false, /* packet tracing */
+        );
         let mut read = input.as_read();
         let mut buf = String::new();
         read.read_line_to_string(&mut buf)?;

gix-filter/src/driver/process/server.rs

@@ -24,6 +24,8 @@ blocking-io = []
 serde = ["dep:serde", "bstr/serde"]
 
 [dependencies]
+gix-trace = { version = "^0.1.3", path = "../gix-trace" }
+
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"]}
 thiserror = "1.0.34"
 faster-hex = "0.8.0"

gix-packetline-blocking/Cargo.toml

@@ -39,6 +39,8 @@ path = "tests/blocking-packetline.rs"
 required-features = ["blocking-io", "maybe-async/is_sync"]
 
 [dependencies]
+gix-trace = { version = "^0.1.3", path = "../gix-trace" }
+
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"]}
 thiserror = "1.0.34"
 faster-hex = "0.8.0"

gix-packetline/Cargo.toml

@@ -91,6 +91,8 @@ pub struct StreamingPeekableIter<T> {
     delimiters: &'static [PacketLineRef<'static>],
     is_done: bool,
     stopped_at: Option<PacketLineRef<'static>>,
+    #[cfg_attr(all(not(feature = "async-io"), not(feature = "blocking-io")), allow(dead_code))]
+    trace: bool,
 }
 
 /// Utilities to help decoding packet lines

gix-packetline/src/lib.rs

@@ -44,12 +44,30 @@ where
         delimiters: &[PacketLineRef<'static>],
         fail_on_err_lines: bool,
         buf_resize: bool,
+        trace: bool,
     ) -> ExhaustiveOutcome<'a> {
         (
             false,
             None,
             Some(match Self::read_line_inner(reader, buf).await {
                 Ok(Ok(line)) => {
+                    if trace {
+                        match line {
+                            #[allow(unused_variables)]
+                            PacketLineRef::Data(d) => {
+                                gix_trace::trace!("<< {}", d.as_bstr().trim().as_bstr());
+                            }
+                            PacketLineRef::Flush => {
+                                gix_trace::trace!("<< FLUSH");
+                            }
+                            PacketLineRef::Delimiter => {
+                                gix_trace::trace!("<< DELIM");
+                            }
+                            PacketLineRef::ResponseEnd => {
+                                gix_trace::trace!("<< RESPONSE_END");
+                            }
+                        }
+                    }
                     if delimiters.contains(&line) {
                         let stopped_at = delimiters.iter().find(|l| **l == line).copied();
                         buf.clear();
@@ -111,6 +129,7 @@ where
                 self.delimiters,
                 self.fail_on_err_lines,
                 false,
+                self.trace,
             )
             .await;
             self.is_done = is_done;
@@ -134,6 +153,7 @@ where
                 self.delimiters,
                 self.fail_on_err_lines,
                 true,
+                self.trace,
             )
             .await;
             self.is_done = is_done;

gix-packetline/src/read/async_io.rs

@@ -38,12 +38,30 @@ where
         delimiters: &[PacketLineRef<'static>],
         fail_on_err_lines: bool,
         buf_resize: bool,
+        trace: bool,
     ) -> ExhaustiveOutcome<'a> {
         (
             false,
             None,
             Some(match Self::read_line_inner(reader, buf) {
                 Ok(Ok(line)) => {
+                    if trace {
+                        match line {
+                            #[allow(unused_variables)]
+                            PacketLineRef::Data(d) => {
+                                gix_trace::trace!("<< {}", d.as_bstr().trim().as_bstr());
+                            }
+                            PacketLineRef::Flush => {
+                                gix_trace::trace!("<< FLUSH");
+                            }
+                            PacketLineRef::Delimiter => {
+                                gix_trace::trace!("<< DELIM");
+                            }
+                            PacketLineRef::ResponseEnd => {
+                                gix_trace::trace!("<< RESPONSE_END");
+                            }
+                        }
+                    }
                     if delimiters.contains(&line) {
                         let stopped_at = delimiters.iter().find(|l| **l == line).copied();
                         buf.clear();
@@ -66,6 +84,7 @@ where
                     if buf_resize {
                         buf.resize(len, 0);
                     }
+                    // TODO(borrowchk): remove additional decoding of internal buffer which is needed only to make it past borrowchk
                     Ok(Ok(crate::decode(buf).expect("only valid data here")))
                 }
                 Ok(Err(err)) => {
@@ -105,6 +124,7 @@ where
                 self.delimiters,
                 self.fail_on_err_lines,
                 false,
+                self.trace,
             );
             self.is_done = is_done;
             self.stopped_at = stopped_at;
@@ -127,6 +147,7 @@ where
                 self.delimiters,
                 self.fail_on_err_lines,
                 true,
+                self.trace,
             );
             self.is_done = is_done;
             self.stopped_at = stopped_at;

gix-packetline/src/read/blocking_io.rs

@@ -43,7 +43,8 @@ pub use error::Error;
 
 impl<T> StreamingPeekableIter<T> {
     /// Return a new instance from `read` which will stop decoding packet lines when receiving one of the given `delimiters`.
-    pub fn new(read: T, delimiters: &'static [PacketLineRef<'static>]) -> Self {
+    /// If `trace` is `true`, all packetlines received or sent will be passed to the facilities of the `gix-trace` crate.
+    pub fn new(read: T, delimiters: &'static [PacketLineRef<'static>], trace: bool) -> Self {
         StreamingPeekableIter {
             read,
             #[cfg(any(feature = "blocking-io", feature = "async-io"))]
@@ -53,6 +54,7 @@ impl<T> StreamingPeekableIter<T> {
             fail_on_err_lines: false,
             is_done: false,
             stopped_at: None,
+            trace,
         }
     }