Fixed main completely. Struct for pstree.

hw4/task1/src/main.rs

@@ -12,54 +12,45 @@ fn main() {
 
     match args.len() {
         1 => {
-            match readproc::self_pids() {
-                Ok(pid_tuple) => {
-                    let pid = pid_tuple.0;
-                    let ppid = pid_tuple.1;
-
-                    // Commands
-                    let pid_command = readproc::get_pid_command(pid).unwrap();
-                    let ppid_command = readproc::get_pid_command(ppid).unwrap();
-
-                    // Threads
-                    let pid_threads = readproc::get_thread_count(pid).unwrap();
-                    let ppid_threads = readproc::get_thread_count(ppid).unwrap();
-
-                    // Output for PID and PPID Information
-                    println!("My PID : {} - {} running {} threads", pid, pid_command, pid_threads);
-                    println!("My PPID: {} - {} running {} threads", ppid, ppid_command, ppid_threads);
+            if let Ok(pid_tuple) = readproc::self_pids() {
+                let pid = pid_tuple.0;
+                let ppid = pid_tuple.1;
+
+                // Commands & Threads for PID
+                if let Ok(pid_command) = readproc::get_pid_command(pid){
+                    if let Ok(pid_threads) = readproc::get_thread_count(pid){
+                        println!("My PID : {} - {} running {} threads", pid, pid_command, pid_threads);
+                    }
                 }
-                Err(_) => {}
+
+                // Commands & Threads for Parent-PID
+                if let Ok(ppid_command) = readproc::get_pid_command(ppid){
+                    if let Ok(ppid_threads) = readproc::get_thread_count(ppid){
+                        println!("My PPID: {} - {} running {} threads", ppid, ppid_command, ppid_threads);
+                    }
+                }
+
             }
 
 
-            match readproc::get_ownprocess_mem() {
-                Ok(size_tuple) => {
-                    // Memory
-                    let vspace = size_tuple.0;
-                    let code = size_tuple.1;
-                    let data = size_tuple.2;
+            if let Ok(size_tuple) = readproc::get_ownprocess_mem() {
+                // Memory
+                let vspace = size_tuple.0;
+                let code = size_tuple.1;
+                let data = size_tuple.2;
 
-                    println!("My mem : {} (vspace), {} (code), {} (data)", vspace, code, data);
-                }
-                Err(_) => {}
+                println!("My mem : {} (vspace), {} (code), {} (data)", vspace, code, data);
             }
 
-            match readproc::get_last_created_command() {
-                Ok(last_command) => {
-                    // Last Process
-                    println!("Last process created in system was: {}", last_command);
-                }
-                Err(_) => {}
+            if let Ok(last_command) = readproc::get_last_created_command() {
+                // Last Process
+                println!("Last process created in system was: {}", last_command);
             }
 
 
-            match readproc::get_task_total() {
-                Ok(task_total) => {
-                    // Number of tasks
-                    println!("Total number of tasks: {}", task_total);
-                }
-                Err(_) => {}
+            if let Ok(task_total) = readproc::get_task_total() {
+                // Number of tasks
+                println!("Total number of tasks: {}", task_total);
             }
         }
 
@@ -67,7 +58,6 @@ fn main() {
             match args[1].parse::<i32>() {
                 Ok(pid) => {
                    if !pstree::print(pid) {
-                       println!("Invalid PID");
                        process::exit(1);
                    }
                 }

hw4/task1/src/pstree.rs

@@ -1,34 +1,75 @@
 use procinfo::pid;
+use std::os::unix::raw::pid_t;
 
+struct Process {
+    name : String,
+    pid : pid_t,
+    ppid : pid_t,
+}
 
-pub fn print(pid:i32) -> bool{
-    if let Err(_) = pid::stat(pid) {
-        return false
+impl Process {
+
+    fn new(with_pid:pid_t) -> Self {
+        if let Ok(stat) = pid::stat(with_pid) {
+            Process{name: stat.command, pid:stat.pid, ppid:stat.ppid}
+        } else {
+            Process{name: "".to_string(), pid:0, ppid:0}
+        }
     }
 
-    if let Ok(my_pid) = pid::stat_self() {
-        let mut output = "".to_string();
-        print_recursive(my_pid.pid, pid, &mut output);
-        println!("{}", output);
+    fn has_parent(&self) -> bool {
+        self.ppid != 0
     }
 
-    true
-}
+    fn parent(&self) -> Self {
+        Process::new(self.ppid)
+    }
 
-fn print_recursive(from_pid:i32, to_pid:i32, output: &mut String) {
-    if let Ok(stat) = pid::stat(from_pid) {
+    fn has_parent_with_pid(&self, pid: pid_t) -> bool {
+        let mut p = self;
+
+        if p.pid == pid {
+            return true
+        }
+
+        if p.has_parent() {
+            return p.parent().has_parent_with_pid(pid)
+        }
+        false
+    }
+
+    fn print_recursive(d, to_pid:pid_t, output: &mut String) {
 
         if output.len() == 0 {
-            *output = format!("{}({}){}", stat.command, stat.pid, output);
+            *output = format!("{}({}){}", from.name, from.pid, output);
         } else {
-            *output = format!("{}({})---{}", stat.command, stat.pid, output);
+            *output = format!("{}({})---{}", from.name, from.pid, output);
         }
 
-
-        if stat.ppid != 0 && stat.pid != to_pid {
-            print_recursive(stat.ppid, to_pid, output);
+        if from.has_parent() && from.pid != to_pid {
+            Process::print_recursive(&from.parent(), to_pid, output);
         }
     }
 }
 
+pub fn print(pid:pid_t) -> bool {
+    if let Err(_) = pid::stat(pid) {
+        println!("Invalid PID");
+        return false
+    }
 
+    if let Ok(my_pid) = pid::stat_self() {
+        let mut output = "".to_string();
+        let my_proc = Process::new(my_pid.pid);
+
+        if !my_proc.has_parent_with_pid(pid) {
+            println!("This Process has no parent {}", pid);
+            return false
+        }
+
+        Process::print_recursive(&my_proc,pid, &mut output);
+        println!("{}", output);
+    }
+
+    true
+}

hw4/task1/src/unit_test_pstree.rs

@@ -1,6 +1,7 @@
 #[cfg(test)]
 mod tests {
     #[test]
-    fn it_works() {
+    fn invalid_pid() {
+        assert_eq!()
     }
 }