Code cleanup : made each update tool into a function.

This commit is contained in:
Andrew Schott 2024-08-20 20:49:00 -05:00
parent 9a7c029754
commit e0bcfef2c3

View file

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