hw10 now has the same functionality as hw9.

hw10/task1/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "task1"
+version = "0.2.0"
+authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>", "Lorenz Bung <lorenz.bung@htwg-konstanz.de>"]
+
+[dependencies]
+srv-commands = { path = "srv-commands" }
+srv-config = { path = "srv-config" }
+
+[workspace]

hw10/task1/DESIGN.md

@@ -0,0 +1 @@
+# Design des MultiHashServer (hw10)

hw10/task1/src/main.rs

@@ -0,0 +1,121 @@
+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 {
+    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>, 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) {
+            Ok(n) => {
+                if n == 0 {
+                    break;
+                }
+
+                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");
+                            }
+                        }
+                    }
+                    Ok(Command::Control(ref control_string)) => {
+                        if v {
+                            println!("Received Control: {}", control_string);
+                        }
+                    }
+                    Err(Parse(e)) => {
+                        println!("Error occurred: {:?}", e);
+                    }
+                    _ => {}
+                }
+
+                let _ = writer.flush();
+            }
+            _ => {
+                break;
+            }
+        }
+    }
+}
+
+pub fn main() {
+
+    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
+        );
+    }
+
+    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).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.verbosity > 0);
+                    if c.verbosity > 1 {
+                        println!("[DEBUG] Client diconnected")
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            println!("Failed to start the MultiHashServer: {:?}", e);
+        }
+    }
+}

hw10/task1/srv-commands/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "srv-commands"
+version = "0.1.0"
+authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
+
+[dependencies]
+sha2 = "0.7.0"
+time = "0.1"

hw10/task1/srv-commands/src/lib.rs

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

hw10/task1/srv-commands/tests/srv-commands.rs

@@ -0,0 +1,43 @@
+#[cfg(test)]
+
+mod tests {
+	extern crate srv_commands;
+    use self::srv_commands::*;
+
+    #[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))
+    }
+
+}

hw10/task1/srv-config/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "srv-config"
+version = "0.1.0"
+authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
+
+[dependencies]
+clap = {version = "~2.29.0", features = ["yaml"]}

hw10/task1/srv-config/src/cli.yml

@@ -0,0 +1,32 @@
+name: "Multi Hash Server 0.1"
+author: "Lorenz Bung & Joshua Rutschmann"
+about: "Does awesome things to find a hash with specific pattern"
+args:
+    - verbose:
+        short: "v"
+        help: "Prints help information"
+        multiple: true
+        required: false
+
+    - address:
+        short: "a"
+        long: "address"
+        value_name: "ADDRESS"
+        help: "the address, where the server can be reached (127.0.0.1 is default)"
+        takes_value: true
+        required: false
+
+    - port:
+        short: "p"
+        long: "port"
+        value_name: "PORT"
+        help: "the port, where the server can be reached (7878 is default)"
+        takes_value: true
+        required: true
+
+subcommands:
+    - test:
+        about: "controls testing features"
+        version: "1.0"
+        author: "Lorenz Bung & Joshua Rutschmann"
+

hw10/task1/srv-config/src/lib.rs

@@ -0,0 +1,36 @@
+#[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,
+        }
+    }
+}