admin/topgrade
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: unify the behavior of the steps that require sudo (#467)

Browse Source
This commit is contained in:
SteveLauC
2023-06-13 22:15:57 +08:00
committed by GitHub
parent a7ddf4575a
commit 30858780cf
11 changed files with 265 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/error.rs
View File

@@ -10,10 +10,6 @@ pub enum TopgradeError {
#[error("`{0}` failed: {1}")] #[error("`{0}` failed: {1}")]
ProcessFailedWithOutput(String, ExitStatus, String), ProcessFailedWithOutput(String, ExitStatus, String),
#[error("Sudo is required for this step")]
#[allow(dead_code)]
SudoRequired,
#[error("Unknown Linux Distribution")] #[error("Unknown Linux Distribution")]
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
UnknownLinuxDistribution, UnknownLinuxDistribution,

4
src/execution_context.rs
View File

@@ -2,7 +2,7 @@
use crate::executor::RunType; use crate::executor::RunType;
use crate::git::Git; use crate::git::Git;
use crate::sudo::Sudo; use crate::sudo::Sudo;
use crate::utils::require_option; use crate::utils::{require_option, REQUIRE_SUDO};
use crate::{config::Config, executor::Executor}; use crate::{config::Config, executor::Executor};
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
use std::path::Path; use std::path::Path;
@@ -31,7 +31,7 @@ impl<'a> ExecutionContext<'a> {
} }
pub fn execute_elevated(&self, command: &Path, interactive: bool) -> Result<Executor> { pub fn execute_elevated(&self, command: &Path, interactive: bool) -> Result<Executor> {
let sudo = require_option(self.sudo.clone(), "Sudo is required for this operation".into())?; let sudo = require_option(self.sudo.as_ref(), REQUIRE_SUDO.to_string())?;
Ok(sudo.execute_elevated(self, command, interactive)) Ok(sudo.execute_elevated(self, command, interactive))
} }

31
src/steps/generic.rs
View File

@@ -15,7 +15,7 @@ use crate::command::{CommandExt, Utf8Output};
use crate::execution_context::ExecutionContext; use crate::execution_context::ExecutionContext;
use crate::executor::ExecutorOutput; use crate::executor::ExecutorOutput;
use crate::terminal::{print_separator, shell}; use crate::terminal::{print_separator, shell};
use crate::utils::{self, require, require_option, which, PathExt}; use crate::utils::{self, require, require_option, which, PathExt, REQUIRE_SUDO};
use crate::Step; use crate::Step;
use crate::HOME_DIR; use crate::HOME_DIR;
use crate::{ use crate::{
@@ -112,7 +112,8 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
.execute(gem) .execute(gem)
.args(["update", "--system"]) .args(["update", "--system"])
.status_checked()?; .status_checked()?;
} else if let Some(sudo) = &ctx.sudo() { } else {
let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
if !Path::new("/usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb").exists() { if !Path::new("/usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb").exists() {
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
@@ -121,9 +122,8 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
.args(["update", "--system"]) .args(["update", "--system"])
.status_checked()?; .status_checked()?;
} }
} else {
print_warning("No sudo detected. Skipping system upgrade");
} }
Ok(()) Ok(())
} }
@@ -142,9 +142,8 @@ pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
let mut command = if directory_writable { let mut command = if directory_writable {
ctx.run_type().execute(&haxelib) ctx.run_type().execute(&haxelib)
} else { } else {
let mut c = ctx let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
.run_type() let mut c = ctx.run_type().execute(sudo);
.execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
c.arg(&haxelib); c.arg(&haxelib);
c c
}; };
@@ -310,9 +309,8 @@ pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
let mut command = if is_root_install { let mut command = if is_root_install {
ctx.run_type().execute(&vcpkg) ctx.run_type().execute(&vcpkg)
} else { } else {
let mut c = ctx let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
.run_type() let mut c = ctx.run_type().execute(sudo);
.execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
c.arg(&vcpkg); c.arg(&vcpkg);
c c
}; };
@@ -510,9 +508,8 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
let mut command = if directory_writable { let mut command = if directory_writable {
ctx.run_type().execute(&tlmgr) ctx.run_type().execute(&tlmgr)
} else { } else {
let mut c = ctx let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
.run_type() let mut c = ctx.run_type().execute(sudo);
.execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
c.arg(&tlmgr); c.arg(&tlmgr);
c c
}; };
@@ -592,8 +589,9 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
}; };
if has_update { if has_update {
let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type() ctx.run_type()
.execute(ctx.sudo().as_ref().unwrap()) .execute(sudo)
.arg(&composer) .arg(&composer)
.arg("self-update") .arg("self-update")
.status_checked()?; .status_checked()?;
@@ -676,14 +674,15 @@ pub fn run_helix_grammars(ctx: &ExecutionContext) -> Result<()> {
print_separator("Helix"); print_separator("Helix");
let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type() ctx.run_type()
.execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?) .execute(sudo)
.args(["helix", "--grammar", "fetch"]) .args(["helix", "--grammar", "fetch"])
.status_checked() .status_checked()
.with_context(|| "Failed to download helix grammars!")?; .with_context(|| "Failed to download helix grammars!")?;
ctx.run_type() ctx.run_type()
.execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?) .execute(sudo)
.args(["helix", "--grammar", "build"]) .args(["helix", "--grammar", "build"])
.status_checked() .status_checked()
.with_context(|| "Failed to build helix grammars!")?; .with_context(|| "Failed to build helix grammars!")?;

6
src/steps/node.rs
View File

@@ -4,7 +4,7 @@ use std::os::unix::fs::MetadataExt;
use std::path::PathBuf; use std::path::PathBuf;
use std::process::Command; use std::process::Command;
use crate::utils::require_option; use crate::utils::{require_option, REQUIRE_SUDO};
use crate::HOME_DIR; use crate::HOME_DIR;
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
@@ -92,7 +92,7 @@ impl NPM {
fn upgrade(&self, ctx: &ExecutionContext, use_sudo: bool) -> Result<()> { fn upgrade(&self, ctx: &ExecutionContext, use_sudo: bool) -> Result<()> {
let args = ["update", self.global_location_arg()]; let args = ["update", self.global_location_arg()];
if use_sudo { if use_sudo {
let sudo = require_option(ctx.sudo().clone(), String::from("sudo is not installed"))?; let sudo = require_option(ctx.sudo().clone(), REQUIRE_SUDO.to_string())?;
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
.arg(&self.command) .arg(&self.command)
@@ -156,7 +156,7 @@ impl Yarn {
let args = ["global", "upgrade"]; let args = ["global", "upgrade"];
if use_sudo { if use_sudo {
let sudo = require_option(ctx.sudo().clone(), String::from("sudo is not installed"))?; let sudo = require_option(ctx.sudo().clone(), REQUIRE_SUDO.to_string())?;
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
.arg(self.yarn.as_ref().unwrap_or(&self.command)) .arg(self.yarn.as_ref().unwrap_or(&self.command))

7
src/steps/os/dragonfly.rs
View File

@@ -1,12 +1,12 @@
use crate::command::CommandExt; use crate::command::CommandExt;
use crate::execution_context::ExecutionContext; use crate::execution_context::ExecutionContext;
use crate::terminal::print_separator; use crate::terminal::print_separator;
use crate::utils::require_option; use crate::utils::{require_option, REQUIRE_SUDO};
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
use std::process::Command; use std::process::Command;
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
print_separator("DragonFly BSD Packages"); print_separator("DragonFly BSD Packages");
ctx.execute(sudo) ctx.execute(sudo)
.args(["/usr/local/sbin/pkg", "upgrade"]) .args(["/usr/local/sbin/pkg", "upgrade"])
@@ -14,11 +14,10 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> { pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
println!(); println!();
Command::new(sudo) Command::new(sudo)
.args(["/usr/local/sbin/pkg", "audit", "-Fr"]) .args(["/usr/local/sbin/pkg", "audit", "-Fr"])
.status_checked()?; .status_checked()?;
}
Ok(()) Ok(())
} }

9
src/steps/os/freebsd.rs
View File

@@ -1,13 +1,13 @@
use crate::command::CommandExt; use crate::command::CommandExt;
use crate::execution_context::ExecutionContext; use crate::execution_context::ExecutionContext;
use crate::terminal::print_separator; use crate::terminal::print_separator;
use crate::utils::require_option; use crate::utils::{require_option, REQUIRE_SUDO};
use crate::Step; use crate::Step;
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
use std::process::Command; use std::process::Command;
pub fn upgrade_freebsd(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_freebsd(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
print_separator("FreeBSD Update"); print_separator("FreeBSD Update");
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
@@ -16,7 +16,7 @@ pub fn upgrade_freebsd(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
print_separator("FreeBSD Packages"); print_separator("FreeBSD Packages");
let mut command = ctx.run_type().execute(sudo); let mut command = ctx.run_type().execute(sudo);
@@ -29,11 +29,10 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> { pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
println!(); println!();
Command::new(sudo) Command::new(sudo)
.args(["/usr/sbin/pkg", "audit", "-Fr"]) .args(["/usr/sbin/pkg", "audit", "-Fr"])
.status_checked()?; .status_checked()?;
}
Ok(()) Ok(())
} }

94
src/steps/os/linux.rs
View File

@@ -9,8 +9,8 @@ use crate::command::CommandExt;
use crate::error::{SkipStep, TopgradeError}; use crate::error::{SkipStep, TopgradeError};
use crate::execution_context::ExecutionContext; use crate::execution_context::ExecutionContext;
use crate::steps::os::archlinux; use crate::steps::os::archlinux;
use crate::terminal::{print_separator, print_warning}; use crate::terminal::print_separator;
use crate::utils::{require, require_option, which, PathExt}; use crate::utils::{require, require_option, which, PathExt, REQUIRE_SUDO};
use crate::{Step, HOME_DIR}; use crate::{Step, HOME_DIR};
static OS_RELEASE_PATH: &str = "/etc/os-release"; static OS_RELEASE_PATH: &str = "/etc/os-release";
@@ -158,7 +158,7 @@ impl Distribution {
} }
fn update_bedrock(ctx: &ExecutionContext) -> Result<()> { fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("Sudo required"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type().execute(sudo).args(["brl", "update"]); ctx.run_type().execute(sudo).args(["brl", "update"]);
@@ -189,7 +189,7 @@ fn is_wsl() -> Result<bool> {
fn upgrade_alpine_linux(ctx: &ExecutionContext) -> Result<()> { fn upgrade_alpine_linux(ctx: &ExecutionContext) -> Result<()> {
let apk = require("apk")?; let apk = require("apk")?;
let sudo = ctx.sudo().as_ref().unwrap(); let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?; ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked() ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
@@ -204,7 +204,7 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
} }
}; };
if let Some(sudo) = &ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let mut command = ctx.run_type().execute(sudo); let mut command = ctx.run_type().execute(sudo);
command command
.arg(which("dnf").unwrap_or_else(|| Path::new("yum").to_path_buf())) .arg(which("dnf").unwrap_or_else(|| Path::new("yum").to_path_buf()))
@@ -223,9 +223,6 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
} }
command.status_checked()?; command.status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
@@ -238,17 +235,14 @@ fn upgrade_fedora_silverblue(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> { fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type().execute(sudo).args(["brl", "update"]).status_checked()?; ctx.run_type().execute(sudo).args(["brl", "update"]).status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> { fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
.args(["zypper", "refresh"]) .args(["zypper", "refresh"])
@@ -263,15 +257,12 @@ fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
"update" "update"
}) })
.status_checked()?; .status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
fn upgrade_opensuse_tumbleweed(ctx: &ExecutionContext) -> Result<()> { fn upgrade_opensuse_tumbleweed(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
.args(["zypper", "refresh"]) .args(["zypper", "refresh"])
@@ -282,28 +273,22 @@ fn upgrade_opensuse_tumbleweed(ctx: &ExecutionContext) -> Result<()> {
.arg("zypper") .arg("zypper")
.arg("dist-upgrade") .arg("dist-upgrade")
.status_checked()?; .status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> { fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
.args(["transactional-update", "dup"]) .args(["transactional-update", "dup"])
.status_checked()?; .status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> { fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = &ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let mut command = ctx.run_type().execute(sudo); let mut command = ctx.run_type().execute(sudo);
command.arg(&which("dnf").unwrap()).arg("upgrade"); command.arg(&which("dnf").unwrap()).arg("upgrade");
@@ -317,14 +302,11 @@ fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
} }
command.status_checked()?; command.status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> { fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = &ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let mut command_update = ctx.run_type().execute(sudo); let mut command_update = ctx.run_type().execute(sudo);
command_update.arg(&which("apt-get").unwrap()).arg("update"); command_update.arg(&which("apt-get").unwrap()).arg("update");
@@ -344,9 +326,6 @@ fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
.arg(&which("apt-get").unwrap()) .arg(&which("apt-get").unwrap())
.arg("dist-upgrade") .arg("dist-upgrade")
.status_checked()?; .status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
@@ -372,7 +351,7 @@ fn upgrade_vanilla(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_void(ctx: &ExecutionContext) -> Result<()> { fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let mut command = ctx.run_type().execute(sudo); let mut command = ctx.run_type().execute(sudo);
command.args(["xbps-install", "-Su", "xbps"]); command.args(["xbps-install", "-Su", "xbps"]);
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
@@ -386,9 +365,6 @@ fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
command.arg("-y"); command.arg("-y");
} }
command.status_checked()?; command.status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
@@ -396,7 +372,7 @@ fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> { fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
let run_type = ctx.run_type(); let run_type = ctx.run_type();
if let Some(sudo) = &ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
if let Some(layman) = which("layman") { if let Some(layman) = which("layman") {
run_type run_type
.execute(sudo) .execute(sudo)
@@ -431,9 +407,6 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
.unwrap_or_else(|| vec!["-uDNa", "--with-bdeps=y", "world"]), .unwrap_or_else(|| vec!["-uDNa", "--with-bdeps=y", "world"]),
) )
.status_checked()?; .status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
@@ -469,7 +442,7 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
return Ok(()); return Ok(());
} }
if let Some(sudo) = &ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
if !is_nala { if !is_nala {
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
@@ -503,9 +476,6 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
} }
command.status_checked()?; command.status_checked()?;
} }
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
@@ -526,14 +496,11 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> { fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
.args(["eopkg", "upgrade"]) .args(["eopkg", "upgrade"])
.status_checked()?; .status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
@@ -628,20 +595,17 @@ pub fn run_packer_nu(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> { fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = &ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
.args(["swupd", "update"]) .args(["swupd", "update"])
.status_checked()?; .status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> { fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
ctx.run_type().execute(sudo).args(["cave", "sync"]).status_checked()?; ctx.run_type().execute(sudo).args(["cave", "sync"]).status_checked()?;
ctx.run_type() ctx.run_type()
@@ -665,15 +629,12 @@ fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
.execute(sudo) .execute(sudo)
.args(["eclectic", "config", "interactive"]) .args(["eclectic", "config", "interactive"])
.status_checked()?; .status_checked()?;
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> { fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
if let Some(sudo) = ctx.sudo() { let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let mut command = ctx.run_type().execute(sudo); let mut command = ctx.run_type().execute(sudo);
command.args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"]); command.args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"]);
@@ -688,9 +649,6 @@ fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
.args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"]) .args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
.status_checked()?; .status_checked()?;
} }
} else {
print_warning("No sudo detected. Skipping system upgrade");
}
Ok(()) Ok(())
} }
@@ -701,7 +659,8 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
// in theory rpm based distributions use pkcon as well, though that // in theory rpm based distributions use pkcon as well, though that
// seems rare // seems rare
// if that comes up we need to create a Distribution::PackageKit or some such // if that comes up we need to create a Distribution::PackageKit or some such
if let Some(sudo) = &ctx.sudo() {
let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let pkcon = which("pkcon").unwrap(); let pkcon = which("pkcon").unwrap();
// pkcon ignores update with update and refresh provided together // pkcon ignores update with update and refresh provided together
ctx.run_type() ctx.run_type()
@@ -719,13 +678,12 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
} }
// from pkcon man, exit code 5 is 'Nothing useful was done.' // from pkcon man, exit code 5 is 'Nothing useful was done.'
cmd.status_checked_with_codes(&[5])?; cmd.status_checked_with_codes(&[5])?;
}
Ok(()) Ok(())
} }
pub fn run_needrestart(ctx: &ExecutionContext) -> Result<()> { pub fn run_needrestart(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let needrestart = require("needrestart")?; let needrestart = require("needrestart")?;
let distribution = Distribution::detect()?; let distribution = Distribution::detect()?;
@@ -769,7 +727,7 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> { pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> {
let flatpak = require("flatpak")?; let flatpak = require("flatpak")?;
let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let cleanup = ctx.config().cleanup(); let cleanup = ctx.config().cleanup();
let yes = ctx.config().yes(Step::Flatpak); let yes = ctx.config().yes(Step::Flatpak);
let run_type = ctx.run_type(); let run_type = ctx.run_type();
@@ -830,7 +788,7 @@ pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn run_snap(ctx: &ExecutionContext) -> Result<()> { pub fn run_snap(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let snap = require("snap")?; let snap = require("snap")?;
if !PathBuf::from("/var/snapd.socket").exists() && !PathBuf::from("/run/snapd.socket").exists() { if !PathBuf::from("/var/snapd.socket").exists() && !PathBuf::from("/run/snapd.socket").exists() {
@@ -842,7 +800,7 @@ pub fn run_snap(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn run_pihole_update(ctx: &ExecutionContext) -> Result<()> { pub fn run_pihole_update(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let pihole = require("pihole")?; let pihole = require("pihole")?;
Path::new("/opt/pihole/update.sh").require()?; Path::new("/opt/pihole/update.sh").require()?;
@@ -886,7 +844,7 @@ pub fn run_distrobox_update(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> { pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
let dkp_pacman = require("dkp-pacman")?; let dkp_pacman = require("dkp-pacman")?;
print_separator("Devkitpro pacman"); print_separator("Devkitpro pacman");
@@ -909,7 +867,7 @@ pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> { pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
if ctx.config().yes(Step::ConfigUpdate) { if ctx.config().yes(Step::ConfigUpdate) {
return Err(SkipStep("Skipped in --yes".to_string()).into()); return Err(SkipStep("Skipped in --yes".to_string()).into());
} }

4
src/steps/os/macos.rs
View File

@@ -1,6 +1,7 @@
use crate::command::CommandExt; use crate::command::CommandExt;
use crate::execution_context::ExecutionContext; use crate::execution_context::ExecutionContext;
use crate::terminal::{print_separator, prompt_yesno}; use crate::terminal::{print_separator, prompt_yesno};
use crate::utils::{require_option, REQUIRE_SUDO};
use crate::{utils::require, Step}; use crate::{utils::require, Step};
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
use std::fs; use std::fs;
@@ -9,7 +10,8 @@ use tracing::debug;
pub fn run_macports(ctx: &ExecutionContext) -> Result<()> { pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
require("port")?; require("port")?;
let sudo = ctx.sudo().as_ref().unwrap(); let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
print_separator("MacPorts"); print_separator("MacPorts");
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)

6
src/steps/os/openbsd.rs
View File

@@ -1,11 +1,11 @@
use crate::execution_context::ExecutionContext; use crate::execution_context::ExecutionContext;
use crate::terminal::print_separator; use crate::terminal::print_separator;
use crate::utils::require_option; use crate::utils::{require_option, REQUIRE_SUDO};
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
use std::path::PathBuf; use std::path::PathBuf;
pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
print_separator("OpenBSD Update"); print_separator("OpenBSD Update");
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)
@@ -14,7 +14,7 @@ pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?; let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
print_separator("OpenBSD Packages"); print_separator("OpenBSD Packages");
ctx.run_type() ctx.run_type()
.execute(sudo) .execute(sudo)

9
src/steps/os/unix.rs
View File

@@ -18,9 +18,7 @@ use crate::executor::Executor;
#[cfg(any(target_os = "linux", target_os = "macos"))] #[cfg(any(target_os = "linux", target_os = "macos"))]
use crate::executor::RunType; use crate::executor::RunType;
use crate::terminal::print_separator; use crate::terminal::print_separator;
#[cfg(not(any(target_os = "android", target_os = "macos")))] use crate::utils::{require, require_option, PathExt, REQUIRE_SUDO};
use crate::utils::require_option;
use crate::utils::{require, PathExt};
#[cfg(any(target_os = "linux", target_os = "macos"))] #[cfg(any(target_os = "linux", target_os = "macos"))]
const INTEL_BREW: &str = "/usr/local/bin/brew"; const INTEL_BREW: &str = "/usr/local/bin/brew";
@@ -173,17 +171,18 @@ pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> { pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
let pkgin = require("pkgin")?; let pkgin = require("pkgin")?;
let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
print_separator("Pkgin"); print_separator("Pkgin");
let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap()); let mut command = ctx.run_type().execute(sudo);
command.arg(&pkgin).arg("update"); command.arg(&pkgin).arg("update");
if ctx.config().yes(Step::Pkgin) { if ctx.config().yes(Step::Pkgin) {
command.arg("-y"); command.arg("-y");
} }
command.status_checked()?; command.status_checked()?;
let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap()); let mut command = ctx.run_type().execute(sudo);
command.arg(&pkgin).arg("upgrade"); command.arg(&pkgin).arg("upgrade");
if ctx.config().yes(Step::Pkgin) { if ctx.config().yes(Step::Pkgin) {
command.arg("-y"); command.arg("-y");

4
src/utils.rs
View File

@@ -213,3 +213,7 @@ pub mod merge_strategies {
} }
} }
} }
// Skip causes
// TODO: Put them in a better place when we have more of them
pub const REQUIRE_SUDO: &str = "Require sudo or counterpart but not found, skip";