feature: use winnow to parse resp protocol

Author: tyrchen

Cargo.lock

@@ -18,3 +18,4 @@ tokio-stream = "0.1.15"
 tokio-util = { version = "0.7.10", features = ["codec"] }
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+winnow = { version = "0.6.8", features = ["simd"] }

Cargo.toml

@@ -1,8 +1,10 @@
 mod backend;
 mod resp;
+mod respv2;
 
 pub mod cmd;
 pub mod network;
 
 pub use backend::*;
 pub use resp::*;
+pub use respv2::*;

src/lib.rs

@@ -1,6 +1,6 @@
 use crate::{
     cmd::{Command, CommandExecutor},
-    Backend, RespDecode, RespEncode, RespError, RespFrame,
+    Backend, RespDecodeV2, RespEncode, RespError, RespFrame,
 };
 use anyhow::Result;
 use futures::SinkExt;

src/network.rs

@@ -86,6 +86,12 @@ impl Deref for RespArray {
     }
 }
 
+impl From<Vec<RespFrame>> for RespArray {
+    fn from(s: Vec<RespFrame>) -> Self {
+        RespArray(s)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/resp/array.rs

@@ -80,6 +80,12 @@ impl DerefMut for RespMap {
     }
 }
 
+impl From<BTreeMap<String, RespFrame>> for RespMap {
+    fn from(map: BTreeMap<String, RespFrame>) -> Self {
+        RespMap(map)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/resp/map.rs

@@ -0,0 +1,163 @@
+mod parser;
+
+use self::parser::parse_frame_length;
+use crate::{RespError, RespFrame};
+use bytes::BytesMut;
+use parser::parse_frame;
+
+pub trait RespDecodeV2: Sized {
+    fn decode(buf: &mut BytesMut) -> Result<Self, RespError>;
+    fn expect_length(buf: &[u8]) -> Result<usize, RespError>;
+}
+
+impl RespDecodeV2 for RespFrame {
+    fn decode(buf: &mut BytesMut) -> Result<Self, RespError> {
+        let len = Self::expect_length(buf)?;
+        let data = buf.split_to(len);
+
+        parse_frame(&mut data.as_ref()).map_err(|e| RespError::InvalidFrame(e.to_string()))
+    }
+
+    fn expect_length(buf: &[u8]) -> Result<usize, RespError> {
+        parse_frame_length(buf)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{RespNullArray, RespNullBulkString};
+    use std::collections::BTreeMap;
+
+    #[test]
+    fn respv2_simple_string_length_should_work() {
+        let buf = b"+OK\r\n";
+        let len = RespFrame::expect_length(buf).unwrap();
+        assert_eq!(len, buf.len());
+    }
+
+    #[test]
+    fn respv2_simple_string_bad_length_should_fail() {
+        let buf = b"+OK\r";
+        let err = RespFrame::expect_length(buf).unwrap_err();
+        assert_eq!(err, RespError::NotComplete);
+    }
+
+    #[test]
+    fn respv2_simple_string_should_work() {
+        let mut buf = BytesMut::from("+OK\r\n");
+        let frame = RespFrame::decode(&mut buf).unwrap();
+        assert_eq!(frame, RespFrame::SimpleString("OK".into()));
+    }
+
+    #[test]
+    fn respv2_simple_error_length_should_work() {
+        let buf = b"-ERR\r\n";
+        let len = RespFrame::expect_length(buf).unwrap();
+        assert_eq!(len, buf.len());
+    }
+
+    #[test]
+    fn respv2_simple_error_should_work() {
+        let mut buf = BytesMut::from("-ERR\r\n");
+        let frame = RespFrame::decode(&mut buf).unwrap();
+        assert_eq!(frame, RespFrame::Error("ERR".into()));
+    }
+
+    #[test]
+    fn respv2_integer_length_should_work() {
+        let buf = b":1000\r\n";
+        let len = RespFrame::expect_length(buf).unwrap();
+        assert_eq!(len, buf.len());
+    }
+
+    #[test]
+    fn respv2_integer_should_work() {
+        let mut buf = BytesMut::from(":1000\r\n");
+        let frame = RespFrame::decode(&mut buf).unwrap();
+        assert_eq!(frame, RespFrame::Integer(1000));
+    }
+
+    #[test]
+    fn respv2_bulk_string_length_should_work() {
+        let buf = b"$6\r\nfoobar\r\n";
+        let len = RespFrame::expect_length(buf).unwrap();
+        assert_eq!(len, buf.len());
+    }
+
+    #[test]
+    fn respv2_bulk_string_should_work() {
+        let mut buf = BytesMut::from("$6\r\nfoobar\r\n");
+        let frame = RespFrame::decode(&mut buf).unwrap();
+        assert_eq!(frame, RespFrame::BulkString("foobar".into()));
+    }
+
+    #[test]
+    fn respv2_null_bulk_string_length_should_work() {
+        let buf = b"$-1\r\n";
+        let len = RespFrame::expect_length(buf).unwrap();
+        assert_eq!(len, buf.len());
+    }
+
+    #[test]
+    fn respv2_null_bulk_string_should_work() {
+        let mut buf = BytesMut::from("$-1\r\n");
+        let frame = RespFrame::decode(&mut buf).unwrap();
+        assert_eq!(frame, RespFrame::NullBulkString(RespNullBulkString));
+    }
+
+    #[test]
+    fn respv2_array_length_should_work() {
+        let buf = b"*2\r\n+OK\r\n-ERR\r\n";
+        let len = RespFrame::expect_length(buf).unwrap();
+        assert_eq!(len, buf.len());
+    }
+
+    #[test]
+    fn respv2_array_should_work() {
+        let mut buf = BytesMut::from("*2\r\n+OK\r\n-ERR\r\n");
+        let frame = RespFrame::decode(&mut buf).unwrap();
+        assert_eq!(
+            frame,
+            RespFrame::Array(
+                vec![
+                    RespFrame::SimpleString("OK".into()),
+                    RespFrame::Error("ERR".into())
+                ]
+                .into()
+            )
+        );
+    }
+
+    #[test]
+    fn respv2_null_array_length_should_work() {
+        let buf = b"*-1\r\n";
+        let len = RespFrame::expect_length(buf).unwrap();
+        assert_eq!(len, buf.len());
+    }
+
+    #[test]
+    fn respv2_null_array_should_work() {
+        let mut buf = BytesMut::from("*-1\r\n");
+        let frame = RespFrame::decode(&mut buf).unwrap();
+        assert_eq!(frame, RespFrame::NullArray(RespNullArray));
+    }
+
+    #[test]
+    fn respv2_map_length_should_work() {
+        let buf = b"%2\r\n+OK\r\n-ERR\r\n";
+        let len = RespFrame::expect_length(buf).unwrap();
+        assert_eq!(len, buf.len());
+    }
+
+    #[test]
+    fn respv2_map_should_work() {
+        let mut buf = BytesMut::from("%2\r\n+OK\r\n-ERR\r\n");
+        let frame = RespFrame::decode(&mut buf).unwrap();
+        let items: BTreeMap<String, RespFrame> =
+            [("OK".to_string(), RespFrame::Error("ERR".into()))]
+                .into_iter()
+                .collect();
+        assert_eq!(frame, RespFrame::Map(items.into()));
+    }
+}