Merge branch 'hw6' of https://github.com/themultiplexer/bsys-ws17-grp11 into hw6

.gitignore

 # Generated by Cargo
 # will have compiled files and executables
-/target/
+*/*/target/
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
 **/*.rs.bk
 
 *.swp
+
+# Files generated by IntelliJ IDEA
+*.idea

hw6/simu1/ANSWERS.md

+# hw6 - Simulation 1 - Antworten
+
+1.
+    * Da Job 1 so viel mehr Tickets hat, ist es bei der Ausführung durch den Lottery Scheduler viel wahrscheinlicher, dass dieser Job ausgeführt wird.
+    * Job 0 wird (zumindest mit `-s 0`) nie ausgeführt, bevor Job 1 fertig ist. Theoretisch könnte es vorkommen, ist jedoch sehr unwahrscheinlich (1/101-tel pro Tick).
+    * Eine solch unfaire Ticketverteilung führt zu einem Verhalten des Schedulers, das nicht der Idee der "Lottery" entspricht. Es führt dazu, das ein Job zunächst vollständig ausgeführt wird und anschließend der andere, bzw. zu einer Priorisierung des Jobs mit vielen Tickets. Das Verhalten wird dadurch ähnlich zu Schedulern wie z.B. FIFO.
+
+2. Der Scheduler ist sehr fair bei einer Joblänge von 100. Mit `-s 1` ist die Fairness `196/200 = 0,98`, mit `-s 2` liegt sie bei `190/200 = 0,95`, mit `-s 3` bei `196/200 = 0,98`, mit `-s 4` bei `199/200 = 0,995` und mit `-s 5` bei `181/200 = 0,905`. Im Durchschnitt (unter Verwendung dieser 5 Seeds) ist das eine Fairness von `0,962`, was sehr nahe an der angestrebten Fairness von `1,0` liegt.
+
+3. Mit `-q 10` und den Seeds 1-5 ergeben sich folgende Fairness-Werte: `-s 1` und `-s 5`: `160/200 = 0,8`, `-s 2`, `-s 3` und `-s 4`: `190/200 = `0,95`. Die durchschnittliche Fairness liegt damit bei `0,92`, was deutlich schlechter als mit kürzerer Quantumzeit ist. Je größer die Quantumzeit dabei wird, desto schlechter ist auch die Fairness. Beispielsweise ergibt sich mit den selben Seeds, jedoch mit `-q 100` nur noch eine durchschnittliche Fairness von `0,5`.
+
+4. Mit einem Stride Scheduler wäre die Fairness immer 100%, da beide Jobs die selbe Länge haben und somit immer abwechselnd ausgeführt würden. Der Graph wäre somit konstant auf 1.0.

hw6/task1/src/main.rs

 extern crate nix;
 
 use nix::unistd::{fork, pipe, read, write};
-use nix::sys::wait::wait;
+use nix::sys::wait::{wait, WaitStatus};
 use std::str;
-use nix::sys::wait::WaitStatus;
 use nix::unistd::ForkResult::{Child, Parent};
 use std::os::unix::io::RawFd;
 
+mod unit_test_pipe;
+
 const BUFFER_SIZE: usize = 256;
 
 
                                 Ok(Child) => {
                                     match sum_strings(vec) {
                                         Ok(res) => println!("Sum = {}", res),
-                                        Err(e) => println!("{}", e),
+                                        Err(e) => {
+                                            println!("{}", e);
+                                            process::exit(1);
+                                        }
                                     }
                                 }
                                 Ok(Parent { .. }) => {
                                     if let Ok(ws) = wait() {
-                                        if let WaitStatus::Exited(_, _) = ws {
+                                        if let WaitStatus::Exited(_, exit_code) = ws {
                                             match mul_strings(vec) {
                                                 Ok(res) => println!("Mul = {}", res),
-                                                Err(e) => println!("{}", e),
+                                                Err(e) => {
+                                                    println!("{}", e);
+                                                    process::exit(1);
+                                                }
                                             }
+                                            process::exit(exit_code as i32);
                                         }
                                     }
                                 }
                     for s in numbers {
                         args = concatenate_strings(&args, &concatenate_strings(&s, " "));
                     }
-                    println!("sending to children: {}", args);
+                    println!("sending to childs: {}", args);
+
                     if let Err(_) = write(writer, args.as_bytes()) {
                         println!("Broken pipe")
                     }
 
-                    if let Err(_) = wait() {
-                        println!("Waiting on children failed")
+                    if let Ok(ws) = wait() {
+                        if let WaitStatus::Exited(_, exit_code) = ws {
+                            process::exit(exit_code as i32);
+                        }
                     }
                 }
 
 }
 
 /// Calculates the sum of the given Strings and returns them as a Result.
-fn sum_strings(v: Vec<String>) -> Result<i32, String> {
-    let mut sum = 0;
+fn sum_strings(v: Vec<String>) -> Result<i64, String> {
+    let mut sum: i64 = 0;
     for x in v {
-        match x.parse::<i32>() {
+        match x.parse::<i64>() {
             Ok(val) => {
-                match i32::checked_add(sum, val) {
+                match i64::checked_add(sum, val) {
                     Some(y) => {
                         sum = y;
                     }
 }
 
 /// Calculates the product of the given Strings and returns them as a Result.
-fn mul_strings(v: Vec<String>) -> Result<i32, String> {
-    let mut prod = 1;
+fn mul_strings(v: Vec<String>) -> Result<i64, String> {
+    let mut prod: i64 = 1;
     for x in v {
-        match x.parse::<i32>() {
+        match x.parse::<i64>() {
             Ok(val) => {
-                match i32::checked_mul(prod, val) {
+                match i64::checked_mul(prod, val) {
                     Some(y) => {
                         prod = y;
                     }

hw6/task1/src/unit_test_pipe.rs

+#[cfg(test)]
+mod test {
+    use read_from_pipe;
+    use nix::unistd::{pipe, write};
+
+    #[test]
+    fn test_pipe() {
+        match pipe() {
+            Ok((reader, writer)) => {
+                let input = b"teststring";
+
+                if let Err(_) = write(writer, input) {
+                    // Broken pipe
+                }
+                assert_eq!(read_from_pipe(reader).unwrap(), "teststring".to_string());
+            }
+            Err(_) => {}
+        }
+
+    }
+
+    #[test]
+    fn test_kill_last_child() {}
+}

hw6/task2/src/command.rs

 use std::str::FromStr;
 use std::env;
 
+#[derive(PartialEq, Debug)]
 pub enum Command {
     Empty,
     Exit,
     Cd(Option<OsString>),
 }
 
+#[derive(PartialEq, Debug)]
 pub struct CommandNotFoundError;
 
 impl FromStr for Command {
 
 
 impl Command {
-    /// If the passed String exists, set the path of the Cd in the enum
+    /// If the passed String exists, set the path of the Cd in the enum (as OsString)
+    /// Returns **Command**
     pub fn parse_cd(cmd: Option<&str>) -> Self {
         match cmd {
             None => Command::Cd(None),
         }
     }
 
+    /// If this instance is of Kind **Command::Cd** either go to HOME or navigate to the given path
     pub fn exec_cd(&self) {
         if let Command::Cd(None) = *self {
             let possible_home = env::home_dir();

hw6/task2/src/main.rs

 use std::process;
-use shell::{Shell, R, W};
+use shell::Shell;
 use std::io;
 
+mod unit_tests_shell;
 mod command;
 mod shell;
 
 
+
 fn main() {
     let stdin = io::stdin();
-    let input = R(stdin.lock());
-
     let stdout = io::stdout();
-    let output = W(stdout.lock());
 
-    let mut s = Shell::new(input, output, "schell".to_string());
+    let mut s = Shell::new(stdin.lock(), stdout.lock(), "schell".to_string());
     match s.start() {
         Ok(_) => process::exit(0),
         Err(_) => process::exit(1),

hw6/task2/src/shell.rs

-use std::io::{BufRead, Write, Read, StdinLock, StdoutLock};
-use std::io;
-
+use std::io::{BufRead, Write};
 use command::*;
 use std::str::FromStr;
 use std::env;
 
-///Tuple-Structs which hold Std-in and -out locks.
-pub struct R<'a>(pub StdinLock<'a>);
-pub struct W<'a>(pub StdoutLock<'a>);
-
-pub struct Shell<R, W> {
+pub struct Shell<R: BufRead, W: Write> {
     pub reader: R,
     pub writer: W,
     pub should_exit: bool,
     pub name: String,
 }
 
-impl<'a> Shell<R<'a>, W<'a>> {
+impl<R: BufRead, W: Write> Shell<R, W> {
     /// Creates a new Shell with a name, input and output.
-    pub fn new(input: R<'a>, output: W<'a>, name: String) -> Self {
+    pub fn new(input: R, output: W, name: String) -> Self {
         Shell {
             reader: input,
             writer: output,
     /// If the Command-creation succeeds, run the command.
     fn shell_loop(&mut self) -> Result<(), &str> {
         while !self.should_exit {
-            if let Ok(line) = self.prompt() {
+            if let Ok(Some(line)) = self.prompt() {
                 let _ = Command::from_str(&line).and_then(|cmd| self.run(cmd));
             }
         }
 
     /// Prints the shell prompt.
     /// Waits for user input and returns the read line.
-    fn prompt(&mut self) -> Result<String, &str> {
+    pub fn prompt(&mut self) -> Result<Option<String>, &str> {
         match env::current_dir() {
             Ok(pwd) => {
                 let _ = self.writer.write(
                 let mut line: String = String::new();
                 let read_result = self.reader.read_line(&mut line);
                 match read_result {
-                    Ok(_) => Ok(line),
-                    Err(_) => Err("Error reading."),
+                    Ok(_) => Ok(Some(line)),
+                    Err(_) => Ok(None),
                 }
             }
             Err(_) => return Err("Path Error"),
         Ok(())
     }
 }
-
-/// Implement Read-Trait for Tuple-Struct R
-/// Simply calls `read` of StdinLock
-impl<'a> Read for R<'a> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
-        self.0.read(buf)
-    }
-}
-
-/// Implement BufRead-Trait for Tuple-Struct R
-/// Simply calls `fill_buff` and `consume` from StdinLock
-impl<'a> BufRead for R<'a> {
-    fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
-        self.0.fill_buf()
-    }
-
-    fn consume(&mut self, amt: usize) {
-        self.0.consume(amt)
-    }
-}
-
-/// Implement Write-Trait for Tuple-Struct W
-/// Simply calls `write` and `flush` from StdoutLock
-impl<'a> Write for W<'a> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
-        self.0.write(buf)
-    }
-
-    fn flush(&mut self) -> Result<(), io::Error> {
-        self.0.flush()
-    }
-}

hw6/task2/src/unit_tests_shell.rs

 #[cfg(test)]
 mod test {
-    use shell::Shell;
+    pub use shell::Shell;
+    use command::Command;
+    use command::CommandNotFoundError;
+    use std::str::FromStr;
+    use std::ffi::OsString;
+
+    #[test]
+    fn test_command_empty_whitespace() {
+        assert_eq!(Command::from_str("       ").unwrap(), Command::Empty);
+    }
+
+    #[test]
+    fn test_command_empty_tab() {
+        assert_eq!(Command::from_str("\t").unwrap(), Command::Empty);
+    }
+
+    #[test]
+    fn test_command_cd() {
+        assert_eq!(
+            Command::from_str("cd /home/peter/").unwrap(),
+            Command::Cd(Some(OsString::from("/home/peter/")))
+        );
+    }
+
+    #[test]
+    fn test_command_home() {
+        assert_eq!(Command::from_str("cd").unwrap(), Command::Cd(None));
+    }
+
+    #[test]
+    fn test_command_exit() {
+        assert_eq!(Command::from_str("exit").unwrap(), Command::Exit);
+    }
+
+    #[test]
+    fn test_command_not_found() {
+        assert_eq!(
+            Command::from_str("awdeiu33we").unwrap_err(),
+            CommandNotFoundError
+        );
+    }
 
     #[test]
     fn test_prompt_in_memory_with_string() {