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

refactor: route sudo usage through Sudo::execute*

Browse Source
This commit is contained in:
Andre Toerien
2025-06-25 15:59:02 +02:00
committed by Gideon
parent 012a6bbde3
commit a95dd1e037
16 changed files with 303 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
locales/app.yml
View File

@@ -214,14 +214,6 @@ _version: 2
zh_CN: "正在跳过" zh_CN: "正在跳过"
zh_TW: "正在略過" zh_TW: "正在略過"
de: "Überspringe" de: "Überspringe"
"Aura(<0.4.6) requires sudo installed to work with AUR packages":
en: "Aura(<0.4.6) requires sudo installed to work with AUR packages"
lt: "Aura (<0.4.6) reikalauja sudo įdiegimo, kad galėtų naudoti AUR paketus"
es: "Aura(<0.4.6) requiere tener sudo instalado para funcionar con paquetes AUR"
fr: "Aura(<0.4.6) nécessite sudo pour fonctionner avec les paquets AUR"
zh_CN: "Aura(<0.4.6) 依赖 sudo 安装 AUR 软件包。"
zh_TW: "Aura（<0.4.6）依賴 sudo 安裝 AUR 套件"
de: "Aura(<0.4.6) benötigt sudo zur Verwendung von AUR-Paketen"
"Pacman backup configuration files found:": "Pacman backup configuration files found:":
en: "Pacman backup configuration files found:" en: "Pacman backup configuration files found:"
lt: "Rasti Pacman atsarginės konfigūracijos failai:" lt: "Rasti Pacman atsarginės konfigūracijos failai:"

26
src/execution_context.rs
View File

@@ -3,7 +3,6 @@ use color_eyre::eyre::Result;
use rust_i18n::t; use rust_i18n::t;
use std::env::var; use std::env::var;
use std::ffi::OsStr; use std::ffi::OsStr;
use std::path::Path;
use std::process::Command; use std::process::Command;
use std::sync::{LazyLock, Mutex}; use std::sync::{LazyLock, Mutex};
@@ -11,8 +10,8 @@ use crate::executor::DryCommand;
use crate::powershell::Powershell; use crate::powershell::Powershell;
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
use crate::steps::linux::Distribution; use crate::steps::linux::Distribution;
use crate::sudo::{Sudo, SudoExecuteOpts}; use crate::sudo::Sudo;
use crate::utils::{get_require_sudo_string, require_option}; use crate::utils::require_option;
use crate::{config::Config, executor::Executor}; use crate::{config::Config, executor::Executor};
/// An enum telling whether Topgrade should perform dry runs or actually perform the steps. /// An enum telling whether Topgrade should perform dry runs or actually perform the steps.
@@ -87,20 +86,6 @@ impl<'a> ExecutionContext<'a> {
} }
} }
/// Create an instance of `Executor` that should run `program`,
/// using sudo to elevate privileges.
pub fn execute_elevated(&self, command: &Path, interactive: bool) -> Result<Executor> {
let sudo = require_option(self.sudo.as_ref(), get_require_sudo_string())?;
sudo.execute_opts(
self,
command,
SudoExecuteOpts {
interactive,
..Default::default()
},
)
}
pub fn run_type(&self) -> RunType { pub fn run_type(&self) -> RunType {
self.run_type self.run_type
} }
@@ -109,6 +94,13 @@ impl<'a> ExecutionContext<'a> {
&self.sudo &self.sudo
} }
pub fn require_sudo(&self) -> Result<&Sudo> {
require_option(
self.sudo.as_ref(),
t!("Require sudo or counterpart but not found, skip").to_string(),
)
}
pub fn config(&self) -> &Config { pub fn config(&self) -> &Config {
self.config self.config
} }

3
src/main.rs
View File

