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

hw6/task1/src/main.rs

@@ -10,7 +10,7 @@ use nix::sys::wait::WaitStatus;
 use nix::unistd::ForkResult::{Child, Parent};
 use std::os::unix::io::RawFd;
 
-const BUFFER_SIZE : usize = 256;
+const BUFFER_SIZE: usize = 256;
 
 
 fn main() {
@@ -18,13 +18,12 @@ fn main() {
     let arguments: Vec<String> = args().collect();
 
     if arguments.len() > 2 {
-        if let Ok((reader, writer)) = pipe(){
+        if let Ok((reader, writer)) = pipe() {
             let numbers = arguments[1..].to_vec();
 
             let pid = fork();
             match pid {
                 Ok(Child) => {
-
                     match read_from_pipe(reader) {
                         Ok(msg_received) => {
                             let vec = split_into_strings(&msg_received);
@@ -36,34 +35,34 @@ fn main() {
                                         Ok(res) => println!("Sum = {}", res),
                                         Err(e) => println!("{}", e),
                                     }
-                                },
-                                Ok(Parent{..}) => {
+                                }
+                                Ok(Parent { .. }) => {
                                     if let Ok(ws) = wait() {
-                                        if let WaitStatus::Exited(_,_) = ws {
+                                        if let WaitStatus::Exited(_, _) = ws {
                                             match mul_strings(vec) {
                                                 Ok(res) => println!("Mul = {}", res),
                                                 Err(e) => println!("{}", e),
                                             }
                                         }
                                     }
-                                },
+                                }
                                 Err(_) => println!("Fatal error: Fork failed"),
                             }
 
-                        },
-                        Err(_) => {},
+                        }
+                        Err(_) => {}
                     }
-
-
                 }
 
-                Ok(Parent{..}) => {
+                Ok(Parent { .. }) => {
                     let mut args = String::new();
                     for s in numbers {
-                        args = concatenate_strings(&args, &concatenate_strings(&s , " "));
+                        args = concatenate_strings(&args, &concatenate_strings(&s, " "));
                     }
                     println!("sending to children: {}", args);
-                    if let Err(_) = write(writer, args.as_bytes()) { println!("Broken pipe") }
+                    if let Err(_) = write(writer, args.as_bytes()) {
+                        println!("Broken pipe")
+                    }
 
                     if let Err(_) = wait() {
                         println!("Waiting on children failed")
@@ -80,15 +79,15 @@ fn main() {
 
 }
 
-fn read_from_pipe(reader:RawFd) -> Result<String, String>{
+fn read_from_pipe(reader: RawFd) -> Result<String, String> {
     let mut read_buf = [0u8; BUFFER_SIZE];
-    match read(reader, &mut read_buf){
+    match read(reader, &mut read_buf) {
         Ok(bytes_read) => {
-            match str::from_utf8(&read_buf[0 .. bytes_read]) {
+            match str::from_utf8(&read_buf[0..bytes_read]) {
                 Ok(msg_received) => Ok(msg_received.to_string()),
                 Err(_) => Err("Couldn't read".to_string()),
             }
-        },
+        }
         Err(_) => Err("Couldn't read".to_string()),
     }
 }
@@ -142,4 +141,4 @@ fn mul_strings(v: Vec<String>) -> Result<i32, String> {
         }
     }
     Ok(prod)
-}
+}

hw6/task2/src/command.rs

@@ -1,11 +1,63 @@
-enum Command {
+use std::ffi::OsString;
+use std::str::FromStr;
+use std::env;
+
+pub enum Command {
     Empty,
     Exit,
     Cd(Option<OsString>),
 }
 
-impl Command {}
+pub struct CommandNotFoundError;
 
 impl FromStr for Command {
-    fn from_str(s: &str) -> Result<Self, Self::Err> {}
+    type Err = CommandNotFoundError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+
+        let mut parts = s.split_whitespace();
+
+        match parts.next() {
+            Some("exit") => Ok(Command::Exit),
+            Some("cd") => Ok(Command::parse_cd(parts.next())),
+            Some(cmd) => {
+                //For use in next homework, to execute programs.
+                let _ = cmd;
+                Err(CommandNotFoundError)
+            }
+            None => Ok(Command::Empty),
+        }
+    }
+}
+
+
+impl Command {
+    /// If the passed String exists, set the path of the Cd in the enum
+    pub fn parse_cd(cmd: Option<&str>) -> Self {
+        match cmd {
+            None => Command::Cd(None),
+            Some(dest) => Command::Cd(Some(OsString::from(dest))),
+        }
+    }
+
+    pub fn exec_cd(&self) {
+        if let Command::Cd(None) = *self {
+            let possible_home = env::home_dir();
+
+            if let Some(home) = possible_home {
+                let home_path = home.as_path();
+                let _ = env::set_current_dir(home_path);
+            }
+
+        }
+
+        if let Command::Cd(Some(ref path)) = *self {
+            match path.to_str() {
+                Some(_) => {
+                    let _ = env::set_current_dir(path);
+                }
+                None => {}
+            }
+
+        }
+    }
 }

hw6/task2/src/main.rs

@@ -1,8 +1,19 @@
 use std::process;
+use shell::{Shell, R, W};
+use std::io;
+
+mod command;
 mod shell;
 
+
 fn main() {
-    let mut s = Shell::new(..);
+    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());
     match s.start() {
         Ok(_) => process::exit(0),
         Err(_) => process::exit(1),

hw6/task2/src/shell.rs

@@ -1,52 +1,114 @@
+use std::io::{BufRead, Write, Read, StdinLock, StdoutLock};
 use std::io;
-use std::io::prelude::*;
-use command;
 
-struct Shell<R, W> {
+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 reader: R,
     pub writer: W,
     pub should_exit: bool,
     pub name: String,
 }
 
-impl Shell<R, W> {
-    /// Creates a new Shell.
-    pub fn new(input: R, output: W, name: String) -> Self {
+impl<'a> Shell<R<'a>, W<'a>> {
+    /// Creates a new Shell with a name, input and output.
+    pub fn new(input: R<'a>, output: W<'a>, name: String) -> Self {
         Shell {
-            reader = input,
-            writer = output,
-            should_exit = false,
-            name = name,
+            reader: input,
+            writer: output,
+            should_exit: false,
+            name: name,
         }
     }
-    /// Initializes the Shell Loop
-    pub fn start() -> Result<Self, &str> {
-        shell_loop();
+    /// Initializes the Shell Loop.
+    /// Starts the shell.
+    pub fn start(&mut self) -> Result<(), &str> {
+        self.shell_loop()
     }
-    /// Waits for user inputs.
-    fn shell_loop() -> Result {
-        loop {
+
+    /// Loops while exit hasn't been called.
+    /// When *prompt()* returns (the user hit enter) a Command is created through the FromStr-Trait.
+    /// 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() {
+                let _ = Command::from_str(&line).and_then(|cmd| self.run(cmd));
+            }
         }
+        Ok(())
     }
+
     /// Prints the shell prompt.
-    fn prompt() -> Result<Option, &str> {
+    /// Waits for user input and returns the read line.
+    fn prompt(&mut self) -> Result<String, &str> {
+        match env::current_dir() {
+            Ok(pwd) => {
+                let _ = self.writer.write(
+                    format!("{} {} > ", self.name, pwd.display())
+                        .as_bytes(),
+                );
+                let _ = self.writer.flush();
+
+                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."),
+                }
+            }
+            Err(_) => return Err("Path Error"),
+        }
     }
+
     /// Runs a command.
-    fn run(&str) {
+    /// Currently only `cd` and `exit` are working.
+    fn run(&mut self, command: Command) -> Result<(), CommandNotFoundError> {
+
+        match command {
+            Command::Empty => {}
+            Command::Exit => self.should_exit = true,
+            Command::Cd(_) => {
+                command.exec_cd();
+            }
+        }
+        Ok(())
     }
 }
 
-impl BufRead for Shell<R, W> {
-    fn fill_buf(&mut self) -> Result<&[u8]> {
-        stdin.fill_buf()
+/// 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)
     }
 }
 
-impl Write for Shell<R, W> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+/// 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<()> {
+
+    fn flush(&mut self) -> Result<(), io::Error> {
+        self.0.flush()
     }
 }