Tests running. Fixed task1.

hw9/task1/src/lib.rs

 pub fn parse(message: &str) -> Result<Command, ParseError> {
-    let m: String = String::from(message);
+    let m: String = String::from(message.trim_right());
     let mut line = m.lines();
     match line.next() {
         Some(x) => {

hw9/task1/tests/task1.rs

 
     #[test]
     fn not_known_command_returns_correct_command() {
-        assert_eq!(
-            parse("Hello"),
-            Err(ParseError(ErrorType::UnknownCommand))
-        )
+        assert_eq!(parse("Hello\n"), Err(ParseError(ErrorType::UnknownCommand)))
     }
 
     #[test]
     fn stage_returns_correct_command() {
-        assert_eq!(parse("STAGE Hello"), Ok(Command::Stage("Hello".to_string())))
+        assert_eq!(
+            parse("STAGE Hello\n"),
+            Ok(Command::Stage("Hello".to_string()))
+        )
     }
 
     #[test]
     fn control_returns_correct_command() {
         assert_eq!(
-            parse("CONTROL Hello"),
+            parse("CONTROL Hello\n"),
             Ok(Command::Control("Hello".to_string()))
         )
     }
 
     #[test]
     fn retrieve_returns_correct_command() {
-        assert_eq!(parse("RETRIEVE"), Ok(Command::Retrieve))
+        assert_eq!(parse("RETRIEVE\n"), Ok(Command::Retrieve))
     }
 
     #[test]
     fn retrieve_with_arguments_returns_correct_command() {
-        assert_eq!(parse("RETRIEVE Hello"), Ok(Command::Retrieve))
+        assert_eq!(parse("RETRIEVE Hello\n"), Ok(Command::Retrieve))
     }
 
 }

hw9/task2/Cargo.toml

 
 [dependencies]
 srv-commands = { path = "srv-commands" }
-srv-config = { path = "srv-config" } 
+srv-config = { path = "srv-config" }
 
 [workspace]

hw9/task2/src/main.rs

 extern crate srv_commands;
 extern crate srv_config;
 
-
 use std::io::{BufReader, BufRead, BufWriter, Write};
 use std::collections::VecDeque;
 use std::net::{TcpListener, TcpStream};
 use srv_commands::Command;
 use srv_config::Config;
+use HashServerError::Parse;
 
 #[derive(Debug)]
 pub enum HashServerError {
     }
 }
 
-fn handle_client(stream: TcpStream, orders: &mut VecDeque<String>, config:&Config) {    
-    let mut reader = BufReader::new(&stream);
-	let mut writer = BufWriter::new(&stream);
-	
+fn handle_client(stream: &TcpStream, orders: &mut VecDeque<String>, v: bool) {
+    let mut reader = BufReader::new(stream);
+    let mut writer = BufWriter::new(stream);
+
     loop {
         let mut line = String::new();
         match reader.read_line(&mut line) {
                     break;
                 }
 
-                let cmd = srv_commands::parse(&line.trim_right()).map_err(HashServerError::Parse);
-                
+                let cmd = srv_commands::parse(&line).map_err(HashServerError::Parse);
+
                 match cmd {
                     Ok(Command::Stage(str)) => {
                         orders.push_front(str);
                     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());
-								let _ = writer.write(b"\n");
-							}
+                            if let Some(latest_order) = orders.pop_front() {
+                                let _ = writer.write(latest_order.as_bytes());
+                                let _ = writer.write(b"\n");
+                            }
                         }
                     }
                     Ok(Command::Control(ref control_string)) => {
-                        if config.verbosity > 0 {
+                        if v {
                             println!("Received Control: {}", control_string);
                         }
                     }
-                    Err(ref e) => {
+                    Err(Parse(e)) => {
                         println!("Error occurred: {:?}", e);
                     }
+                    _ => {}
                 }
-				
-				let _ = writer.flush();
-            },
+
+                let _ = writer.flush();
+            }
             _ => {
                 break;
-            },
+            }
         }
     }
 }
 
 pub fn main() {
-    
-	let c = Config::load();
+
+    let c = Config::load();
 
     if c.verbosity > 0 {
         println!("Starting Multi Hash Server 0.1:");
-        println!("verbosity: {} | address: {} | port: {} | test-mode: {}", c.verbosity, c.address, c.port, c.testing);
+        println!(
+            "verbosity: {} | address: {} | port: {} | test-mode: {}",
+            c.verbosity,
+            c.address,
+            c.port,
+            c.testing
+        );
     }
 
     let host = format!("{}:{}", c.address, c.port);
 
-	let mut orders:VecDeque<String> = VecDeque::new(); 
-	
-	if c.testing {
-		orders.push_front(String::from("Test3"));
-		orders.push_front(String::from("Test2"));
-		orders.push_front(String::from("Test1"));
-	}
-	
+    let mut orders: VecDeque<String> = VecDeque::new();
+
+    if c.testing {
+        orders.push_front(String::from("Test3"));
+        orders.push_front(String::from("Test2"));
+        orders.push_front(String::from("Test1"));
+    }
+
     match TcpListener::bind(host).map_err(HashServerError::Io) {
         Ok(listener) => {
             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") }
+                    if c.verbosity > 1 {
+                        println!("[DEBUG] New Client connected")
+                    }
+                    handle_client(&stream, &mut orders, c.verbosity > 0);
+                    if c.verbosity > 1 {
+                        println!("[DEBUG] Client diconnected")
+                    }
                 }
             }
         }
         Err(e) => {
-            println!("{:?}", e);
+            println!("Failed to start the MultiHashServer: {:?}", e);
         }
     }
 }

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

 pub fn parse(message: &str) -> Result<Command, ParseError> {
-    let m: String = String::from(message);
+    let m: String = String::from(message.trim_right());
     let mut line = m.lines();
     match line.next() {
         Some(x) => {

hw9/task2/srv-commands/tests/srv-commands.rs

+#[cfg(test)]
+
+mod tests {
+
+    extern crate task1;
+
+    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"), Err(ParseError(ErrorType::EmptyString)))
+    }
+
+    #[test]
+    fn not_known_command_returns_correct_command() {
+        assert_eq!(parse("Hello\n"), Err(ParseError(ErrorType::UnknownCommand)))
+    }
+
+    #[test]
+    fn stage_returns_correct_command() {
+        assert_eq!(
+            parse("STAGE Hello\n"),
+            Ok(Command::Stage("Hello".to_string()))
+        )
+    }
+
+    #[test]
+    fn control_returns_correct_command() {
+        assert_eq!(
+            parse("CONTROL Hello\n"),
+            Ok(Command::Control("Hello".to_string()))
+        )
+    }
+
+    #[test]
+    fn retrieve_returns_correct_command() {
+        assert_eq!(parse("RETRIEVE\n"), Ok(Command::Retrieve))
+    }
+
+    #[test]
+    fn retrieve_with_arguments_returns_correct_command() {
+        assert_eq!(parse("RETRIEVE Hello\n"), Ok(Command::Retrieve))
+    }
+
+}

hw9/task2/srv-config/Cargo.toml

 authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
 
 [dependencies]
-clap = {version = "~2.29.0", features = ["yaml"]}
+clap = {version = "~2.29.0", features = ["yaml"]}

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

 use clap::App;
 
 pub struct Config {
-	pub address:String,
-	pub port:String,
-	pub verbosity:u64,
-	pub testing:bool,
+    pub address: String,
+    pub port: String,
+    pub verbosity: u64,
+    pub testing: bool,
 }
 
 impl Config {
-	pub fn load() -> Self {
-		let yaml = load_yaml!("cli.yml");
-		let matches = App::from_yaml(yaml).get_matches();
-		let address = matches.value_of("address").unwrap_or("127.0.0.1");
-		let port = matches.value_of("port").unwrap_or("7878");
-		let verbosity = matches.occurrences_of("verbose");
-		let mut testing = false;
+    pub fn load() -> Self {
+        let yaml = load_yaml!("cli.yml");
+        let matches = App::from_yaml(yaml).get_matches();
+        let address = matches.value_of("address").unwrap_or("127.0.0.1");
+        let port = matches.value_of("port").unwrap_or("7878");
+        let verbosity = matches.occurrences_of("verbose");
+        let mut testing = false;
 
-		// Falls das Unterkommando timings angegeben wurde aktiviere die Zeitmessung.
-		if let Some(ref sub_command) = matches.subcommand {
-			if sub_command.name.eq("test") {
-				testing = true;
-			}
-		}
-		
-		Config{
-			address:address.to_string(),
-			port:port.to_string(),
-			verbosity:verbosity,
-			testing:testing,
-		}
-	}
-}
+        // Falls das Unterkommando timings angegeben wurde aktiviere die Zeitmessung.
+        if let Some(ref sub_command) = matches.subcommand {
+            if sub_command.name.eq("test") {
+                testing = true;
+            }
+        }
+
+        Config {
+            address: address.to_string(),
+            port: port.to_string(),
+            verbosity: verbosity,
+            testing: testing,
+        }
+    }
+}