@@ -232,7 +232,8 @@ fn run() -> Result<()> {
run_shell().context("Failed to execute shell")?; run_shell().context("Failed to execute shell")?;
} }
Ok(Key::Char('r' | 'R')) => { Ok(Key::Char('r' | 'R')) => {
reboot().context("Failed to reboot")?; println!("{}", t!("Rebooting..."));
reboot(&ctx).context("Failed to reboot")?;
} }
Ok(Key::Char('q' | 'Q')) => (), Ok(Key::Char('q' | 'Q')) => (),
_ => { _ => {

59
src/steps/generic.rs
View File

@@ -20,10 +20,9 @@ use crate::execution_context::ExecutionContext;
use crate::executor::ExecutorOutput; use crate::executor::ExecutorOutput;
use crate::output_changed_message; use crate::output_changed_message;
use crate::step::Step; use crate::step::Step;
use crate::sudo::SudoExecuteOpts;
use crate::terminal::{print_separator, shell}; use crate::terminal::{print_separator, shell};
use crate::utils::{ use crate::utils::{check_is_python_2_or_shim, require, require_one, require_option, which, PathExt};
check_is_python_2_or_shim, get_require_sudo_string, require, require_one, require_option, which, PathExt,
};
use crate::HOME_DIR; use crate::HOME_DIR;
use crate::{ use crate::{
error::{SkipStep, StepFailed, TopgradeError}, error::{SkipStep, StepFailed, TopgradeError},
@@ -126,13 +125,19 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
{ {
ctx.execute(gem).args(["update", "--system"]).status_checked()?; ctx.execute(gem).args(["update", "--system"]).status_checked()?;
} else { } else {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
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.execute(sudo) sudo.execute_opts(
.arg("-EH") ctx,
.arg(gem) &gem,
.args(["update", "--system"]) SudoExecuteOpts {
.status_checked()?; preserve_env: Some(&[]),
set_home: true,
..Default::default()
},
)?
.args(["update", "--system"])
.status_checked()?;
} }
} }
@@ -154,10 +159,8 @@ pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
let mut command = if directory_writable { let mut command = if directory_writable {
ctx.execute(&haxelib) ctx.execute(&haxelib)
} else { } else {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut c = ctx.execute(sudo); sudo.execute(ctx, &haxelib)?
c.arg(&haxelib);
c
}; };
command.arg("update").status_checked() command.arg("update").status_checked()
@@ -439,10 +442,8 @@ pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
let mut command = if is_root_install { let mut command = if is_root_install {
ctx.execute(&vcpkg) ctx.execute(&vcpkg)
} else { } else {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut c = ctx.execute(sudo); sudo.execute(ctx, &vcpkg)?
c.arg(&vcpkg);
c
}; };
command.args(["upgrade", "--no-dry-run"]).status_checked() command.args(["upgrade", "--no-dry-run"]).status_checked()
@@ -850,10 +851,8 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
let mut command = if directory_writable { let mut command = if directory_writable {
ctx.execute(&tlmgr) ctx.execute(&tlmgr)
} else { } else {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut c = ctx.execute(sudo); sudo.execute(ctx, &tlmgr)?
c.arg(&tlmgr);
c
}; };
command.args(["update", "--self", "--all"]); command.args(["update", "--self", "--all"]);
@@ -932,9 +931,8 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
}; };
if has_update { if has_update {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
ctx.execute(sudo) sudo.execute(ctx, &composer)?
.arg(&composer)
.arg("self-update") .arg("self-update")
.status_checked()?; .status_checked()?;
} }
@@ -1173,16 +1171,12 @@ pub fn run_bob(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn run_certbot(ctx: &ExecutionContext) -> Result<()> { pub fn run_certbot(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let certbot = require("certbot")?; let certbot = require("certbot")?;
print_separator("Certbot"); print_separator("Certbot");
let mut cmd = ctx.execute(sudo); sudo.execute(ctx, &certbot)?.arg("renew").status_checked()
cmd.arg(certbot);
cmd.arg("renew");
cmd.status_checked()
} }
/// Run `$ freshclam` to update ClamAV signature database /// Run `$ freshclam` to update ClamAV signature database
@@ -1223,10 +1217,9 @@ pub fn run_lensfun_update_data(ctx: &ExecutionContext) -> Result<()> {
const EXIT_CODE_WHEN_NO_UPDATE: i32 = 1; const EXIT_CODE_WHEN_NO_UPDATE: i32 = 1;
if ctx.config().lensfun_use_sudo() { if ctx.config().lensfun_use_sudo() {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
print_separator(SEPARATOR); print_separator(SEPARATOR);
ctx.execute(sudo) sudo.execute(ctx, &lensfun_update_data)?
.arg(lensfun_update_data)
// `lensfun-update-data` returns 1 when there is no update available // `lensfun-update-data` returns 1 when there is no update available
// which should be considered success // which should be considered success
.status_checked_with_codes(&[EXIT_CODE_WHEN_NO_UPDATE]) .status_checked_with_codes(&[EXIT_CODE_WHEN_NO_UPDATE])

13
src/steps/node.rs
View File

@@ -4,7 +4,6 @@ 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::{get_require_sudo_string, require_option};
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")]
@@ -93,8 +92,8 @@ 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(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
ctx.execute(sudo).arg(&self.command).args(args).status_checked()?; sudo.execute(ctx, &self.command)?.args(args).status_checked()?;
} else { } else {
ctx.execute(&self.command).args(args).status_checked()?; ctx.execute(&self.command).args(args).status_checked()?;
} }
@@ -153,11 +152,9 @@ impl Yarn {
let args = ["global", "upgrade"]; let args = ["global", "upgrade"];
if use_sudo { if use_sudo {
let sudo = require_option(ctx.sudo().clone(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
ctx.execute(sudo) let command = self.yarn.as_ref().unwrap_or(&self.command);
.arg(self.yarn.as_ref().unwrap_or(&self.command)) sudo.execute(ctx, command)?.args(args).status_checked()?;
.args(args)
.status_checked()?;
} else { } else {
ctx.execute(&self.command).args(args).status_checked()?; ctx.execute(&self.command).args(args).status_checked()?;
} }

29
src/steps/os/archlinux.rs
View File

@@ -11,7 +11,6 @@ use crate::command::CommandExt;
use crate::error::TopgradeError; use crate::error::TopgradeError;
use crate::execution_context::ExecutionContext; use crate::execution_context::ExecutionContext;
use crate::step::Step; use crate::step::Step;
use crate::utils::require_option;
use crate::utils::which; use crate::utils::which;
use crate::{config, output_changed_message}; use crate::{config, output_changed_message};
@@ -150,20 +149,17 @@ pub struct Pacman {
impl ArchPackageManager for Pacman { impl ArchPackageManager for Pacman {
fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> { fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), "sudo is required to run pacman".into())?; let sudo = ctx.require_sudo()?;
let mut command = ctx.execute(sudo); let mut command = sudo.execute(ctx, &self.executable)?;
command command.arg("-Syu").env("PATH", get_execution_path());
.arg(&self.executable)
.arg("-Syu")
.env("PATH", get_execution_path());
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
command.arg("--noconfirm"); command.arg("--noconfirm");
} }
command.status_checked()?; command.status_checked()?;
if ctx.config().cleanup() { if ctx.config().cleanup() {
let mut command = ctx.execute(sudo); let mut command = sudo.execute(ctx, &self.executable)?;
command.arg(&self.executable).arg("-Scc"); command.arg("-Scc");
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
command.arg("--noconfirm"); command.arg("--noconfirm");
} }
@@ -306,23 +302,18 @@ impl ArchPackageManager for Aura {
} }
cmd.status_checked()?; cmd.status_checked()?;
} else { } else {
let sudo = crate::utils::require_option( let sudo = ctx.require_sudo()?;
ctx.sudo().as_ref(),
t!("Aura(<0.4.6) requires sudo installed to work with AUR packages").to_string(),
)?;
let mut cmd = ctx.execute(sudo); let mut cmd = sudo.execute(ctx, &self.executable)?;
cmd.arg(&self.executable) cmd.arg("-Au")
.arg("-Au")
.args(ctx.config().aura_aur_arguments().split_whitespace()); .args(ctx.config().aura_aur_arguments().split_whitespace());
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
cmd.arg("--noconfirm"); cmd.arg("--noconfirm");
} }
cmd.status_checked()?; cmd.status_checked()?;
let mut cmd = ctx.execute(sudo); let mut cmd = sudo.execute(ctx, &self.executable)?;
cmd.arg(&self.executable) cmd.arg("-Syu")
.arg("-Syu")
.args(ctx.config().aura_pacman_arguments().split_whitespace()); .args(ctx.config().aura_pacman_arguments().split_whitespace());
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
cmd.arg("--noconfirm"); cmd.arg("--noconfirm");

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

@@ -2,15 +2,15 @@ use crate::command::CommandExt;
use crate::execution_context::ExecutionContext; use crate::execution_context::ExecutionContext;
use crate::step::Step; use crate::step::Step;
use crate::terminal::print_separator; use crate::terminal::print_separator;
use crate::utils::{get_require_sudo_string, require_option};
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
use std::process::Command; use rust_i18n::t;
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
print_separator(t!("DragonFly BSD Packages")); print_separator(t!("DragonFly BSD Packages"));
let mut cmd = ctx.execute(sudo);
cmd.args(["/usr/local/sbin/pkg", "upgrade"]); let mut cmd = sudo.execute(ctx, "/usr/local/sbin/pkg")?;
cmd.arg("upgrade");
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
cmd.arg("-y"); cmd.arg("-y");
} }
@@ -18,19 +18,19 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> { pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
print_separator(t!("DragonFly BSD Audit")); print_separator(t!("DragonFly BSD Audit"));
#[allow(clippy::disallowed_methods)] sudo.execute(ctx, "/usr/local/sbin/pkg")?
if !Command::new(sudo) .args(["audit", "-Fr"])
.args(["/usr/local/sbin/pkg", "audit", "-Fr"]) .status_checked_with(|status| {
.status()? if !status.success() {
.success() println!(
{ "{}",
println!(t!( t!("The package audit was successful, but vulnerable packages still remain on the system")
"The package audit was successful, but vulnerable packages still remain on the system" );
)); }
} Ok(())
Ok(()) })
} }

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

