task1 uses Results. task2 maps errors now.

hw9/task1/src/lib.rs

@@ -1,4 +1,4 @@
-pub fn parse(message: &str) -> Command {
+pub fn parse(message: &str) -> Result<Command, ParseError> {
     let m: String = String::from(message);
     let mut line = m.lines();
     match line.next() {
@@ -7,18 +7,18 @@ pub fn parse(message: &str) -> Command {
             match str.next() {
                 Some("STAGE") => {
                     let msg = m[6..].trim_left();
-                    Command::Stage(msg.to_string())
+                    Ok(Command::Stage(msg.to_string()))
                 }
                 Some("CONTROL") => {
                     let cmd = m[8..].trim_left();
-                    Command::Control(cmd.to_string())
+                    Ok(Command::Control(cmd.to_string()))
                 }
-                Some("RETRIEVE") => Command::Retrieve,
-                Some(_) => Command::ParseError(ErrorType::UnknownCommand),
-                None => Command::ParseError(ErrorType::EmptyString),
+                Some("RETRIEVE") => Ok(Command::Retrieve),
+                Some(_) => Err(ParseError(ErrorType::UnknownCommand)),
+                None => Err(ParseError(ErrorType::EmptyString)),
             }
         }
-        None => Command::ParseError(ErrorType::EmptyString),
+        None => Err(ParseError(ErrorType::EmptyString)),
     }
 }
 
@@ -27,9 +27,11 @@ pub enum Command {
     Stage(String),
     Control(String),
     Retrieve,
-    ParseError(ErrorType),
 }
 
+#[derive(Debug, PartialEq)]
+pub struct ParseError(pub ErrorType);
+
 #[derive(Debug, PartialEq)]
 pub enum ErrorType {
     UnknownCommand,

hw9/task1/tests/task1.rs

@@ -7,41 +7,42 @@ mod tests {
     use self::task1::Command;
     use self::task1::ErrorType;
     use self::task1::parse;
+    use self::task1::ParseError;
 
     #[test]
     fn empty_returns_correct_command() {
-        assert_eq!(parse("\n"), Command::ParseError(ErrorType::EmptyString))
+        assert_eq!(parse("\n"), Err(ParseError(ErrorType::EmptyString)))
     }
 
     #[test]
     fn not_known_command_returns_correct_command() {
         assert_eq!(
             parse("Hello"),
-            Command::ParseError(ErrorType::UnknownCommand)
+            Err(ParseError(ErrorType::UnknownCommand))
         )
     }
 
     #[test]
     fn stage_returns_correct_command() {
-        assert_eq!(parse("STAGE Hello"), Command::Stage("Hello".to_string()))
+        assert_eq!(parse("STAGE Hello"), Ok(Command::Stage("Hello".to_string())))
     }
 
     #[test]
     fn control_returns_correct_command() {
         assert_eq!(
             parse("CONTROL Hello"),
-            Command::Control("Hello".to_string())
+            Ok(Command::Control("Hello".to_string()))
         )
     }
 
     #[test]
     fn retrieve_returns_correct_command() {
-        assert_eq!(parse("RETRIEVE"), Command::Retrieve)
+        assert_eq!(parse("RETRIEVE"), Ok(Command::Retrieve))
     }
 
     #[test]
     fn retrieve_with_arguments_returns_correct_command() {
-        assert_eq!(parse("RETRIEVE Hello"), Command::Retrieve)
+        assert_eq!(parse("RETRIEVE Hello"), Ok(Command::Retrieve))
     }
 
 }

hw9/task2/src/main.rs

@@ -8,7 +8,25 @@ use std::net::{TcpListener, TcpStream};
 use srv_commands::Command;
 use srv_config::Config;
 
-fn handle_client(stream: TcpStream, orders: &mut VecDeque<String>) {    
+#[derive(Debug)]
+pub enum HashServerError {
+    Parse(srv_commands::ParseError),
+    Io(std::io::Error),
+}
+
+impl From<std::io::Error> for HashServerError {
+    fn from(err: std::io::Error) -> HashServerError {
+        HashServerError::Io(err)
+    }
+}
+
+impl From<srv_commands::ParseError> for HashServerError {
+    fn from(err: srv_commands::ParseError) -> HashServerError {
+        HashServerError::Parse(err)
+    }
+}
+
+fn handle_client(stream: TcpStream, orders: &mut VecDeque<String>, config:&Config) {    
     let mut reader = BufReader::new(&stream);
 	let mut writer = BufWriter::new(&stream);
 	
@@ -20,32 +38,34 @@ fn handle_client(stream: TcpStream, orders: &mut VecDeque<String>) {
                     break;
                 }
 
-                let cmd = srv_commands::parse(&line.trim_right());
+                let cmd = srv_commands::parse(&line.trim_right()).map_err(HashServerError::Parse);
                 
                 match cmd {
-                    Command::Stage(str) => {
+                    Ok(Command::Stage(str)) => {
                         orders.push_front(str);
                     }
-                    Command::Retrieve => {
+                    Ok(Command::Retrieve) => {
                         if orders.is_empty() {
                             let _ = writer.write(b"No order on stage!\n");
 							
                         } else {
 							if let Some(latest_order) = orders.pop_front() {
 								let _ = writer.write(latest_order.as_bytes());
-								writer.write(b"\n");
+								let _ = writer.write(b"\n");
 							}
                         }
                     }
-                    Command::Control(ref control_string) => {
-                        println!("Received Control: {}", control_string);
+                    Ok(Command::Control(ref control_string)) => {
+                        if config.verbosity > 0 {
+                            println!("Received Control: {}", control_string);
+                        }
                     }
-                    Command::ParseError(_) => {
-                        println!("Error occurred: {:?}", cmd);
+                    Err(ref e) => {
+                        println!("Error occurred: {:?}", e);
                     }
                 }
 				
-				writer.flush();
+				let _ = writer.flush();
             },
             _ => {
                 break;
@@ -73,21 +93,18 @@ pub fn main() {
 		orders.push_front(String::from("Test1"));
 	}
 	
-    match TcpListener::bind(host) {
+    match TcpListener::bind(host).map_err(HashServerError::Io) {
         Ok(listener) => {
-            for stream in listener.incoming() {
-                match stream {
-                    Ok(stream) => {
-						if c.verbosity > 1 { println!("[DEBUG] New Client connected") }
-						handle_client(stream, &mut orders);
-						if c.verbosity > 1 { println!("[DEBUG] Client diconnected") }
-                    }
-                    Err(_) => { /* connection failed */ }
+            for s in listener.incoming() {
+                if let Ok(stream) = s {
+                    if c.verbosity > 1 { println!("[DEBUG] New Client connected") }
+                    handle_client(stream, &mut orders, &c);
+                    if c.verbosity > 1 { println!("[DEBUG] Client diconnected") }
                 }
             }
         }
-        Err(_) => {
-            println!("Error starting server.");
+        Err(e) => {
+            println!("{:?}", e);
         }
     }
 }

hw9/task2/srv-commands/src/lib.rs

@@ -1,4 +1,4 @@
-pub fn parse(message: &str) -> Command {
+pub fn parse(message: &str) -> Result<Command, ParseError> {
     let m: String = String::from(message);
     let mut line = m.lines();
     match line.next() {
@@ -7,18 +7,18 @@ pub fn parse(message: &str) -> Command {
             match str.next() {
                 Some("STAGE") => {
                     let msg = m[6..].trim_left();
-                    Command::Stage(msg.to_string())
+                    Ok(Command::Stage(msg.to_string()))
                 }
                 Some("CONTROL") => {
                     let cmd = m[8..].trim_left();
-                    Command::Control(cmd.to_string())
+                    Ok(Command::Control(cmd.to_string()))
                 }
-                Some("RETRIEVE") => Command::Retrieve,
-                Some(_) => Command::ParseError(ErrorType::UnknownCommand),
-                None => Command::ParseError(ErrorType::EmptyString),
+                Some("RETRIEVE") => Ok(Command::Retrieve),
+                Some(_) => Err(ParseError(ErrorType::UnknownCommand)),
+                None => Err(ParseError(ErrorType::EmptyString)),
             }
         }
-        None => Command::ParseError(ErrorType::EmptyString),
+        None => Err(ParseError(ErrorType::EmptyString)),
     }
 }
 
@@ -27,9 +27,11 @@ pub enum Command {
     Stage(String),
     Control(String),
     Retrieve,
-    ParseError(ErrorType),
 }
 
+#[derive(Debug, PartialEq)]
+pub struct ParseError(pub ErrorType);
+
 #[derive(Debug, PartialEq)]
 pub enum ErrorType {
     UnknownCommand,