fix: support keepalive packets. (#450)

Keepalive packets are side-band only empty datalines that should
just be ignored. This is now happening, allowing longer git
operations to work as they will send keepalive packets every 5 seconds,
and previously we would choke on it.

Note that empty datalines are never send otherwise, making it a
previously unused marker that can safely be skipped.

Author: Byron

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

@@ -238,7 +238,12 @@ where
                                         .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
                                     const ENCODED_BAND: usize = 1;
                                     match band {
-                                        BandRef::Data(d) => break (U16_HEX_BYTES + ENCODED_BAND, d.len()),
+                                        BandRef::Data(d) => {
+                                            if d.is_empty() {
+                                                continue;
+                                            }
+                                            break (U16_HEX_BYTES + ENCODED_BAND, d.len());
+                                        }
                                         BandRef::Progress(d) => {
                                             let text = TextRef::from(d).0;
                                             handle_progress(false, text);

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

@@ -113,7 +113,12 @@ where
                             .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
                         const ENCODED_BAND: usize = 1;
                         match band {
-                            BandRef::Data(d) => break (U16_HEX_BYTES + ENCODED_BAND, d.len()),
+                            BandRef::Data(d) => {
+                                if d.is_empty() {
+                                    continue;
+                                }
+                                break (U16_HEX_BYTES + ENCODED_BAND, d.len());
+                            }
                             BandRef::Progress(d) => {
                                 let text = TextRef::from(d).0;
                                 handle_progress(false, text);

git-protocol/tests/fetch/response.rs

@@ -124,14 +124,21 @@ mod v2 {
 
         #[maybe_async::test(feature = "blocking-client", async(feature = "async-client", async_std::test))]
         async fn clone() -> crate::Result {
-            let mut provider = mock_reader("v2/clone-only.response");
-            let mut reader = provider.as_read_without_sidebands();
-            let r = fetch::Response::from_line_reader(Protocol::V2, &mut reader).await?;
-            assert!(r.acknowledgements().is_empty(), "it should go straight to the packfile");
-            assert!(r.has_pack());
-            let mut buf = Vec::new();
-            let bytes_read = reader.read_to_end(&mut buf).await?;
-            assert_eq!(bytes_read, 1089, "should be able to read the whole pack");
+            for keepalive in [false, true] {
+                let fixture = format!(
+                    "v2/clone-only{}.response",
+                    keepalive.then(|| "-with-keepalive").unwrap_or_default()
+                );
+                let mut provider = mock_reader(&fixture);
+                let mut reader = provider.as_read_without_sidebands();
+                let r = fetch::Response::from_line_reader(Protocol::V2, &mut reader).await?;
+                assert!(r.acknowledgements().is_empty(), "it should go straight to the packfile");
+                assert!(r.has_pack());
+                reader.set_progress_handler(Some(Box::new(|_is_err, _text| ())));
+                let mut buf = Vec::new();
+                let bytes_read = reader.read_to_end(&mut buf).await?;
+                assert_eq!(bytes_read, 876, "should be able to read the whole pack");
+            }
             Ok(())
         }
 

git-protocol/tests/fetch/v1.rs

@@ -7,22 +7,28 @@ use crate::fetch::{helper_unused, oid, transport, CloneDelegate, LsRemoteDelegat
 
 #[maybe_async::test(feature = "blocking-client", async(feature = "async-client", async_std::test))]
 async fn clone() -> crate::Result {
-    let out = Vec::new();
-    let mut dlg = CloneDelegate::default();
-    git_protocol::fetch(
-        transport(
-            out,
-            "v1/clone.response",
-            Protocol::V1,
-            git_transport::client::git::ConnectMode::Daemon,
-        ),
-        &mut dlg,
-        helper_unused,
-        progress::Discard,
-        FetchConnection::TerminateOnSuccessfulCompletion,
-    )
-    .await?;
-    assert_eq!(dlg.pack_bytes, 876, "It be able to read pack bytes");
+    for with_keepalive in [false, true] {
+        let out = Vec::new();
+        let mut dlg = CloneDelegate::default();
+        let fixture = format!(
+            "v1/clone{}.response",
+            with_keepalive.then(|| "-with-keepalive").unwrap_or_default()
+        );
+        git_protocol::fetch(
+            transport(
+                out,
+                &fixture,
+                Protocol::V1,
+                git_transport::client::git::ConnectMode::Daemon,
+            ),
+            &mut dlg,
+            helper_unused,
+            progress::Discard,
+            FetchConnection::TerminateOnSuccessfulCompletion,
+        )
+        .await?;
+        assert_eq!(dlg.pack_bytes, 876, "{}: It be able to read pack bytes", fixture);
+    }
     Ok(())
 }