@@ -2,26 +2,23 @@ use crate::command::CommandExt;
use crate::execution_context::ExecutionContext; use crate::execution_context::ExecutionContext;
use crate::step::Step; use crate::step::Step;
use crate::terminal::print_separator; use crate::terminal::print_separator;
use crate::utils::{get_require_sudo_string, require_option};
use color_eyre::Result; use color_eyre::Result;
use rust_i18n::t; use rust_i18n::t;
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(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
print_separator(t!("FreeBSD Update")); print_separator(t!("FreeBSD Update"));
ctx.execute(sudo) sudo.execute(ctx, "/usr/sbin/freebsd-update")?
.args(["/usr/sbin/freebsd-update", "fetch", "install"]) .args(["fetch", "install"])
.status_checked() .status_checked()
} }
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
print_separator(t!("FreeBSD Packages")); print_separator(t!("FreeBSD Packages"));
let mut command = ctx.execute(sudo); let mut command = sudo.execute(ctx, "/usr/sbin/pkg")?;
command.arg("upgrade");
command.args(["/usr/sbin/pkg", "upgrade"]);
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
command.arg("-y"); command.arg("-y");
} }
@@ -29,12 +26,11 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> { pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
print_separator(t!("FreeBSD Audit")); print_separator(t!("FreeBSD Audit"));
Command::new(sudo) sudo.execute(ctx, "/usr/sbin/pkg")?
.args(["/usr/sbin/pkg", "audit", "-Fr"]) .args(["audit", "-Fr"])
.status_checked()?; .status_checked()
Ok(())
} }

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

