Made main safer. Wrote pstree.rs. Created test.

hw4/task1/src/main.rs

@@ -1,36 +1,91 @@
 extern crate procinfo;
 
+use std::env;
+use std::process;
+
 mod readproc;
 mod pstree;
 
 fn main() {
 
-    // PID and PPID
-    let pid_tuple = readproc::self_pids().unwrap();
-    let pid = pid_tuple.0;
-    let ppid = pid_tuple.1;
+    let args:Vec<String> = env::args().collect();
+
+    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);
+                }
+                Err(_) => {}
+            }
+
+
+            match readproc::get_ownprocess_mem() {
+                Ok(size_tuple) => {
+                    // 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(_) => {}
+            }
+
+            match readproc::get_last_created_command() {
+                Ok(last_command) => {
+                    // Last Process
+                    println!("Last process created in system was: {}", last_command);
+                }
+                Err(_) => {}
+            }
+
+
+            match readproc::get_task_total() {
+                Ok(task_total) => {
+                    // Number of tasks
+                    println!("Total number of tasks: {}", task_total);
+                }
+                Err(_) => {}
+            }
+        }
+
+        2 => {
+            match args[1].parse::<i32>() {
+                Ok(pid) => {
+                   if !pstree::print(pid) {
+                       println!("Invalid PID");
+                       process::exit(1);
+                   }
+                }
+                Err(_) => {
+                    println!("Error while parsing PID");
+                    process::exit(1);
+                }
+            }
+        }
 
-    // Commands
-    let pid_command = readproc::get_pid_command(pid).unwrap();
-    let ppid_command = readproc::get_pid_command(ppid).unwrap();
+        _ => {
+            println!("Correct usage: no param or param PID");
+            process::exit(1);
+        }
+    }
 
-    // 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);
 
-    // Memory
-    let vspace = readproc::get_ownprocess_mem().unwrap().0;
-    let code = readproc::get_ownprocess_mem().unwrap().1;
-    let data = readproc::get_ownprocess_mem().unwrap().2;
-    println!("My mem : {} (vspace), {} (code), {} (data)", vspace, code, data);
 
-    // Last Process
-    println!("Last process created in system was: {}", readproc::get_last_created_command().unwrap());
 
-    // Number of tasks
-    println!("Total number of tasks: {}", readproc::get_task_total().unwrap());
 }

hw4/task1/src/pstree.rs

@@ -0,0 +1,34 @@
+use procinfo::pid;
+
+
+pub fn print(pid:i32) -> bool{
+    if let Err(_) = pid::stat(pid) {
+        return false
+    }
+
+    if let Ok(my_pid) = pid::stat_self() {
+        let mut output = "".to_string();
+        print_recursive(my_pid.pid, pid, &mut output);
+        println!("{}", output);
+    }
+
+    true
+}
+
+fn print_recursive(from_pid:i32, to_pid:i32, output: &mut String) {
+    if let Ok(stat) = pid::stat(from_pid) {
+
+        if output.len() == 0 {
+            *output = format!("{}({}){}", stat.command, stat.pid, output);
+        } else {
+            *output = format!("{}({})---{}", stat.command, stat.pid, output);
+        }
+
+
+        if stat.ppid != 0 && stat.pid != to_pid {
+            print_recursive(stat.ppid, to_pid, output);
+        }
+    }
+}
+
+

hw4/task1/src/unit_test_pstree.rs

@@ -0,0 +1,6 @@
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+    }
+}