Nearly finished. Error handling and tests missing.

hw9/task2/Cargo.toml

@@ -4,7 +4,6 @@ version = "0.1.0"
 authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
 
 [dependencies]
-clap = {version = "~2.29.0", features = ["yaml"]}
 srv-commands = { path = "srv-commands" }
 srv-config = { path = "srv-config" } 
 

hw9/task2/src/main.rs

@@ -1,17 +1,17 @@
-#[macro_use]
-extern crate clap;
 extern crate srv_commands;
+extern crate srv_config;
 
-use clap::App;
-use std::io::{BufReader, BufRead};
+
+use std::io::{BufReader, BufRead, BufWriter, Write};
 use std::collections::VecDeque;
 use std::net::{TcpListener, TcpStream};
 use srv_commands::Command;
+use srv_config::Config;
 
-fn handle_client(stream: TcpStream) {
-    println!("New Client connected");
-    let mut orders:VecDeque<Command> = VecDeque::new(); 
-    let mut reader = BufReader::new(stream);
+fn handle_client(stream: TcpStream, orders: &mut VecDeque<String>) {    
+    let mut reader = BufReader::new(&stream);
+	let mut writer = BufWriter::new(&stream);
+	
     loop {
         let mut line = String::new();
         match reader.read_line(&mut line) {
@@ -20,18 +20,21 @@ fn handle_client(stream: TcpStream) {
                     break;
                 }
 
-                let cmd = srv_commands::parse(&line); 
-                println!("Command: {:?}", cmd);
+                let cmd = srv_commands::parse(&line.trim_right());
                 
                 match cmd {
-                    Command::Stage(_) => {
-                        orders.push_front(cmd);
+                    Command::Stage(str) => {
+                        orders.push_front(str);
                     }
                     Command::Retrieve => {
                         if orders.is_empty() {
-                            println!("No order on stage!");
+                            let _ = writer.write(b"No order on stage!\n");
+							
                         } else {
-                            println!("{:?}", orders.pop_front());
+							if let Some(latest_order) = orders.pop_front() {
+								let _ = writer.write(latest_order.as_bytes());
+								writer.write(b"\n");
+							}
                         }
                     }
                     Command::Control(ref control_string) => {
@@ -41,45 +44,43 @@ fn handle_client(stream: TcpStream) {
                         println!("Error occurred: {:?}", cmd);
                     }
                 }
+				
+				writer.flush();
             },
             _ => {
                 break;
             },
         }
     }
-
-    println!("Client diconnected");
 }
 
 pub fn main() {
-    // Lade Commandline Einstellungen aus YAML-Datei
-    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;
-        }
-    }
+    
+	let c = Config::load();
 
-    if verbosity > 0 {
+    if c.verbosity > 0 {
         println!("Starting Multi Hash Server 0.1:");
-        println!("verbosity: {} | address: {} | port: {} | test-mode: {}", verbosity, address, port, testing);
+        println!("verbosity: {} | address: {} | port: {} | test-mode: {}", c.verbosity, c.address, c.port, c.testing);
     }
 
-    let host = format!("{}:{}", address, port);
+    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"));
+	}
+	
     match TcpListener::bind(host) {
         Ok(listener) => {
             for stream in listener.incoming() {
                 match stream {
                     Ok(stream) => {
-						handle_client(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 */ }
                 }

hw9/task2/srv-config/Cargo.toml

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

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

@@ -1,7 +1,36 @@
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
+#[macro_use]
+extern crate clap;
+
+use clap::App;
+
+pub struct Config {
+	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;
+
+		// 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,
+		}
+	}
+}