@@ -12,8 +12,9 @@ use crate::execution_context::ExecutionContext;
use crate::step::Step; use crate::step::Step;
use crate::steps::generic::is_wsl; use crate::steps::generic::is_wsl;
use crate::steps::os::archlinux; use crate::steps::os::archlinux;
use crate::sudo::SudoExecuteOpts;
use crate::terminal::{print_separator, prompt_yesno}; use crate::terminal::{print_separator, prompt_yesno};
use crate::utils::{get_require_sudo_string, require, require_option, which, PathExt}; use crate::utils::{require, require_one, which, PathExt};
use crate::HOME_DIR; use crate::HOME_DIR;
static OS_RELEASE_PATH: &str = "/etc/os-release"; static OS_RELEASE_PATH: &str = "/etc/os-release";
@@ -175,11 +176,9 @@ impl Distribution {
} }
fn update_bedrock(ctx: &ExecutionContext) -> Result<()> { fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let brl = require("brl")?;
ctx.execute(sudo).args(["brl", "update"]); let output = Command::new(&brl).arg("list").output_checked_utf8()?;
let output = Command::new("brl").arg("list").output_checked_utf8()?;
debug!("brl list: {:?} {:?}", output.stdout, output.stderr); debug!("brl list: {:?} {:?}", output.stdout, output.stderr);
for distribution in output.stdout.trim().lines() { for distribution in output.stdout.trim().lines() {
@@ -199,34 +198,34 @@ fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_alpine_linux(ctx: &ExecutionContext) -> Result<()> { fn upgrade_alpine_linux(ctx: &ExecutionContext) -> Result<()> {
let sudo = ctx.require_sudo()?;
let apk = require("apk")?; let apk = require("apk")?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
ctx.execute(sudo).arg(&apk).arg("update").status_checked()?; sudo.execute(ctx, &apk)?.arg("update").status_checked()?;
ctx.execute(sudo).arg(&apk).arg("upgrade").status_checked() sudo.execute(ctx, &apk)?.arg("upgrade").status_checked()
} }
fn upgrade_chimera_linux(ctx: &ExecutionContext) -> Result<()> { fn upgrade_chimera_linux(ctx: &ExecutionContext) -> Result<()> {
let sudo = ctx.require_sudo()?;
let apk = require("apk")?; let apk = require("apk")?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
ctx.execute(sudo).arg(&apk).arg("update").status_checked()?; sudo.execute(ctx, &apk)?.arg("update").status_checked()?;
ctx.execute(sudo).arg(&apk).arg("upgrade").status_checked() sudo.execute(ctx, &apk)?.arg("upgrade").status_checked()
} }
fn upgrade_wolfi_linux(ctx: &ExecutionContext) -> Result<()> { fn upgrade_wolfi_linux(ctx: &ExecutionContext) -> Result<()> {
let sudo = ctx.require_sudo()?;
let apk = require("apk")?; let apk = require("apk")?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
ctx.execute(sudo).arg(&apk).arg("update").status_checked()?; sudo.execute(ctx, &apk)?.arg("update").status_checked()?;
ctx.execute(sudo).arg(&apk).arg("upgrade").status_checked() sudo.execute(ctx, &apk)?.arg("upgrade").status_checked()
} }
fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> { fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
if let Some(bootc) = which("bootc") { if let Some(bootc) = which("bootc") {
if ctx.config().bootc() { if ctx.config().bootc() {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
return ctx.execute(sudo).arg(&bootc).arg("upgrade").status_checked(); return sudo.execute(ctx, &bootc)?.arg("upgrade").status_checked();
} }
} }
@@ -238,15 +237,15 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
} }
}; };
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut command = ctx.execute(sudo); let dnf = require_one(["dnf", "yum"])?;
command
.arg(which("dnf").unwrap_or_else(|| Path::new("yum").to_path_buf())) let mut command = sudo.execute(ctx, &dnf)?;
.arg(if ctx.config().redhat_distro_sync() { command.arg(if ctx.config().redhat_distro_sync() {
"distro-sync" "distro-sync"
} else { } else {
"upgrade" "upgrade"
}); });
if let Some(args) = ctx.config().dnf_arguments() { if let Some(args) = ctx.config().dnf_arguments() {
command.args(args.split_whitespace()); command.args(args.split_whitespace());
@@ -261,11 +260,10 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_nobara(ctx: &ExecutionContext) -> Result<()> { fn upgrade_nobara(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let pkg_manager = require("dnf")?; let dnf = require("dnf")?;
let mut update_command = ctx.execute(sudo); let mut update_command = sudo.execute(ctx, &dnf)?;
update_command.arg(&pkg_manager);
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
update_command.arg("-y"); update_command.arg("-y");
@@ -281,8 +279,7 @@ fn upgrade_nobara(ctx: &ExecutionContext) -> Result<()> {
]); ]);
update_command.arg("--refresh").status_checked()?; update_command.arg("--refresh").status_checked()?;
let mut upgrade_command = ctx.execute(sudo); let mut upgrade_command = sudo.execute(ctx, &dnf)?;
upgrade_command.arg(&pkg_manager);
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
upgrade_command.arg("-y"); upgrade_command.arg("-y");
@@ -295,18 +292,18 @@ fn upgrade_nobara(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_nilrt(ctx: &ExecutionContext) -> Result<()> { fn upgrade_nilrt(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let opkg = require("opkg")?; let opkg = require("opkg")?;
ctx.execute(sudo).arg(&opkg).arg("update").status_checked()?; sudo.execute(ctx, &opkg)?.arg("update").status_checked()?;
ctx.execute(sudo).arg(&opkg).arg("upgrade").status_checked() sudo.execute(ctx, &opkg)?.arg("upgrade").status_checked()
} }
fn upgrade_fedora_immutable(ctx: &ExecutionContext) -> Result<()> { fn upgrade_fedora_immutable(ctx: &ExecutionContext) -> Result<()> {
if let Some(bootc) = which("bootc") { if let Some(bootc) = which("bootc") {
if ctx.config().bootc() { if ctx.config().bootc() {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
return ctx.execute(sudo).arg(&bootc).arg("upgrade").status_checked(); return sudo.execute(ctx, &bootc)?.arg("upgrade").status_checked();
} }
} }
@@ -318,18 +315,21 @@ fn upgrade_fedora_immutable(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> { fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
ctx.execute(sudo).args(["brl", "update"]).status_checked()?; let brl = require("brl")?;
sudo.execute(ctx, &brl)?.arg("update").status_checked()?;
Ok(()) Ok(())
} }
fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> { fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
ctx.execute(sudo).args(["zypper", "refresh"]).status_checked()?; let zypper = require("zypper")?;
let mut cmd = ctx.execute(sudo); sudo.execute(ctx, &zypper)?.arg("refresh").status_checked()?;
cmd.arg("zypper");
let mut cmd = sudo.execute(ctx, &zypper)?;
cmd.arg(if ctx.config().suse_dup() { cmd.arg(if ctx.config().suse_dup() {
"dist-upgrade" "dist-upgrade"
} else { } else {
@@ -345,11 +345,13 @@ fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_opensuse_tumbleweed(ctx: &ExecutionContext) -> Result<()> { fn upgrade_opensuse_tumbleweed(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
ctx.execute(sudo).args(["zypper", "refresh"]).status_checked()?; let zypper = require("zypper")?;
let mut cmd = ctx.execute(sudo); sudo.execute(ctx, &zypper)?.arg("refresh").status_checked()?;
cmd.args(["zypper", "dist-upgrade"]);
let mut cmd = sudo.execute(ctx, &zypper)?;
cmd.arg("dist-upgrade");
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
cmd.arg("-y"); cmd.arg("-y");
} }
@@ -360,9 +362,10 @@ fn upgrade_opensuse_tumbleweed(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> { fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut cmd = ctx.execute(sudo); let upd = require("transactional-update")?;
cmd.arg("transactional-update");
let mut cmd = sudo.execute(ctx, &upd)?;
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
cmd.arg("-n"); cmd.arg("-n");
} }
@@ -373,10 +376,12 @@ fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> { fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut command = ctx.execute(sudo); let dnf = require("dnf")?;
command.arg(which("dnf").unwrap()).arg("upgrade"); let mut command = sudo.execute(ctx, &dnf)?;
command.arg("upgrade");
if let Some(args) = ctx.config().dnf_arguments() { if let Some(args) = ctx.config().dnf_arguments() {
command.args(args.split_whitespace()); command.args(args.split_whitespace());
@@ -392,10 +397,12 @@ fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> { fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut command_update = ctx.execute(sudo); let apt_get = require("apt-get")?;
command_update.arg(which("apt-get").unwrap()).arg("update"); let mut command_update = sudo.execute(ctx, &apt_get)?;
command_update.arg("update");
if let Some(args) = ctx.config().dnf_arguments() { if let Some(args) = ctx.config().dnf_arguments() {
command_update.args(args.split_whitespace()); command_update.args(args.split_whitespace());
@@ -407,8 +414,7 @@ fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
command_update.status_checked()?; command_update.status_checked()?;
let mut cmd = ctx.execute(sudo); let mut cmd = sudo.execute(ctx, &apt_get)?;
cmd.arg(which("apt-get").unwrap());
cmd.arg("dist-upgrade"); cmd.arg("dist-upgrade");
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
cmd.arg("-y"); cmd.arg("-y");
@@ -439,16 +445,18 @@ fn upgrade_vanilla(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_void(ctx: &ExecutionContext) -> Result<()> { fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut command = ctx.execute(sudo); let xbps = require("xbps-install")?;
command.args(["xbps-install", "-Su", "xbps"]);
let mut command = sudo.execute(ctx, &xbps)?;
command.args(["-Su", "xbps"]);
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
command.arg("-y"); command.arg("-y");
} }
command.status_checked()?; command.status_checked()?;
let mut command = ctx.execute(sudo); let mut command = sudo.execute(ctx, &xbps)?;
command.args(["xbps-install", "-u"]); command.arg("-u");
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
command.arg("-y"); command.arg("-y");
} }
@@ -458,18 +466,20 @@ fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> { fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let emerge = require("emerge")?;
if let Some(layman) = which("layman") { if let Some(layman) = which("layman") {
ctx.execute(sudo).arg(layman).args(["-s", "ALL"]).status_checked()?; sudo.execute(ctx, &layman)?.args(["-s", "ALL"]).status_checked()?;
} }
println!("{}", t!("Syncing portage")); println!("{}", t!("Syncing portage"));
if let Some(ego) = which("ego") { if let Some(ego) = which("ego") {
// The Funtoo team doesn't reccomend running both ego sync and emerge --sync // The Funtoo team doesn't reccomend running both ego sync and emerge --sync
ctx.execute(sudo).arg(ego).arg("sync").status_checked()?; sudo.execute(ctx, &ego)?.arg("sync").status_checked()?;
} else { } else {
ctx.execute(sudo) sudo.execute(ctx, &emerge)?
.args(["emerge", "--sync"]) .arg("--sync")
.args( .args(
ctx.config() ctx.config()
.emerge_sync_flags() .emerge_sync_flags()
@@ -480,11 +490,10 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
} }
if let Some(eix_update) = which("eix-update") { if let Some(eix_update) = which("eix-update") {
ctx.execute(sudo).arg(eix_update).status_checked()?; sudo.execute(ctx, &eix_update)?.status_checked()?;
} }
ctx.execute(sudo) sudo.execute(ctx, &emerge)?
.arg("emerge")
.args( .args(
ctx.config() ctx.config()
.emerge_update_flags() .emerge_update_flags()
@@ -527,16 +536,14 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
return Ok(()); return Ok(());
} }
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
if !is_nala { if !is_nala {
ctx.execute(sudo) sudo.execute(ctx, &apt)?
.arg(&apt)
.arg("update") .arg("update")
.status_checked_with_codes(&[0, 100])?; .status_checked_with_codes(&[0, 100])?;
} }
let mut command = ctx.execute(sudo); let mut command = sudo.execute(ctx, &apt)?;
command.arg(&apt);
if is_nala { if is_nala {
command.arg("upgrade"); command.arg("upgrade");
} else { } else {
@@ -551,10 +558,10 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
command.status_checked()?; command.status_checked()?;
if ctx.config().cleanup() { if ctx.config().cleanup() {
ctx.execute(sudo).arg(&apt).arg("clean").status_checked()?; sudo.execute(ctx, &apt)?.arg("clean").status_checked()?;
let mut command = ctx.execute(sudo); let mut command = sudo.execute(ctx, &apt)?;
command.arg(&apt).arg("autoremove"); command.arg("autoremove");
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
command.arg("-y"); command.arg("-y");
} }
@@ -584,9 +591,10 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> { fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut cmd = ctx.execute(sudo); let eopkg = require("eopkg")?;
cmd.arg("eopkg");
let mut cmd = sudo.execute(ctx, &eopkg)?;
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
cmd.arg("-y"); cmd.arg("-y");
} }
@@ -689,9 +697,11 @@ pub fn run_packer_nu(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> { fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut cmd = ctx.execute(sudo); let swupd = require("swupd")?;
cmd.args(["swupd", "update"]);
let mut cmd = sudo.execute(ctx, &swupd)?;
cmd.arg("update");
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
cmd.arg("--assume=yes"); cmd.arg("--assume=yes");
} }
@@ -701,32 +711,36 @@ fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
} }
fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> { fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
ctx.execute(sudo).args(["cave", "sync"]).status_checked()?; let cave = require("cave")?;
let eclectic = require("eclectic")?;
ctx.execute(sudo) sudo.execute(ctx, &cave)?.arg("sync").status_checked()?;
.args(["cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
sudo.execute(ctx, &cave)?
.args(["resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
.status_checked()?; .status_checked()?;
if ctx.config().cleanup() { if ctx.config().cleanup() {
ctx.execute(sudo).args(["cave", "purge", "-x"]).status_checked()?; sudo.execute(ctx, &cave)?.args(["purge", "-x"]).status_checked()?;
} }
ctx.execute(sudo) sudo.execute(ctx, &cave)?
.args(["cave", "fix-linkage", "-x", "--", "-Cs"]) .args(["fix-linkage", "-x", "--", "-Cs"])
.status_checked()?; .status_checked()?;
ctx.execute(sudo) sudo.execute(ctx, &eclectic)?
.args(["eclectic", "config", "interactive"]) .args(["config", "interactive"])
.status_checked()?; .status_checked()?;
Ok(()) Ok(())
} }
fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> { fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let mut command = ctx.execute(sudo);
command.args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"]); let mut command = sudo.execute(ctx, "/run/current-system/sw/bin/nixos-rebuild")?;
command.args(["switch", "--upgrade"]);
if let Some(args) = ctx.config().nix_arguments() { if let Some(args) = ctx.config().nix_arguments() {
command.args(args.split_whitespace()); command.args(args.split_whitespace());
@@ -734,8 +748,8 @@ fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
command.status_checked()?; command.status_checked()?;
if ctx.config().cleanup() { if ctx.config().cleanup() {
ctx.execute(sudo) sudo.execute(ctx, "/run/current-system/sw/bin/nix-collect-garbage")?
.args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"]) .arg("-d")
.status_checked()?; .status_checked()?;
} }
@@ -749,12 +763,14 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
// 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
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let pkcon = which("pkcon").unwrap(); let pkcon = require("pkcon")?;
// pkcon ignores update with update and refresh provided together // pkcon ignores update with update and refresh provided together
ctx.execute(sudo).arg(&pkcon).arg("refresh").status_checked()?; sudo.execute(ctx, &pkcon)?.arg("refresh").status_checked()?;
let mut exe = ctx.execute(sudo);
let cmd = exe.arg(&pkcon).arg("update"); let mut exe = sudo.execute(ctx, &pkcon)?;
let cmd = exe.arg("update");
if ctx.config().yes(Step::System) { if ctx.config().yes(Step::System) {
cmd.arg("-y"); cmd.arg("-y");
} }
@@ -809,14 +825,14 @@ fn should_skip_needrestart() -> Result<()> {
} }
pub fn run_needrestart(ctx: &ExecutionContext) -> Result<()> { pub fn run_needrestart(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let needrestart = require("needrestart")?; let needrestart = require("needrestart")?;
should_skip_needrestart()?; should_skip_needrestart()?;
print_separator(t!("Check for needed restarts")); print_separator(t!("Check for needed restarts"));
ctx.execute(sudo).arg(needrestart).status_checked()?; sudo.execute(ctx, &needrestart)?.status_checked()?;
Ok(()) Ok(())
} }
@@ -846,8 +862,9 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> { pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> {
let sudo = ctx.require_sudo()?;
let flatpak = require("flatpak")?; let flatpak = require("flatpak")?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_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);
print_separator("Flatpak User Packages"); print_separator("Flatpak User Packages");
@@ -872,13 +889,13 @@ pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> {
if yes { if yes {
update_args.push("-y"); update_args.push("-y");
} }
ctx.execute(sudo).arg(&flatpak).args(&update_args).status_checked()?; sudo.execute(ctx, &flatpak)?.args(&update_args).status_checked()?;
if cleanup { if cleanup {
let mut cleanup_args = vec!["uninstall", "--system", "--unused"]; let mut cleanup_args = vec!["uninstall", "--system", "--unused"];
if yes { if yes {
cleanup_args.push("-y"); cleanup_args.push("-y");
} }
ctx.execute(sudo).arg(flatpak).args(&cleanup_args).status_checked()?; sudo.execute(ctx, &flatpak)?.args(&cleanup_args).status_checked()?;
} }
} else { } else {
let mut update_args = vec!["update", "--system"]; let mut update_args = vec!["update", "--system"];
@@ -899,7 +916,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(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
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() {
@@ -907,17 +924,17 @@ pub fn run_snap(ctx: &ExecutionContext) -> Result<()> {
} }
print_separator("snap"); print_separator("snap");
ctx.execute(sudo).arg(snap).arg("refresh").status_checked() sudo.execute(ctx, &snap)?.arg("refresh").status_checked()
} }
pub fn run_pihole_update(ctx: &ExecutionContext) -> Result<()> { pub fn run_pihole_update(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let pihole = require("pihole")?; let pihole = require("pihole")?;
Path::new("/opt/pihole/update.sh").require()?; Path::new("/opt/pihole/update.sh").require()?;
print_separator("pihole"); print_separator("pihole");
ctx.execute(sudo).arg(pihole).arg("-up").status_checked() sudo.execute(ctx, &pihole)?.arg("-up").status_checked()
} }
pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> { pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
@@ -960,36 +977,44 @@ 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(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let dkp_pacman = require("dkp-pacman")?; let dkp_pacman = require("dkp-pacman")?;
print_separator("Devkitpro pacman"); print_separator("Devkitpro pacman");
ctx.execute(sudo).arg(&dkp_pacman).arg("-Syu").status_checked()?; sudo.execute(ctx, &dkp_pacman)?.arg("-Syu").status_checked()?;
if ctx.config().cleanup() { if ctx.config().cleanup() {
ctx.execute(sudo).arg(&dkp_pacman).arg("-Scc").status_checked()?; sudo.execute(ctx, &dkp_pacman)?.arg("-Scc").status_checked()?;
} }
Ok(()) Ok(())
} }
pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> { pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
if ctx.config().yes(Step::ConfigUpdate) { if ctx.config().yes(Step::ConfigUpdate) {
return Err(SkipStep(t!("Skipped in --yes").to_string()).into()); return Err(SkipStep(t!("Skipped in --yes").to_string()).into());
} }
if let Ok(etc_update) = require("etc-update") { if let Ok(etc_update) = require("etc-update") {
print_separator(t!("Configuration update")); print_separator(t!("Configuration update"));
ctx.execute(sudo).arg(etc_update).status_checked()?; sudo.execute(ctx, etc_update)?.status_checked()?;
} else if let Ok(pacdiff) = require("pacdiff") { } else if let Ok(pacdiff) = require("pacdiff") {
if std::env::var("DIFFPROG").is_err() { if std::env::var("DIFFPROG").is_err() {
require("vim")?; require("vim")?;
} }
print_separator(t!("Configuration update")); print_separator(t!("Configuration update"));
ctx.execute_elevated(&pacdiff, false)?.status_checked()?; sudo.execute_opts(
ctx,
&pacdiff,
SudoExecuteOpts {
preserve_env: Some(&["DIFFPROG"]),
..Default::default()
},
)?
.status_checked()?;
} }
Ok(()) Ok(())
@@ -1012,8 +1037,9 @@ pub fn run_lure_update(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn run_waydroid(ctx: &ExecutionContext) -> Result<()> { pub fn run_waydroid(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let waydroid = require("waydroid")?; let waydroid = require("waydroid")?;
let status = ctx.execute(&waydroid).arg("status").output_checked_utf8()?; let status = ctx.execute(&waydroid).arg("status").output_checked_utf8()?;
// example output of `waydroid status`: // example output of `waydroid status`:
// //
@@ -1052,16 +1078,16 @@ pub fn run_waydroid(ctx: &ExecutionContext) -> Result<()> {
); );
} }
} }
ctx.execute(sudo).arg(&waydroid).arg("upgrade").status_checked() sudo.execute(ctx, &waydroid)?.arg("upgrade").status_checked()
} }
pub fn run_auto_cpufreq(ctx: &ExecutionContext) -> Result<()> { pub fn run_auto_cpufreq(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
let auto_cpu_freq = require("auto-cpufreq")?; let auto_cpu_freq = require("auto-cpufreq")?;
print_separator("auto-cpufreq"); print_separator("auto-cpufreq");
ctx.execute(sudo).arg(auto_cpu_freq).arg("--update").status_checked() sudo.execute(ctx, &auto_cpu_freq)?.arg("--update").status_checked()
} }
pub fn run_cinnamon_spices_updater(ctx: &ExecutionContext) -> Result<()> { pub fn run_cinnamon_spices_updater(ctx: &ExecutionContext) -> Result<()> {

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

@@ -3,7 +3,6 @@ use crate::execution_context::ExecutionContext;
use crate::step::Step; use crate::step::Step;
use crate::terminal::{print_separator, prompt_yesno}; use crate::terminal::{print_separator, prompt_yesno};
use crate::utils::require; use crate::utils::require;
use crate::utils::{get_require_sudo_string, require_option};
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
use rust_i18n::t; use rust_i18n::t;
use std::collections::HashSet; use std::collections::HashSet;
@@ -12,16 +11,16 @@ use std::process::Command;
use tracing::debug; use tracing::debug;
pub fn run_macports(ctx: &ExecutionContext) -> Result<()> { pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
require("port")?; let sudo = ctx.require_sudo()?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let port = require("port")?;
print_separator("MacPorts"); print_separator("MacPorts");
ctx.execute(sudo).args(["port", "selfupdate"]).status_checked()?; sudo.execute(ctx, &port)?.arg("selfupdate").status_checked()?;
ctx.execute(sudo) sudo.execute(ctx, &port)?
.args(["port", "-u", "upgrade", "outdated"]) .args(["-u", "upgrade", "outdated"])
.status_checked()?; .status_checked()?;
if ctx.config().cleanup() { if ctx.config().cleanup() {
ctx.execute(sudo).args(["port", "-N", "reclaim"]).status_checked()?; sudo.execute(ctx, &port)?.args(["-N", "reclaim"]).status_checked()?;
} }
Ok(()) Ok(())

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

@@ -1,7 +1,6 @@
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::{get_require_sudo_string, require_option};
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
use rust_i18n::t; use rust_i18n::t;
use std::fs; use std::fs;
@@ -18,7 +17,7 @@ fn is_openbsd_current(ctx: &ExecutionContext) -> Result<bool> {
} }
pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
print_separator(t!("OpenBSD Update")); print_separator(t!("OpenBSD Update"));
let is_current = is_openbsd_current(ctx)?; let is_current = is_openbsd_current(ctx)?;
@@ -28,17 +27,15 @@ pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
return Ok(()); return Ok(());
} }
let args = if is_current { if is_current {
vec!["/usr/sbin/sysupgrade", "-sn"] sudo.execute(ctx, "/usr/sbin/sysupgrade")?.arg("-sn").status_checked()
} else { } else {
vec!["/usr/sbin/syspatch"] sudo.execute(ctx, "/usr/sbin/syspatch")?.status_checked()
}; }
ctx.execute(sudo).args(&args).status_checked()
} }
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
print_separator(t!("OpenBSD Packages")); print_separator(t!("OpenBSD Packages"));
let is_current = is_openbsd_current(ctx)?; let is_current = is_openbsd_current(ctx)?;
@@ -49,17 +46,13 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
} }
if ctx.config().cleanup() { if ctx.config().cleanup() {
ctx.execute(sudo) sudo.execute(ctx, "/usr/sbin/pkg_delete")?.arg("-ac").status_checked()?;
.args(["/usr/sbin/pkg_delete", "-ac"])
.status_checked()?;
} }
let mut args = vec!["/usr/sbin/pkg_add", "-u"]; let mut command = sudo.execute(ctx, "/usr/sbin/pkg_add")?;
command.arg("-u");
if is_current { if is_current {
args.push("-Dsnap"); command.arg("-Dsnap");
} }
command.status_checked()
ctx.execute(sudo).args(&args).status_checked()?;
Ok(())
} }

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

@@ -1,5 +1,3 @@
use crate::command::CommandExt;
use crate::{output_changed_message, HOME_DIR};
use color_eyre::eyre::eyre; use color_eyre::eyre::eyre;
use color_eyre::eyre::Context; use color_eyre::eyre::Context;
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
@@ -20,6 +18,10 @@ use std::sync::LazyLock;
use std::{env::var, path::Path}; use std::{env::var, path::Path};
use tracing::{debug, warn}; use tracing::{debug, warn};
use crate::command::CommandExt;
use crate::sudo::SudoExecuteOpts;
use crate::{output_changed_message, HOME_DIR};
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
use super::linux::Distribution; use super::linux::Distribution;
use crate::error::SkipStep; use crate::error::SkipStep;
@@ -28,7 +30,7 @@ use crate::execution_context::ExecutionContext;
use crate::executor::Executor; use crate::executor::Executor;
use crate::step::Step; use crate::step::Step;
use crate::terminal::print_separator; use crate::terminal::print_separator;
use crate::utils::{get_require_sudo_string, require, require_option, PathExt}; 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";
@@ -197,20 +199,20 @@ pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
} }
pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> { pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
let sudo = ctx.require_sudo()?;
let pkgin = require("pkgin")?; let pkgin = require("pkgin")?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
print_separator("Pkgin"); print_separator("Pkgin");
let mut command = ctx.execute(sudo); let mut command = sudo.execute(ctx, &pkgin)?;
command.arg(&pkgin).arg("update"); command.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.execute(sudo); let mut command = sudo.execute(ctx, &pkgin)?;
command.arg(&pkgin).arg("upgrade"); command.arg("upgrade");
if ctx.config().yes(Step::Pkgin) { if ctx.config().yes(Step::Pkgin) {
command.arg("-y"); command.arg("-y");
} }
@@ -247,7 +249,7 @@ pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
#[cfg(not(any(target_os = "android", target_os = "macos")))] #[cfg(not(any(target_os = "android", target_os = "macos")))]
pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> { pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
let gdbus = require("gdbus")?; let gdbus = require("gdbus")?;
require_option( crate::utils::require_option(
var("XDG_CURRENT_DESKTOP").ok().filter(|p| p.contains("GNOME")), var("XDG_CURRENT_DESKTOP").ok().filter(|p| p.contains("GNOME")),
t!("Desktop does not appear to be GNOME").to_string(), t!("Desktop does not appear to be GNOME").to_string(),
)?; )?;
@@ -327,16 +329,19 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
let sudo_as_user = t!("sudo as user '{user}'", user = user.name); let sudo_as_user = t!("sudo as user '{user}'", user = user.name);
print_separator(format!("{} ({})", variant.step_title(), sudo_as_user)); print_separator(format!("{} ({})", variant.step_title(), sudo_as_user));
let sudo = crate::utils::require_option(ctx.sudo().as_ref(), crate::utils::get_require_sudo_string())?; let sudo = ctx.require_sudo()?;
ctx.execute(sudo) sudo.execute_opts(
.current_dir("/tmp") // brew needs a writable current directory ctx,
.args([ &binary_name,
"--set-home", SudoExecuteOpts {
&format!("--user={}", user.name), set_home: true,
&format!("{}", binary_name.to_string_lossy()), user: Some(&user.name),
"update", ..Default::default()
]) },
.status_checked()?; )?
.current_dir("/tmp") // brew needs a writable current directory
.arg("update")
.status_checked()?;
return Ok(()); return Ok(());
} }
} }
@@ -551,10 +556,18 @@ pub fn run_nix_self_upgrade(ctx: &ExecutionContext) -> Result<()> {
let nix_args = nix_args(); let nix_args = nix_args();
if multi_user { if multi_user {
ctx.execute_elevated(&nix, true)? let sudo = ctx.require_sudo()?;
.args(nix_args) sudo.execute_opts(
.arg("upgrade-nix") ctx,
.status_checked() &nix,
SudoExecuteOpts {
interactive: true,
..Default::default()
},
)?
.args(nix_args)
.arg("upgrade-nix")
.status_checked()
} else { } else {
ctx.execute(&nix).args(nix_args).arg("upgrade-nix").status_checked() ctx.execute(&nix).args(nix_args).arg("upgrade-nix").status_checked()
} }
@@ -897,8 +910,9 @@ pub fn run_maza(ctx: &ExecutionContext) -> Result<()> {
ctx.execute(maza).arg("update").status_checked() ctx.execute(maza).arg("update").status_checked()
} }
pub fn reboot() -> Result<()> { pub fn reboot(ctx: &ExecutionContext) -> Result<()> {
print!("{}", t!("Rebooting...")); match ctx.sudo() {
Some(sudo) => sudo.execute(ctx, "reboot")?.status_checked(),
Command::new("sudo").arg("reboot").status_checked() None => ctx.execute("reboot").status_checked(),
}
} }

16
src/steps/os/windows.rs
View File

@@ -20,11 +20,7 @@ pub fn run_chocolatey(ctx: &ExecutionContext) -> Result<()> {
print_separator("Chocolatey"); print_separator("Chocolatey");
let mut command = match ctx.sudo() { let mut command = match ctx.sudo() {
Some(sudo) => { Some(sudo) => sudo.execute(ctx, &choco)?,
let mut command = ctx.execute(sudo);
command.arg(choco);
command
}
None => ctx.execute(choco), None => ctx.execute(choco),
}; };
@@ -46,11 +42,7 @@ pub fn run_winget(ctx: &ExecutionContext) -> Result<()> {
let mut command = if ctx.config().winget_use_sudo() { let mut command = if ctx.config().winget_use_sudo() {
match ctx.sudo() { match ctx.sudo() {
Some(sudo) => { Some(sudo) => sudo.execute(ctx, &winget)?,
let mut command = ctx.execute(sudo);
command.arg(winget);
command
}
None => ctx.execute(winget), None => ctx.execute(winget),
} }
} else { } else {
@@ -242,10 +234,10 @@ pub fn microsoft_store(ctx: &ExecutionContext) -> Result<()> {
powershell.microsoft_store(ctx) powershell.microsoft_store(ctx)
} }
pub fn reboot() -> Result<()> { pub fn reboot(ctx: &ExecutionContext) -> Result<()> {
// If this works, it won't return, but if it doesn't work, it may return a useful error // If this works, it won't return, but if it doesn't work, it may return a useful error
// message. // message.
Command::new("shutdown").args(["/R", "/T", "0"]).status_checked() ctx.execute("shutdown.exe").args(["/R", "/T", "0"]).status_checked()
} }
pub fn insert_startup_scripts(git_repos: &mut RepoStep) -> Result<()> { pub fn insert_startup_scripts(git_repos: &mut RepoStep) -> Result<()> {

10
src/steps/powershell.rs
View File

@@ -75,12 +75,10 @@ impl Powershell {
/// Builds a "primary" powershell command (uses dry-run if required): /// Builds a "primary" powershell command (uses dry-run if required):
/// {powershell} -NoProfile -Command {cmd} /// {powershell} -NoProfile -Command {cmd}
fn build_command<'a>(&self, ctx: &'a ExecutionContext, cmd: &str, use_sudo: bool) -> Result<impl CommandExt + 'a> { fn build_command<'a>(&self, ctx: &'a ExecutionContext, cmd: &str, use_sudo: bool) -> Result<impl CommandExt + 'a> {
let mut command = if use_sudo && ctx.sudo().is_some() { // if use_sudo and sudo is available, use it, otherwise run directly
let mut cmd = ctx.execute(ctx.sudo().as_ref().unwrap()); let mut command = match ctx.sudo() {
cmd.arg(&self.path); Some(sudo) if use_sudo => sudo.execute(ctx, &self.path)?,
cmd _ => ctx.execute(&self.path),
} else {
ctx.execute(&self.path)
}; };
#[cfg(windows)] #[cfg(windows)]

16
src/sudo.rs
View File

@@ -1,4 +1,5 @@
use std::ffi::OsStr; use std::ffi::OsStr;
use std::path::Path;
use std::path::PathBuf; use std::path::PathBuf;
use color_eyre::eyre::Context; use color_eyre::eyre::Context;
@@ -69,6 +70,15 @@ impl Sudo {
which(kind.as_ref()).map(|path| Self { path, kind }) which(kind.as_ref()).map(|path| Self { path, kind })
} }
/// Gets the path to the `sudo` binary. Do not use this to execute `sudo` directly - either use
/// [`Sudo::elevate`], or if you need to specify arguments to `sudo`, use [`Sudo::elevate_opts`].
/// This way, sudo options can be specified generically and the actual arguments customized
/// depending on the sudo kind.
#[allow(unused)]
pub fn path(&self) -> &Path {
self.path.as_ref()
}
/// Elevate permissions with `sudo`. /// Elevate permissions with `sudo`.
/// ///
/// This helps prevent blocking `sudo` prompts from stopping the run in the middle of a /// This helps prevent blocking `sudo` prompts from stopping the run in the middle of a
@@ -278,9 +288,3 @@ pub enum SudoKind {
Run0, Run0,
Please, Please,
} }
impl AsRef<OsStr> for Sudo {
fn as_ref(&self) -> &OsStr {
self.path.as_ref()
}
}

6
src/utils.rs
View File

@@ -222,12 +222,6 @@ pub mod merge_strategies {
} }
} }
// Skip causes
// TODO: Put them in a better place when we have more of them
pub fn get_require_sudo_string() -> String {
t!("Require sudo or counterpart but not found, skip").to_string()
}
/// Return `Err(SkipStep)` if `python` is a Python 2 or shim. /// Return `Err(SkipStep)` if `python` is a Python 2 or shim.
/// ///
/// # Shim /// # Shim