From e0bcfef2c3ac2c757a6d1fbce4685c5c55f7e3ee Mon Sep 17 00:00:00 2001
From: Andrew Schott <andrew@schotty.com>
Date: Tue, 20 Aug 2024 20:49:00 -0500
Subject: [PATCH] Code cleanup : made each update tool into a function.

---
 osupdater/src/main.rs | 605 +++++++++++++++++++++++-------------------
 1 file changed, 330 insertions(+), 275 deletions(-)

diff --git a/osupdater/src/main.rs b/osupdater/src/main.rs
index 50a035f..306fd6c 100644
--- a/osupdater/src/main.rs
+++ b/osupdater/src/main.rs
@@ -2,7 +2,7 @@ use std::process::{Command, Stdio};
 use std::path::Path;
 use color_print::cprintln;
 //use std::io::{stdin,stdout,Write};
-use input_validation::{get_choice};
+//use input_validation::{get_choice};
 
 fn trim_newline(s: &mut String) {
     if s.ends_with('\n') {
@@ -13,280 +13,335 @@ fn trim_newline(s: &mut String) {
     }
 }
 
-fn main() {
-   {
-        //Clear termianl, and move cursor to 1,1 inside the terminal
-        print!("{esc}[2J{esc}[1;1H", esc = 27 as char);
+fn update_apt() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
 
-        // Tell user that we are going to start the update procedure
-        cprintln!("<bold><rev>osupdater : This tool will locate and run any package/container managers on your system.</rev></bold>\n");
-        cprintln!("<bold><rev>Looking for native package managers.</rev></bold>\n");
+    let find_apt = Command::new("which")
+        .arg("apt").stdout(Stdio::piped()).output().unwrap();
+    let mut apt_bin = String::from_utf8(find_apt.stdout).unwrap();
+    trim_newline(&mut apt_bin);
 
-        //Figure out if the program should ask if an update tool should be run
-        //let autoupdate_choices = vec!["Y","N"];
-        //let autoupdate_index = get_choice("Shall the application autorun each update tool?", &autoupdate_choices);
-        //println!("Selection was {}", autoupdate_choices[autoupdate_index]);
-
-        //Find if binaries exist and their location
-        let find_sudo = Command::new("which")
-            .arg("sudo").stdout(Stdio::piped()).output().unwrap();
-        let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
-        trim_newline(&mut sudo_bin);
-
-        let find_apt = Command::new("which")
-            .arg("apt").stdout(Stdio::piped()).output().unwrap();
-        let mut apt_bin = String::from_utf8(find_apt.stdout).unwrap();
-        trim_newline(&mut apt_bin);
-
-        let find_dnf5 = Command::new("which")
-        .arg("dnf5").stdout(Stdio::piped()).output().unwrap();
-        let mut dnf5_bin = String::from_utf8(find_dnf5.stdout).unwrap();
-        trim_newline(&mut dnf5_bin);
-
-        let find_dnf = Command::new("which")
-            .arg("dnf").stdout(Stdio::piped()).output().unwrap();
-        let mut dnf_bin = String::from_utf8(find_dnf.stdout).unwrap();
-        trim_newline(&mut dnf_bin);
-
-        let find_pacman = Command::new("which")
-            .arg("pacman").stdout(Stdio::piped()).output().unwrap();
-        let mut pacman_bin = String::from_utf8(find_pacman.stdout).unwrap();
-        trim_newline(&mut pacman_bin);
-
-        let find_urpmi = Command::new("which")
-            .arg("urpmi").stdout(Stdio::piped()).output().unwrap();
-        let mut urpmi_bin = String::from_utf8(find_urpmi.stdout).unwrap();
-        trim_newline(&mut urpmi_bin);
-
-        let find_zypper = Command::new("which")
-            .arg("zypper").stdout(Stdio::piped()).output().unwrap();
-        let mut zypper_bin = String::from_utf8(find_zypper.stdout).unwrap();
-        trim_newline(&mut zypper_bin);
-
-        let find_flatpak = Command::new("which")
-            .arg("flatpak").stdout(Stdio::piped()).output().unwrap();
-        let mut flatpak_bin = String::from_utf8(find_flatpak.stdout).unwrap();
-        trim_newline(&mut flatpak_bin);
-
-        let find_snap = Command::new("which")
-            .arg("snap").stdout(Stdio::piped()).output().unwrap();
-        let mut snap_bin = String::from_utf8(find_snap.stdout).unwrap();
-        trim_newline(&mut snap_bin);
-
-        let find_pip_review = Command::new("which")
-            .arg("pip-review").stdout(Stdio::piped()).output().unwrap();
-        let mut pip_review_bin = String::from_utf8(find_pip_review.stdout).unwrap();
-        trim_newline(&mut pip_review_bin);
-
-        let find_distrobox_upgrade = Command::new("which")
-            .arg("distrobox-upgrade").stdout(Stdio::piped()).output().unwrap();
-        let mut distrobox_upgrade_bin = String::from_utf8(find_distrobox_upgrade.stdout).unwrap();
-        trim_newline(&mut distrobox_upgrade_bin);
-
-        let find_podman = Command::new("which")
-            .arg("podman").stdout(Stdio::piped()).output().unwrap();
-        let mut podman_bin = String::from_utf8(find_podman.stdout).unwrap();
-        trim_newline(&mut podman_bin);
-
-        //apt
-        let path = Path::new(&apt_bin);
-        if path.exists(){
-            cprintln!("<bold><rev>Updating via: apt</rev></bold>");
-            let mut cmd =
-                Command::new(&sudo_bin)
-                .arg(&apt_bin).arg("update").arg("-y")
-                .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-                .spawn().unwrap();
-            let _output = cmd.wait();
-            let mut cmd =
-                Command::new(&sudo_bin)
-                .arg(&apt_bin).arg("upgrade").arg("-y")
-                .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-                .spawn().unwrap();
-            let _output = cmd.wait();
-        }
-
-        // dnf
-        let path = Path::new(&dnf_bin);
-        let path_dnf5 = Path::new(&dnf5_bin);
-
-        if path_dnf5.exists() {
-            cprintln!("<bold><rev>dnf found but skipped since dnf5 is present</rev></bold>")
-        } else if path.exists(){
-            cprintln!("<bold><rev>Updating via: dnf</rev></bold>");
-            let mut cmd =
-                Command::new(&sudo_bin)
-                .arg(&dnf_bin).arg("--refresh").arg("--skip-broken").arg("--nobest").arg("-y").arg("update")
-                .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-                .spawn().unwrap();
-            let _output = cmd.wait();
-        }
-
-        // dnf5
-        let path = Path::new(&dnf5_bin);
-        if path.exists(){
-            cprintln!("<bold><rev>Updating via: dnf5</rev></bold>");
-            let mut cmd =
-                Command::new(&sudo_bin)
-                .arg(&dnf5_bin).arg("--refresh").arg("--nobest").arg("-y").arg("update")
-                .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-                .spawn().unwrap();
-            let _output = cmd.wait();
-        }
-
-        // pacman
-        let path = Path::new(&pacman_bin);
-        if path.exists(){
-            cprintln!("<bold><rev>Updating via: pacman</rev></bold>");
-            let mut cmd =
-                Command::new(&sudo_bin)
-                .arg(&pacman_bin).arg("-Syu")
-                .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-                .spawn().unwrap();
-            let _output = cmd.wait();
-        }
-
-        // urpmi
-        let path = Path::new(&urpmi_bin);
-        if path.exists(){
-            cprintln!("<bold><rev>Updating via urpmi</rev></bold>");
-            let mut cmd =
-                Command::new(&sudo_bin)
-                .arg(&urpmi_bin).arg("--auto-update").arg("-y")
-                .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-                .spawn().unwrap();
-                let _output = cmd.wait();
-        }
-
-        // zypper
-        let path = Path::new(&zypper_bin);
-        if path.exists(){
-            cprintln!("<bold><rev>Updating via: zypper</rev></bold>");
-            let mut cmd =
-                Command::new(&sudo_bin)
-                .arg(&zypper_bin).arg("up").arg("-y")
-                .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-                .spawn().unwrap();
-            let _output = cmd.wait();
-        }
-
-       // Check container formats
-       cprintln!("<bold><rev>Checking application containers</rev></bold>");
-
-       // flatpak
-       let path = Path::new(&flatpak_bin);
-       if path.exists(){
-           cprintln!("<bold><rev>Updating user flatpak installs</rev></bold>");
-           let mut cmd =
-               Command::new(&flatpak_bin)
-               .arg("update").arg("--user").arg("-y")
-               .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-               .spawn().unwrap();
-           let _output = cmd.wait();
-       }
-       let path = Path::new(&flatpak_bin);
-       if path.exists(){
-           cprintln!("<bold><rev>Updating system flatpak installs</rev></bold>");
-           let mut cmd =
-               Command::new(&sudo_bin)
-               .arg(&flatpak_bin).arg("update").arg("-y")
-               .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-               .spawn().unwrap();
-           let _output = cmd.wait();
-       }
-
-       // snap
-       let path = Path::new(&snap_bin);
-       if path.exists(){
-           cprintln!("<bold><rev>Updating user snap installation</rev></bold>");
-           let mut cmd =
-               Command::new(&snap_bin)
-               .arg("refresh").arg("-y")
-               .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-               .spawn().unwrap();
-           let _output = cmd.wait();
-       }
-       let path = Path::new(&snap_bin);
-       if path.exists(){
-           cprintln!("<bold><rev>Updating system snap installation</rev></bold>");
-           let mut cmd =
-               Command::new(&sudo_bin)
-               .arg(&snap_bin).arg("refresh").arg("-y")
-               .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-               .spawn().unwrap();
-           let _output = cmd.wait();
-       }
-
-       //Python
-       let path = Path::new(&pip_review_bin);
-       if path.exists(){
-           cprintln!("<bold><rev>Updating Python user installation via pip-review</rev></bold>");
-           let mut cmd =
-               Command::new(&pip_review_bin)
-               .arg("--auto").arg("--local").arg("--user")
-               .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-               .spawn().unwrap();
-           let _output = cmd.wait();
-       }
-
-       //Distrobox
-       let path = Path::new(&distrobox_upgrade_bin);
-       if path.exists(){
-           cprintln!("<bold><rev>Updating Distrobox containers</rev></bold>");
-           let mut cmd =
-               Command::new(&distrobox_upgrade_bin)
-               .arg("--all")
-               .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-               .spawn().unwrap();
-           let _output = cmd.wait();
-       }
-
-       //Podman system
-       let path = Path::new(&podman_bin);
-       if path.exists(){
-           cprintln!("<bold><rev>Updating Podman system containers</rev></bold>");
-           let mut cmd =
-               Command::new(&sudo_bin)
-               .arg(&podman_bin).arg("auto-update")
-               .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-               .spawn().unwrap();
-           let _output = cmd.wait();
-       }
-
-        //Podman user
-        let path = Path::new(&podman_bin);
-        if path.exists(){
-            cprintln!("<bold><rev>Updating Podman user containers</rev></bold>");
-            let mut cmd =
-                Command::new(&podman_bin)
-                .arg("auto-update")
-                .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-                .spawn().unwrap();
-            let _output = cmd.wait();
-        }
-
-        //Podman system prune
-        let path = Path::new(&podman_bin);
-        if path.exists(){
-            cprintln!("<bold><rev>Pruning Podman system containers</rev></bold>");
-            let mut cmd =
-                Command::new(&sudo_bin)
-                .arg(&podman_bin).arg("system").arg("prune").arg("-af")
-                .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-                .spawn().unwrap();
-            let _output = cmd.wait();
-        }
-
-       //Podman user prune
-       let path = Path::new(&podman_bin);
-       if path.exists(){
-           cprintln!("<bold><rev>Pruning Podman user containers</rev></bold>");
-           let mut cmd =
-               Command::new(&podman_bin)
-               .arg("system").arg("prune").arg("-af")
-               .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-               .spawn().unwrap();
-           let _output = cmd.wait();
-       }
-   }
+    let path = Path::new(&apt_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating via: apt</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&apt_bin).arg("update").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&apt_bin).arg("upgrade").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
+fn update_dnf() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_dnf5 = Command::new("which")
+    .arg("dnf5").stdout(Stdio::piped()).output().unwrap();
+    let mut dnf5_bin = String::from_utf8(find_dnf5.stdout).unwrap();
+    trim_newline(&mut dnf5_bin);
+
+    let find_dnf = Command::new("which")
+        .arg("dnf").stdout(Stdio::piped()).output().unwrap();
+    let mut dnf_bin = String::from_utf8(find_dnf.stdout).unwrap();
+    trim_newline(&mut dnf_bin);
+
+    let path_dnf = Path::new(&dnf_bin);
+    let path_dnf5 = Path::new(&dnf5_bin);
+
+    if path_dnf5.exists() {
+        cprintln!("<bold><rev>dnf found but skipped since dnf5 is present</rev></bold>");
+        cprintln!("<bold><rev>Updating via: dnf5</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&dnf5_bin).arg("--refresh").arg("--nobest").arg("-y").arg("update")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    } else if path_dnf.exists(){
+        cprintln!("<bold><rev>Updating via: dnf</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&dnf_bin).arg("--refresh").arg("--skip-broken").arg("--nobest").arg("-y").arg("update")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+
+}
+
+fn update_pacman() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_pacman = Command::new("which")
+        .arg("pacman").stdout(Stdio::piped()).output().unwrap();
+    let mut pacman_bin = String::from_utf8(find_pacman.stdout).unwrap();
+    trim_newline(&mut pacman_bin);
+
+    let path = Path::new(&pacman_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating via: pacman</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&pacman_bin).arg("-Syu")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+
+}
+
+fn update_urpmi() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_urpmi = Command::new("which")
+        .arg("urpmi").stdout(Stdio::piped()).output().unwrap();
+    let mut urpmi_bin = String::from_utf8(find_urpmi.stdout).unwrap();
+    trim_newline(&mut urpmi_bin);
+
+    let path = Path::new(&urpmi_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating via urpmi</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&urpmi_bin).arg("--auto-update").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+            let _output = cmd.wait();
+    }
+}
+
+fn update_zypper() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_zypper = Command::new("which")
+        .arg("zypper").stdout(Stdio::piped()).output().unwrap();
+    let mut zypper_bin = String::from_utf8(find_zypper.stdout).unwrap();
+    trim_newline(&mut zypper_bin);
+
+    let path = Path::new(&zypper_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating via: zypper</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&zypper_bin).arg("up").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
+fn update_flatpak() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_flatpak = Command::new("which")
+        .arg("flatpak").stdout(Stdio::piped()).output().unwrap();
+    let mut flatpak_bin = String::from_utf8(find_flatpak.stdout).unwrap();
+    trim_newline(&mut flatpak_bin);
+
+    let path = Path::new(&flatpak_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating user flatpak installs</rev></bold>");
+        let mut cmd =
+            Command::new(&flatpak_bin)
+            .arg("update").arg("--user").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+    let path = Path::new(&flatpak_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating system flatpak installs</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&flatpak_bin).arg("update").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
+fn update_snap() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_snap = Command::new("which")
+        .arg("snap").stdout(Stdio::piped()).output().unwrap();
+    let mut snap_bin = String::from_utf8(find_snap.stdout).unwrap();
+    trim_newline(&mut snap_bin);
+
+    let path = Path::new(&snap_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating user snap installation</rev></bold>");
+        let mut cmd =
+            Command::new(&snap_bin)
+            .arg("refresh").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+    let path = Path::new(&snap_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating system snap installation</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&snap_bin).arg("refresh").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
+fn update_python() {
+    let find_pip_review = Command::new("which")
+        .arg("pip-review").stdout(Stdio::piped()).output().unwrap();
+    let mut pip_review_bin = String::from_utf8(find_pip_review.stdout).unwrap();
+    trim_newline(&mut pip_review_bin);
+
+    let path = Path::new(&pip_review_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating Python user installation via pip-review</rev></bold>");
+        let mut cmd =
+            Command::new(&pip_review_bin)
+            .arg("--auto").arg("--local").arg("--user")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
+fn update_distrobox() {
+    let find_distrobox_upgrade = Command::new("which")
+        .arg("distrobox-upgrade").stdout(Stdio::piped()).output().unwrap();
+    let mut distrobox_upgrade_bin = String::from_utf8(find_distrobox_upgrade.stdout).unwrap();
+    trim_newline(&mut distrobox_upgrade_bin);
+
+    let path = Path::new(&distrobox_upgrade_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating Distrobox containers</rev></bold>");
+        let mut cmd =
+            Command::new(&distrobox_upgrade_bin)
+            .arg("--all")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
+fn update_podman() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_podman = Command::new("which")
+        .arg("podman").stdout(Stdio::piped()).output().unwrap();
+    let mut podman_bin = String::from_utf8(find_podman.stdout).unwrap();
+    trim_newline(&mut podman_bin);
+
+    let path = Path::new(&podman_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>Updating Podman system containers</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&podman_bin).arg("auto-update")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+
+    if path.exists(){
+         cprintln!("<bold><rev>Updating Podman user containers</rev></bold>");
+         let mut cmd =
+             Command::new(&podman_bin)
+             .arg("auto-update")
+             .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+             .spawn().unwrap();
+         let _output = cmd.wait();
+     }
+
+     if path.exists(){
+         cprintln!("<bold><rev>Pruning Podman system containers</rev></bold>");
+         let mut cmd =
+             Command::new(&sudo_bin)
+             .arg(&podman_bin).arg("system").arg("prune").arg("-af")
+             .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+             .spawn().unwrap();
+         let _output = cmd.wait();
+     }
+
+    if path.exists(){
+        cprintln!("<bold><rev>Pruning Podman user containers</rev></bold>");
+        let mut cmd =
+            Command::new(&podman_bin)
+            .arg("system").arg("prune").arg("-af")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
+fn main() {
+    //Clear termianl, and move cursor to 1,1 inside the terminal
+    print!("{esc}[2J{esc}[1;1H", esc = 27 as char);
+    // Tell user that we are going to start the update procedure
+    cprintln!("<bold><rev>osupdater : This tool will locate and run any package/container managers on your system.</rev></bold>\n");
+
+    //Figure out if the program should ask if an update tool should be run
+    //let autoupdate_choices = vec!["Y","N"];
+    //let autoupdate_index = get_choice("Shall the application autorun each update tool?", &autoupdate_choices);
+    //println!("Selection was {}", autoupdate_choices[autoupdate_index]);
+
+    // Find sudo
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    // Check package managers
+    cprintln!("<bold><rev>Looking for native package managers.</rev></bold>\n");
+    update_apt();
+    update_dnf();
+    update_pacman();
+    update_urpmi();
+    update_zypper();
+
+    // Check container formats
+    cprintln!("<bold><rev>Checking application containers</rev></bold>");
+    update_flatpak();
+    update_snap();
+    update_python();
+    update_distrobox();
+    update_podman();
 }