First version

parser/src/lib.rs

@@ -16,35 +16,6 @@ pub enum Value<'a> {
     Null,
 }
 
-#[derive(Debug, PartialEq, Clone)]
-pub enum Frame {
-    Array(Vec<Frame>),
-    Blob(Vec<u8>),
-    String(String),
-    Error(String, String),
-    Integer(i64),
-    Boolean(bool),
-    Float(f64),
-    BigInteger(i128),
-    Null,
-}
-
-impl<'a> Value<'a> {
-    pub fn to_frame(&self) -> Frame {
-        match self {
-            Self::String(x) => Frame::String(x.to_string()),
-            Self::Blob(x) => Frame::Blob(x.to_vec()),
-            Self::Array(x) => Frame::Array(x.iter().map(|x| x.to_frame()).collect()),
-            Self::Boolean(x) => Frame::Boolean(*x),
-            Self::BigInteger(x) => Frame::BigInteger(*x),
-            Self::Integer(x) => Frame::Integer(*x),
-            Self::Float(x) => Frame::Float(*x),
-            Self::Error(x, y) => Frame::Error(x.to_string(), y.to_string()),
-            Self::Null => Frame::Null,
-        }
-    }
-}
-
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Error {
     Partial,

src/main.rs

@@ -0,0 +1,72 @@
+mod value;
+
+use bytes::{Buf, BytesMut};
+use redis_zero_parser::{parse, Error as RedisError};
+use std::convert::TryFrom;
+use std::env;
+use std::error::Error;
+use std::{
+    io,
+    sync::{Arc, Mutex},
+};
+use tokio::net::{TcpListener, TcpStream};
+use tokio_stream::StreamExt;
+use tokio_util::codec::{Decoder, Framed};
+use value::Value;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let addr = env::args()
+        .nth(1)
+        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
+
+    let listener = TcpListener::bind(&addr).await?;
+    println!("Listening on: {}", addr);
+
+    loop {
+        match listener.accept().await {
+            Ok((socket, _)) => {
+                tokio::spawn(async move {
+                    let mut lines = Framed::new(socket, RedisParser);
+
+                    while let Some(result) = lines.next().await {
+                        match result {
+                            Ok(line) => {
+                                println!("x => ({:?})", line);
+                            }
+                            Err(e) => {
+                                println!("error on decoding from socket; error = {:?}", e);
+                                break;
+                            }
+                        }
+                    }
+                });
+            }
+            Err(e) => println!("error accepting socket; error = {:?}", e),
+        }
+    }
+
+    Ok(())
+}
+
+struct RedisParser;
+
+impl Decoder for RedisParser {
+    type Item = Value;
+    type Error = io::Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> io::Result<Option<Self::Item>> {
+        let (frame, proccesed) = {
+            let (unused, val) = match parse(src) {
+                Ok((buf, val)) => (buf, val),
+                Err(RedisError::Partial) => return Ok(None),
+                Err(_) => return Err(io::Error::new(io::ErrorKind::Other, "something")),
+            };
+            (Value::try_from(&val).unwrap(), src.len() - unused.len())
+        };
+
+        src.advance(proccesed);
+
+        Ok(Some(frame))
+    }
+}

src/value.rs

@@ -0,0 +1,35 @@
+use redis_zero_parser::Value as ParsedValue;
+use std::convert::TryFrom;
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum Value {
+    Array(Vec<Value>),
+    Blob(Vec<u8>),
+    String(String),
+    Err(String, String),
+    Integer(i64),
+    Boolean(bool),
+    Float(f64),
+    BigInteger(i128),
+    Null,
+}
+
+impl<'a> TryFrom<&ParsedValue<'a>> for Value {
+    type Error = &'static str;
+
+    fn try_from(value: &ParsedValue) -> Result<Self, Self::Error> {
+        Ok(match value {
+            ParsedValue::String(x) => Self::String(x.to_string()),
+            ParsedValue::Blob(x) => Self::Blob(x.to_vec()),
+            ParsedValue::Array(x) => {
+                Self::Array(x.iter().map(|x| Value::try_from(x).unwrap()).collect())
+            }
+            ParsedValue::Boolean(x) => Self::Boolean(*x),
+            ParsedValue::BigInteger(x) => Self::BigInteger(*x),
+            ParsedValue::Integer(x) => Self::Integer(*x),
+            ParsedValue::Float(x) => Self::Float(*x),
+            ParsedValue::Error(x, y) => Self::Err(x.to_string(), y.to_string()),
+            ParsedValue::Null => Self::Null,
+        })
+    }
+}