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_TW: "正在略過"
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:":
en: "Pacman backup configuration files found:"
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 std::env::var;
use std::ffi::OsStr;
use std::path::Path;
use std::process::Command;
use std::sync::{LazyLock, Mutex};
@@ -11,8 +10,8 @@ use crate::executor::DryCommand;
use crate::powershell::Powershell;
#[cfg(target_os = "linux")]
use crate::steps::linux::Distribution;
use crate::sudo::{Sudo, SudoExecuteOpts};
use crate::utils::{get_require_sudo_string, require_option};
use crate::sudo::Sudo;
use crate::utils::require_option;
use crate::{config::Config, executor::Executor};
/// 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 {
self.run_type
}
@@ -109,6 +94,13 @@ impl<'a> ExecutionContext<'a> {
&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 {
self.config
}

3
src/main.rs
View File

@@ -232,7 +232,8 @@ fn run() -> Result<()> {
run_shell().context("Failed to execute shell")?;
}
Ok(Key::Char('r' | 'R')) => {
reboot().context("Failed to reboot")?;
println!("{}", t!("Rebooting..."));
reboot(&ctx).context("Failed to reboot")?;
}
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::output_changed_message;
use crate::step::Step;
use crate::sudo::SudoExecuteOpts;
use crate::terminal::{print_separator, shell};
use crate::utils::{
check_is_python_2_or_shim, get_require_sudo_string, require, require_one, require_option, which, PathExt,
};
use crate::utils::{check_is_python_2_or_shim, require, require_one, require_option, which, PathExt};
use crate::HOME_DIR;
use crate::{
error::{SkipStep, StepFailed, TopgradeError},
@@ -126,13 +125,19 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
{
ctx.execute(gem).args(["update", "--system"]).status_checked()?;
} 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() {
ctx.execute(sudo)
.arg("-EH")
.arg(gem)
.args(["update", "--system"])
.status_checked()?;
sudo.execute_opts(
ctx,
&gem,
SudoExecuteOpts {
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 {
ctx.execute(&haxelib)
} else {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
let mut c = ctx.execute(sudo);
c.arg(&haxelib);
c
let sudo = ctx.require_sudo()?;
sudo.execute(ctx, &haxelib)?
};
command.arg("update").status_checked()
@@ -439,10 +442,8 @@ pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
let mut command = if is_root_install {
ctx.execute(&vcpkg)
} else {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
let mut c = ctx.execute(sudo);
c.arg(&vcpkg);
c
let sudo = ctx.require_sudo()?;
sudo.execute(ctx, &vcpkg)?
};
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 {
ctx.execute(&tlmgr)
} else {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
let mut c = ctx.execute(sudo);
c.arg(&tlmgr);
c
let sudo = ctx.require_sudo()?;
sudo.execute(ctx, &tlmgr)?
};
command.args(["update", "--self", "--all"]);
@@ -932,9 +931,8 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
};
if has_update {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
ctx.execute(sudo)
.arg(&composer)
let sudo = ctx.require_sudo()?;
sudo.execute(ctx, &composer)?
.arg("self-update")
.status_checked()?;
}
@@ -1173,16 +1171,12 @@ pub fn run_bob(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")?;
print_separator("Certbot");
let mut cmd = ctx.execute(sudo);
cmd.arg(certbot);
cmd.arg("renew");
cmd.status_checked()
sudo.execute(ctx, &certbot)?.arg("renew").status_checked()
}
/// 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;
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);
ctx.execute(sudo)
.arg(lensfun_update_data)
sudo.execute(ctx, &lensfun_update_data)?
// `lensfun-update-data` returns 1 when there is no update available
// which should be considered success
.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::process::Command;
use crate::utils::{get_require_sudo_string, require_option};
use crate::HOME_DIR;
use color_eyre::eyre::Result;
#[cfg(target_os = "linux")]
@@ -93,8 +92,8 @@ impl NPM {
fn upgrade(&self, ctx: &ExecutionContext, use_sudo: bool) -> Result<()> {
let args = ["update", self.global_location_arg()];
if use_sudo {
let sudo = require_option(ctx.sudo().clone(), get_require_sudo_string())?;
ctx.execute(sudo).arg(&self.command).args(args).status_checked()?;
let sudo = ctx.require_sudo()?;
sudo.execute(ctx, &self.command)?.args(args).status_checked()?;
} else {
ctx.execute(&self.command).args(args).status_checked()?;
}
@@ -153,11 +152,9 @@ impl Yarn {
let args = ["global", "upgrade"];
if use_sudo {
let sudo = require_option(ctx.sudo().clone(), get_require_sudo_string())?;
ctx.execute(sudo)
.arg(self.yarn.as_ref().unwrap_or(&self.command))
.args(args)
.status_checked()?;
let sudo = ctx.require_sudo()?;
let command = self.yarn.as_ref().unwrap_or(&self.command);
sudo.execute(ctx, command)?.args(args).status_checked()?;
} else {
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::execution_context::ExecutionContext;
use crate::step::Step;
use crate::utils::require_option;
use crate::utils::which;
use crate::{config, output_changed_message};
@@ -150,20 +149,17 @@ pub struct Pacman {
impl ArchPackageManager for Pacman {
fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), "sudo is required to run pacman".into())?;
let mut command = ctx.execute(sudo);
command
.arg(&self.executable)
.arg("-Syu")
.env("PATH", get_execution_path());
let sudo = ctx.require_sudo()?;
let mut command = sudo.execute(ctx, &self.executable)?;
command.arg("-Syu").env("PATH", get_execution_path());
if ctx.config().yes(Step::System) {
command.arg("--noconfirm");
}
command.status_checked()?;
if ctx.config().cleanup() {
let mut command = ctx.execute(sudo);
command.arg(&self.executable).arg("-Scc");
let mut command = sudo.execute(ctx, &self.executable)?;
command.arg("-Scc");
if ctx.config().yes(Step::System) {
command.arg("--noconfirm");
}
@@ -306,23 +302,18 @@ impl ArchPackageManager for Aura {
}
cmd.status_checked()?;
} else {
let sudo = crate::utils::require_option(
ctx.sudo().as_ref(),
t!("Aura(<0.4.6) requires sudo installed to work with AUR packages").to_string(),
)?;
let sudo = ctx.require_sudo()?;
let mut cmd = ctx.execute(sudo);
cmd.arg(&self.executable)
.arg("-Au")
let mut cmd = sudo.execute(ctx, &self.executable)?;
cmd.arg("-Au")
.args(ctx.config().aura_aur_arguments().split_whitespace());
if ctx.config().yes(Step::System) {
cmd.arg("--noconfirm");
}
cmd.status_checked()?;
let mut cmd = ctx.execute(sudo);
cmd.arg(&self.executable)
.arg("-Syu")
let mut cmd = sudo.execute(ctx, &self.executable)?;
cmd.arg("-Syu")
.args(ctx.config().aura_pacman_arguments().split_whitespace());
if ctx.config().yes(Step::System) {
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::step::Step;
use crate::terminal::print_separator;
use crate::utils::{get_require_sudo_string, require_option};
use color_eyre::eyre::Result;
use std::process::Command;
use rust_i18n::t;
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"));
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) {
cmd.arg("-y");
}
@@ -18,19 +18,19 @@ pub fn upgrade_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"));
#[allow(clippy::disallowed_methods)]
if !Command::new(sudo)
.args(["/usr/local/sbin/pkg", "audit", "-Fr"])
.status()?
.success()
{
println!(t!(
"The package audit was successful, but vulnerable packages still remain on the system"
));
}
Ok(())
sudo.execute(ctx, "/usr/local/sbin/pkg")?
.args(["audit", "-Fr"])
.status_checked_with(|status| {
if !status.success() {
println!(
"{}",
t!("The package audit was successful, but vulnerable packages still remain on the system")
);
}
Ok(())
})
}

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

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

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

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

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

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

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

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

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::Context;
use color_eyre::eyre::Result;
@@ -20,6 +18,10 @@ use std::sync::LazyLock;
use std::{env::var, path::Path};
use tracing::{debug, warn};
use crate::command::CommandExt;
use crate::sudo::SudoExecuteOpts;
use crate::{output_changed_message, HOME_DIR};
#[cfg(target_os = "linux")]
use super::linux::Distribution;
use crate::error::SkipStep;
@@ -28,7 +30,7 @@ use crate::execution_context::ExecutionContext;
use crate::executor::Executor;
use crate::step::Step;
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"))]
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<()> {
let sudo = ctx.require_sudo()?;
let pkgin = require("pkgin")?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
print_separator("Pkgin");
let mut command = ctx.execute(sudo);
command.arg(&pkgin).arg("update");
let mut command = sudo.execute(ctx, &pkgin)?;
command.arg("update");
if ctx.config().yes(Step::Pkgin) {
command.arg("-y");
}
command.status_checked()?;
let mut command = ctx.execute(sudo);
command.arg(&pkgin).arg("upgrade");
let mut command = sudo.execute(ctx, &pkgin)?;
command.arg("upgrade");
if ctx.config().yes(Step::Pkgin) {
command.arg("-y");
}
@@ -247,7 +249,7 @@ pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
#[cfg(not(any(target_os = "android", target_os = "macos")))]
pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
let gdbus = require("gdbus")?;
require_option(
crate::utils::require_option(
var("XDG_CURRENT_DESKTOP").ok().filter(|p| p.contains("GNOME")),
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);
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())?;
ctx.execute(sudo)
.current_dir("/tmp") // brew needs a writable current directory
.args([
"--set-home",
&format!("--user={}", user.name),
&format!("{}", binary_name.to_string_lossy()),
"update",
])
.status_checked()?;
let sudo = ctx.require_sudo()?;
sudo.execute_opts(
ctx,
&binary_name,
SudoExecuteOpts {
set_home: true,
user: Some(&user.name),
..Default::default()
},
)?
.current_dir("/tmp") // brew needs a writable current directory
.arg("update")
.status_checked()?;
return Ok(());
}
}
@@ -551,10 +556,18 @@ pub fn run_nix_self_upgrade(ctx: &ExecutionContext) -> Result<()> {
let nix_args = nix_args();
if multi_user {
ctx.execute_elevated(&nix, true)?
.args(nix_args)
.arg("upgrade-nix")
.status_checked()
let sudo = ctx.require_sudo()?;
sudo.execute_opts(
ctx,
&nix,
SudoExecuteOpts {
interactive: true,
..Default::default()
},
)?
.args(nix_args)
.arg("upgrade-nix")
.status_checked()
} else {
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()
}
pub fn reboot() -> Result<()> {
print!("{}", t!("Rebooting..."));
Command::new("sudo").arg("reboot").status_checked()
pub fn reboot(ctx: &ExecutionContext) -> Result<()> {
match ctx.sudo() {
Some(sudo) => sudo.execute(ctx, "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");
let mut command = match ctx.sudo() {
Some(sudo) => {
let mut command = ctx.execute(sudo);
command.arg(choco);
command
}
Some(sudo) => sudo.execute(ctx, &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() {
match ctx.sudo() {
Some(sudo) => {
let mut command = ctx.execute(sudo);
command.arg(winget);
command
}
Some(sudo) => sudo.execute(ctx, &winget)?,
None => ctx.execute(winget),
}
} else {
@@ -242,10 +234,10 @@ pub fn microsoft_store(ctx: &ExecutionContext) -> Result<()> {
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
// 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<()> {

10
src/steps/powershell.rs
View File

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

16
src/sudo.rs
View File

@@ -1,4 +1,5 @@
use std::ffi::OsStr;
use std::path::Path;
use std::path::PathBuf;
use color_eyre::eyre::Context;
@@ -69,6 +70,15 @@ impl Sudo {
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`.
///
/// This helps prevent blocking `sudo` prompts from stopping the run in the middle of a
@@ -278,9 +288,3 @@ pub enum SudoKind {
Run0,
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.
///
/// # Shim