[protocol] suppot for V2 special lines

Author: Byron

git-protocol/src/packet_line/decode.rs

@@ -1,4 +1,6 @@
-use crate::packet_line::{self, ERR_PREFIX, FLUSH_LINE, MAX_DATA_LEN, MAX_LINE_LEN, U16_HEX_BYTES};
+use crate::packet_line::{
+    self, DELIMITER_LINE, ERR_PREFIX, FLUSH_LINE, MAX_DATA_LEN, MAX_LINE_LEN, RESPONSE_END_LINE, U16_HEX_BYTES,
+};
 use bstr::BString;
 use quick_error::quick_error;
 
@@ -48,6 +50,18 @@ pub fn streaming(data: &[u8]) -> Result<Stream, Error> {
             bytes_consumed: 4,
         });
     }
+    if hex_bytes == DELIMITER_LINE {
+        return Ok(Stream::Complete {
+            line: packet_line::Borrowed::Delimiter,
+            bytes_consumed: 4,
+        });
+    }
+    if hex_bytes == RESPONSE_END_LINE {
+        return Ok(Stream::Complete {
+            line: packet_line::Borrowed::ResponseEnd,
+            bytes_consumed: 4,
+        });
+    }
 
     let mut buf = [0u8; U16_HEX_BYTES / 2];
     hex::decode_to_slice(hex_bytes, &mut buf)?;

git-protocol/src/packet_line/encode.rs

@@ -1,4 +1,4 @@
-use crate::packet_line::{ERR_PREFIX, FLUSH_LINE, MAX_DATA_LEN};
+use crate::packet_line::{DELIMITER_LINE, ERR_PREFIX, FLUSH_LINE, MAX_DATA_LEN, RESPONSE_END_LINE};
 use quick_error::quick_error;
 use std::io;
 
@@ -19,6 +19,14 @@ quick_error! {
     }
 }
 
+pub fn response_end_to_write(mut out: impl io::Write) -> io::Result<usize> {
+    out.write_all(RESPONSE_END_LINE).map(|_| 4)
+}
+
+pub fn delim_to_write(mut out: impl io::Write) -> io::Result<usize> {
+    out.write_all(DELIMITER_LINE).map(|_| 4)
+}
+
 pub fn flush_to_write(mut out: impl io::Write) -> io::Result<usize> {
     out.write_all(FLUSH_LINE).map(|_| 4)
 }

git-protocol/src/packet_line/mod.rs

@@ -5,27 +5,33 @@ pub(crate) const U16_HEX_BYTES: usize = 4;
 pub(crate) const MAX_DATA_LEN: usize = 65516;
 pub(crate) const MAX_LINE_LEN: usize = MAX_DATA_LEN + U16_HEX_BYTES;
 pub(crate) const FLUSH_LINE: &[u8] = b"0000";
+pub(crate) const DELIMITER_LINE: &[u8] = b"0001";
+pub(crate) const RESPONSE_END_LINE: &[u8] = b"0002";
 pub(crate) const ERR_PREFIX: &[u8] = b"ERR ";
 
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub enum Borrowed<'a> {
     Data(&'a [u8]),
     Flush,
+    Delimiter,
+    ResponseEnd,
 }
 
 impl<'a> Borrowed<'a> {
     pub fn to_write(&self, out: impl io::Write) -> Result<usize, encode::Error> {
         match self {
-            Borrowed::Flush => encode::flush_to_write(out).map_err(Into::into),
             Borrowed::Data(d) => encode::data_to_write(d, out),
+            Borrowed::Flush => encode::flush_to_write(out).map_err(Into::into),
+            Borrowed::Delimiter => encode::delim_to_write(out).map_err(Into::into),
+            Borrowed::ResponseEnd => encode::response_end_to_write(out).map_err(Into::into),
         }
     }
 
     pub fn as_slice(&self) -> &[u8] {
         match self {
             Borrowed::Data(d) => d,
-            Borrowed::Flush => &[],
+            Borrowed::Flush | Borrowed::Delimiter | Borrowed::ResponseEnd => &[],
         }
     }
     pub fn as_bstr(&self) -> &BStr {

git-protocol/tests/packet_line/decode.rs

@@ -66,7 +66,12 @@ mod streaming {
 
     #[test]
     fn round_trips() -> crate::Result {
-        for (line, bytes) in &[(PacketLine::Flush, 4), (PacketLine::Data(b"hello there"), 15)] {
+        for (line, bytes) in &[
+            (PacketLine::ResponseEnd, 4),
+            (PacketLine::Delimiter, 4),
+            (PacketLine::Flush, 4),
+            (PacketLine::Data(b"hello there"), 15),
+        ] {
             let mut out = Vec::new();
             line.to_write(&mut out)?;
             assert_complete(streaming(&out), *bytes, *line)?;

git-protocol/tests/packet_line/encode.rs

@@ -1,7 +1,9 @@
 mod data_to_write {
     use crate::packet_line::assert_err_display;
     use bstr::ByteSlice;
-    use git_protocol::packet_line::encode::{data_to_write, error_to_write, flush_to_write};
+    use git_protocol::packet_line::encode::{
+        data_to_write, delim_to_write, error_to_write, flush_to_write, response_end_to_write,
+    };
     use std::io;
 
     fn vec_sized(size: usize) -> Vec<u8> {
@@ -23,10 +25,18 @@ mod data_to_write {
     }
 
     #[test]
-    fn success_flush() -> crate::Result {
+    fn success_flush_delim_response_end() -> crate::Result {
         let mut out = Vec::new();
         assert_eq!(flush_to_write(&mut out)?, 4);
         assert_eq!(out.as_bstr(), b"0000".as_bstr());
+
+        out.clear();
+        assert_eq!(delim_to_write(&mut out)?, 4);
+        assert_eq!(out.as_bstr(), b"0001".as_bstr());
+
+        out.clear();
+        assert_eq!(response_end_to_write(&mut out)?, 4);
+        assert_eq!(out.as_bstr(), b"0002".as_bstr());
         Ok(())
     }