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

refactor: move RunType::execute to ExecutionContext

Browse Source
This commit is contained in:
Andre Toerien
2025-06-24 15:20:29 +02:00
committed by Gideon
parent 257d202646
commit 32197f79f3
27 changed files with 386 additions and 621 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -14,7 +14,7 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let is_nala = pkg.ends_with("nala");
let mut command = ctx.run_type().execute(&pkg);
let mut command = ctx.execute(&pkg);
command.arg("upgrade");
if ctx.config().yes(Step::System) {
@@ -23,10 +23,10 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
command.status_checked()?;
if !is_nala && ctx.config().cleanup() {
ctx.run_type().execute(&pkg).arg("clean").status_checked()?;
ctx.execute(&pkg).arg("clean").status_checked()?;
let apt = require("apt")?;
let mut command = ctx.run_type().execute(apt);
let mut command = ctx.execute(apt);
command.arg("autoremove");
if ctx.config().yes(Step::System) {
command.arg("-y");

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

@@ -33,13 +33,12 @@ pub struct YayParu {
impl ArchPackageManager for YayParu {
fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
if ctx.config().show_arch_news() {
ctx.run_type()
.execute(&self.executable)
ctx.execute(&self.executable)
.arg("-Pw")
.status_checked_with_codes(&[1, 0])?;
}
let mut command = ctx.run_type().execute(&self.executable);
let mut command = ctx.execute(&self.executable);
command
.arg("--pacman")
@@ -54,7 +53,7 @@ impl ArchPackageManager for YayParu {
command.status_checked()?;
if ctx.config().cleanup() {
let mut command = ctx.run_type().execute(&self.executable);
let mut command = ctx.execute(&self.executable);
command.arg("--pacman").arg(&self.pacman).arg("-Scc");
if ctx.config().yes(Step::System) {
command.arg("--noconfirm");
@@ -81,7 +80,7 @@ pub struct GarudaUpdate {
impl ArchPackageManager for GarudaUpdate {
fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
let mut command = ctx.run_type().execute(&self.executable);
let mut command = ctx.execute(&self.executable);
command
.env("PATH", get_execution_path())
@@ -112,7 +111,7 @@ pub struct Trizen {
impl ArchPackageManager for Trizen {
fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
let mut command = ctx.run_type().execute(&self.executable);
let mut command = ctx.execute(&self.executable);
command
.arg("-Syu")
@@ -125,7 +124,7 @@ impl ArchPackageManager for Trizen {
command.status_checked()?;
if ctx.config().cleanup() {
let mut command = ctx.run_type().execute(&self.executable);
let mut command = ctx.execute(&self.executable);
command.arg("-Sc");
if ctx.config().yes(Step::System) {
command.arg("--noconfirm");
@@ -152,7 +151,7 @@ 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.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command
.arg(&self.executable)
.arg("-Syu")
@@ -163,7 +162,7 @@ impl ArchPackageManager for Pacman {
command.status_checked()?;
if ctx.config().cleanup() {
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.arg(&self.executable).arg("-Scc");
if ctx.config().yes(Step::System) {
command.arg("--noconfirm");
@@ -197,7 +196,7 @@ impl Pikaur {
impl ArchPackageManager for Pikaur {
fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
let mut command = ctx.run_type().execute(&self.executable);
let mut command = ctx.execute(&self.executable);
command
.arg("-Syu")
@@ -211,7 +210,7 @@ impl ArchPackageManager for Pikaur {
command.status_checked()?;
if ctx.config().cleanup() {
let mut command = ctx.run_type().execute(&self.executable);
let mut command = ctx.execute(&self.executable);
command.arg("-Sc");
if ctx.config().yes(Step::System) {
command.arg("--noconfirm");
@@ -236,7 +235,7 @@ impl Pamac {
}
impl ArchPackageManager for Pamac {
fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
let mut command = ctx.run_type().execute(&self.executable);
let mut command = ctx.execute(&self.executable);
command
.arg("upgrade")
@@ -250,7 +249,7 @@ impl ArchPackageManager for Pamac {
command.status_checked()?;
if ctx.config().cleanup() {
let mut command = ctx.run_type().execute(&self.executable);
let mut command = ctx.execute(&self.executable);
command.arg("clean");
if ctx.config().yes(Step::System) {
command.arg("--no-confirm");
@@ -278,11 +277,7 @@ impl ArchPackageManager for Aura {
fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
use semver::Version;
let version_cmd_output = ctx
.run_type()
.execute(&self.executable)
.arg("--version")
.output_checked_utf8()?;
let version_cmd_output = ctx.execute(&self.executable).arg("--version").output_checked_utf8()?;
// Output will be something like: "aura x.x.x\n"
let version_cmd_stdout = version_cmd_output.stdout;
let version_str = version_cmd_stdout.trim_start_matches("aura ").trim_end();
@@ -295,7 +290,7 @@ impl ArchPackageManager for Aura {
let version_no_sudo = Version::new(4, 0, 6);
if version >= version_no_sudo {
let mut cmd = ctx.run_type().execute(&self.executable);
let mut cmd = ctx.execute(&self.executable);
cmd.arg("-Au")
.args(ctx.config().aura_aur_arguments().split_whitespace());
if ctx.config().yes(Step::System) {
@@ -303,7 +298,7 @@ impl ArchPackageManager for Aura {
}
cmd.status_checked()?;
let mut cmd = ctx.run_type().execute(&self.executable);
let mut cmd = ctx.execute(&self.executable);
cmd.arg("-Syu")
.args(ctx.config().aura_pacman_arguments().split_whitespace());
if ctx.config().yes(Step::System) {
@@ -316,7 +311,7 @@ impl ArchPackageManager for Aura {
t!("Aura(<0.4.6) requires sudo installed to work with AUR packages").to_string(),
)?;
let mut cmd = ctx.run_type().execute(sudo);
let mut cmd = ctx.execute(sudo);
cmd.arg(&self.executable)
.arg("-Au")
.args(ctx.config().aura_aur_arguments().split_whitespace());
@@ -325,7 +320,7 @@ impl ArchPackageManager for Aura {
}
cmd.status_checked()?;
let mut cmd = ctx.run_type().execute(sudo);
let mut cmd = ctx.execute(sudo);
cmd.arg(&self.executable)
.arg("-Syu")
.args(ctx.config().aura_pacman_arguments().split_whitespace());

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

@@ -9,7 +9,7 @@ use std::process::Command;
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
print_separator(t!("DragonFly BSD Packages"));
let mut cmd = ctx.run_type().execute(sudo);
let mut cmd = ctx.execute(sudo);
cmd.args(["/usr/local/sbin/pkg", "upgrade"]);
if ctx.config().yes(Step::System) {
cmd.arg("-y");

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

@@ -10,8 +10,7 @@ use std::process::Command;
pub fn upgrade_freebsd(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
print_separator(t!("FreeBSD Update"));
ctx.run_type()
.execute(sudo)
ctx.execute(sudo)
.args(["/usr/sbin/freebsd-update", "fetch", "install"])
.status_checked()
}
@@ -20,7 +19,7 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
print_separator(t!("FreeBSD Packages"));
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.args(["/usr/sbin/pkg", "upgrade"]);
if ctx.config().yes(Step::System) {

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

@@ -177,7 +177,7 @@ impl Distribution {
fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
ctx.run_type().execute(sudo).args(["brl", "update"]);
ctx.execute(sudo).args(["brl", "update"]);
let output = Command::new("brl").arg("list").output_checked_utf8()?;
debug!("brl list: {:?} {:?}", output.stdout, output.stderr);
@@ -202,44 +202,44 @@ fn upgrade_alpine_linux(ctx: &ExecutionContext) -> Result<()> {
let apk = require("apk")?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
ctx.execute(sudo).arg(&apk).arg("update").status_checked()?;
ctx.execute(sudo).arg(&apk).arg("upgrade").status_checked()
}
fn upgrade_chimera_linux(ctx: &ExecutionContext) -> Result<()> {
let apk = require("apk")?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
ctx.execute(sudo).arg(&apk).arg("update").status_checked()?;
ctx.execute(sudo).arg(&apk).arg("upgrade").status_checked()
}
fn upgrade_wolfi_linux(ctx: &ExecutionContext) -> Result<()> {
let apk = require("apk")?;
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
ctx.execute(sudo).arg(&apk).arg("update").status_checked()?;
ctx.execute(sudo).arg(&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.run_type().execute(sudo).arg(&bootc).arg("upgrade").status_checked();
return ctx.execute(sudo).arg(&bootc).arg("upgrade").status_checked();
}
}
if let Some(ostree) = which("rpm-ostree") {
if ctx.config().rpm_ostree() {
let mut command = ctx.run_type().execute(ostree);
let mut command = ctx.execute(ostree);
command.arg("upgrade");
return command.status_checked();
}
};
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
let mut command = ctx.run_type().execute(sudo);
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() {
@@ -264,7 +264,7 @@ fn upgrade_nobara(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
let pkg_manager = require("dnf")?;
let mut update_command = ctx.run_type().execute(sudo);
let mut update_command = ctx.execute(sudo);
update_command.arg(&pkg_manager);
if ctx.config().yes(Step::System) {
@@ -281,7 +281,7 @@ fn upgrade_nobara(ctx: &ExecutionContext) -> Result<()> {
]);
update_command.arg("--refresh").status_checked()?;
let mut upgrade_command = ctx.run_type().execute(sudo);
let mut upgrade_command = ctx.execute(sudo);
upgrade_command.arg(&pkg_manager);
if ctx.config().yes(Step::System) {
@@ -298,20 +298,20 @@ fn upgrade_nilrt(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
let opkg = require("opkg")?;
ctx.run_type().execute(sudo).arg(&opkg).arg("update").status_checked()?;
ctx.run_type().execute(sudo).arg(&opkg).arg("upgrade").status_checked()
ctx.execute(sudo).arg(&opkg).arg("update").status_checked()?;
ctx.execute(sudo).arg(&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.run_type().execute(sudo).arg(&bootc).arg("upgrade").status_checked();
return ctx.execute(sudo).arg(&bootc).arg("upgrade").status_checked();
}
}
let ostree = require("rpm-ostree")?;
let mut command = ctx.run_type().execute(ostree);
let mut command = ctx.execute(ostree);
command.arg("upgrade");
command.status_checked()?;
Ok(())
@@ -319,19 +319,16 @@ 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.run_type().execute(sudo).args(["brl", "update"]).status_checked()?;
ctx.execute(sudo).args(["brl", "update"]).status_checked()?;
Ok(())
}
fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
ctx.run_type()
.execute(sudo)
.args(["zypper", "refresh"])
.status_checked()?;
ctx.execute(sudo).args(["zypper", "refresh"]).status_checked()?;
let mut cmd = ctx.run_type().execute(sudo);
let mut cmd = ctx.execute(sudo);
cmd.arg("zypper");
cmd.arg(if ctx.config().suse_dup() {
"dist-upgrade"
@@ -349,12 +346,9 @@ 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.run_type()
.execute(sudo)
.args(["zypper", "refresh"])
.status_checked()?;
ctx.execute(sudo).args(["zypper", "refresh"]).status_checked()?;
let mut cmd = ctx.run_type().execute(sudo);
let mut cmd = ctx.execute(sudo);
cmd.args(["zypper", "dist-upgrade"]);
if ctx.config().yes(Step::System) {
cmd.arg("-y");
@@ -367,7 +361,7 @@ 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.run_type().execute(sudo);
let mut cmd = ctx.execute(sudo);
cmd.arg("transactional-update");
if ctx.config().yes(Step::System) {
cmd.arg("-n");
@@ -380,7 +374,7 @@ 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.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.arg(which("dnf").unwrap()).arg("upgrade");
@@ -399,7 +393,7 @@ 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.run_type().execute(sudo);
let mut command_update = ctx.execute(sudo);
command_update.arg(which("apt-get").unwrap()).arg("update");
@@ -413,7 +407,7 @@ fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
command_update.status_checked()?;
let mut cmd = ctx.run_type().execute(sudo);
let mut cmd = ctx.execute(sudo);
cmd.arg(which("apt-get").unwrap());
cmd.arg("dist-upgrade");
if ctx.config().yes(Step::System) {
@@ -427,14 +421,14 @@ fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
fn upgrade_vanilla(ctx: &ExecutionContext) -> Result<()> {
let apx = require("apx")?;
let mut update = ctx.run_type().execute(&apx);
let mut update = ctx.execute(&apx);
update.args(["update", "--all"]);
if ctx.config().yes(Step::System) {
update.arg("-y");
}
update.status_checked()?;
let mut upgrade = ctx.run_type().execute(&apx);
let mut upgrade = ctx.execute(&apx);
update.args(["upgrade", "--all"]);
if ctx.config().yes(Step::System) {
upgrade.arg("-y");
@@ -446,14 +440,14 @@ 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.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.args(["xbps-install", "-Su", "xbps"]);
if ctx.config().yes(Step::System) {
command.arg("-y");
}
command.status_checked()?;
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.args(["xbps-install", "-u"]);
if ctx.config().yes(Step::System) {
command.arg("-y");
@@ -464,24 +458,17 @@ fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
}
fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
let run_type = ctx.run_type();
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
if let Some(layman) = which("layman") {
run_type
.execute(sudo)
.arg(layman)
.args(["-s", "ALL"])
.status_checked()?;
ctx.execute(sudo).arg(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
run_type.execute(sudo).arg(ego).arg("sync").status_checked()?;
ctx.execute(sudo).arg(ego).arg("sync").status_checked()?;
} else {
run_type
.execute(sudo)
ctx.execute(sudo)
.args(["emerge", "--sync"])
.args(
ctx.config()
@@ -493,11 +480,10 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
}
if let Some(eix_update) = which("eix-update") {
run_type.execute(sudo).arg(eix_update).status_checked()?;
ctx.execute(sudo).arg(eix_update).status_checked()?;
}
run_type
.execute(sudo)
ctx.execute(sudo)
.arg("emerge")
.args(
ctx.config()
@@ -533,8 +519,8 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
// MIST does not require `sudo`
if is_mist {
ctx.run_type().execute(&apt).arg("update").status_checked()?;
ctx.run_type().execute(&apt).arg("upgrade").status_checked()?;
ctx.execute(&apt).arg("update").status_checked()?;
ctx.execute(&apt).arg("upgrade").status_checked()?;
// Simply return as MIST does not have `clean` and `autoremove`
// subcommands, neither the `-y` option (for now maybe?).
@@ -543,14 +529,13 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
if !is_nala {
ctx.run_type()
.execute(sudo)
ctx.execute(sudo)
.arg(&apt)
.arg("update")
.status_checked_with_codes(&[0, 100])?;
}
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.arg(&apt);
if is_nala {
command.arg("upgrade");
@@ -566,9 +551,9 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
command.status_checked()?;
if ctx.config().cleanup() {
ctx.run_type().execute(sudo).arg(&apt).arg("clean").status_checked()?;
ctx.execute(sudo).arg(&apt).arg("clean").status_checked()?;
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.arg(&apt).arg("autoremove");
if ctx.config().yes(Step::System) {
command.arg("-y");
@@ -584,11 +569,11 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
print_separator("deb-get");
ctx.run_type().execute(&deb_get).arg("update").status_checked()?;
ctx.run_type().execute(&deb_get).arg("upgrade").status_checked()?;
ctx.execute(&deb_get).arg("update").status_checked()?;
ctx.execute(&deb_get).arg("upgrade").status_checked()?;
if ctx.config().cleanup() {
let output = ctx.run_type().execute(&deb_get).arg("clean").output_checked()?;
let output = ctx.execute(&deb_get).arg("clean").output_checked()?;
// Swallow the output, as it's very noisy and not useful.
// The output is automatically printed as part of `output_checked` when an error occurs.
println!("{}", t!("<output from `deb-get clean` omitted>"));
@@ -600,7 +585,7 @@ 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.run_type().execute(sudo);
let mut cmd = ctx.execute(sudo);
cmd.arg("eopkg");
if ctx.config().yes(Step::System) {
cmd.arg("-y");
@@ -615,7 +600,7 @@ pub fn run_am(ctx: &ExecutionContext) -> Result<()> {
print_separator("AM");
let mut am = ctx.run_type().execute(am);
let mut am = ctx.execute(am);
if ctx.config().yes(Step::AM) {
am.arg("-U");
@@ -631,7 +616,7 @@ pub fn run_appman(ctx: &ExecutionContext) -> Result<()> {
print_separator("appman");
ctx.run_type().execute(appman).arg("-u").status_checked()
ctx.execute(appman).arg("-u").status_checked()
}
pub fn run_pacdef(ctx: &ExecutionContext) -> Result<()> {
@@ -639,12 +624,12 @@ pub fn run_pacdef(ctx: &ExecutionContext) -> Result<()> {
print_separator("pacdef");
let output = ctx.run_type().execute(&pacdef).arg("version").output_checked()?;
let output = ctx.execute(&pacdef).arg("version").output_checked()?;
let string = String::from_utf8(output.stdout)?;
let new_version = string.contains("version: 1");
if new_version {
let mut cmd = ctx.run_type().execute(&pacdef);
let mut cmd = ctx.execute(&pacdef);
cmd.args(["package", "sync"]);
if ctx.config().yes(Step::System) {
cmd.arg("--noconfirm");
@@ -652,12 +637,9 @@ pub fn run_pacdef(ctx: &ExecutionContext) -> Result<()> {
cmd.status_checked()?;
println!();
ctx.run_type()
.execute(&pacdef)
.args(["package", "review"])
.status_checked()?;
ctx.execute(&pacdef).args(["package", "review"]).status_checked()?;
} else {
let mut cmd = ctx.run_type().execute(&pacdef);
let mut cmd = ctx.execute(&pacdef);
cmd.arg("sync");
if ctx.config().yes(Step::System) {
cmd.arg("--noconfirm");
@@ -666,7 +648,7 @@ pub fn run_pacdef(ctx: &ExecutionContext) -> Result<()> {
cmd.status_checked()?;
println!();
ctx.run_type().execute(&pacdef).arg("review").status_checked()?;
ctx.execute(&pacdef).arg("review").status_checked()?;
}
Ok(())
}
@@ -676,8 +658,8 @@ pub fn run_pacstall(ctx: &ExecutionContext) -> Result<()> {
print_separator("Pacstall");
let mut update_cmd = ctx.run_type().execute(&pacstall);
let mut upgrade_cmd = ctx.run_type().execute(pacstall);
let mut update_cmd = ctx.execute(&pacstall);
let mut upgrade_cmd = ctx.execute(pacstall);
if ctx.config().yes(Step::Pacstall) {
update_cmd.arg("-P");
@@ -696,8 +678,7 @@ pub fn run_packer_nu(ctx: &ExecutionContext) -> Result<()> {
print_separator("packer.nu");
ctx.run_type()
.execute(nu)
ctx.execute(nu)
.env("PWD", "/")
.env("NU_PACKER_HOME", packer_home)
.args([
@@ -709,7 +690,7 @@ 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.run_type().execute(sudo);
let mut cmd = ctx.execute(sudo);
cmd.args(["swupd", "update"]);
if ctx.config().yes(Step::System) {
cmd.arg("--assume=yes");
@@ -721,27 +702,21 @@ 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.run_type().execute(sudo).args(["cave", "sync"]).status_checked()?;
ctx.execute(sudo).args(["cave", "sync"]).status_checked()?;
ctx.run_type()
.execute(sudo)
ctx.execute(sudo)
.args(["cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
.status_checked()?;
if ctx.config().cleanup() {
ctx.run_type()
.execute(sudo)
.args(["cave", "purge", "-x"])
.status_checked()?;
ctx.execute(sudo).args(["cave", "purge", "-x"]).status_checked()?;
}
ctx.run_type()
.execute(sudo)
ctx.execute(sudo)
.args(["cave", "fix-linkage", "-x", "--", "-Cs"])
.status_checked()?;
ctx.run_type()
.execute(sudo)
ctx.execute(sudo)
.args(["eclectic", "config", "interactive"])
.status_checked()?;
@@ -750,7 +725,7 @@ fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"]);
if let Some(args) = ctx.config().nix_arguments() {
@@ -759,8 +734,7 @@ fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
command.status_checked()?;
if ctx.config().cleanup() {
ctx.run_type()
.execute(sudo)
ctx.execute(sudo)
.args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
.status_checked()?;
}
@@ -778,12 +752,8 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
let pkcon = which("pkcon").unwrap();
// pkcon ignores update with update and refresh provided together
ctx.run_type()
.execute(sudo)
.arg(&pkcon)
.arg("refresh")
.status_checked()?;
let mut exe = ctx.run_type().execute(sudo);
ctx.execute(sudo).arg(&pkcon).arg("refresh").status_checked()?;
let mut exe = ctx.execute(sudo);
let cmd = exe.arg(&pkcon).arg("update");
if ctx.config().yes(Step::System) {
cmd.arg("-y");
@@ -846,7 +816,7 @@ pub fn run_needrestart(ctx: &ExecutionContext) -> Result<()> {
print_separator(t!("Check for needed restarts"));
ctx.run_type().execute(sudo).arg(needrestart).status_checked()?;
ctx.execute(sudo).arg(needrestart).status_checked()?;
Ok(())
}
@@ -860,12 +830,9 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
print_separator(t!("Firmware upgrades"));
ctx.run_type()
.execute(&fwupdmgr)
.arg("refresh")
.status_checked_with_codes(&[2])?;
ctx.execute(&fwupdmgr).arg("refresh").status_checked_with_codes(&[2])?;
let mut updmgr = ctx.run_type().execute(&fwupdmgr);
let mut updmgr = ctx.execute(&fwupdmgr);
if ctx.config().firmware_upgrade() {
updmgr.arg("update");
@@ -883,21 +850,20 @@ pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
let cleanup = ctx.config().cleanup();
let yes = ctx.config().yes(Step::Flatpak);
let run_type = ctx.run_type();
print_separator("Flatpak User Packages");
let mut update_args = vec!["update", "--user"];
if yes {
update_args.push("-y");
}
run_type.execute(&flatpak).args(&update_args).status_checked()?;
ctx.execute(&flatpak).args(&update_args).status_checked()?;
if cleanup {
let mut cleanup_args = vec!["uninstall", "--user", "--unused"];
if yes {
cleanup_args.push("-y");
}
run_type.execute(&flatpak).args(&cleanup_args).status_checked()?;
ctx.execute(&flatpak).args(&cleanup_args).status_checked()?;
}
print_separator(t!("Flatpak System Packages"));
@@ -906,34 +872,26 @@ pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> {
if yes {
update_args.push("-y");
}
run_type
.execute(sudo)
.arg(&flatpak)
.args(&update_args)
.status_checked()?;
ctx.execute(sudo).arg(&flatpak).args(&update_args).status_checked()?;
if cleanup {
let mut cleanup_args = vec!["uninstall", "--system", "--unused"];
if yes {
cleanup_args.push("-y");
}
run_type
.execute(sudo)
.arg(flatpak)
.args(&cleanup_args)
.status_checked()?;
ctx.execute(sudo).arg(flatpak).args(&cleanup_args).status_checked()?;
}
} else {
let mut update_args = vec!["update", "--system"];
if yes {
update_args.push("-y");
}
run_type.execute(&flatpak).args(&update_args).status_checked()?;
ctx.execute(&flatpak).args(&update_args).status_checked()?;
if cleanup {
let mut cleanup_args = vec!["uninstall", "--system", "--unused"];
if yes {
cleanup_args.push("-y");
}
run_type.execute(flatpak).args(&cleanup_args).status_checked()?;
ctx.execute(flatpak).args(&cleanup_args).status_checked()?;
}
}
@@ -949,7 +907,7 @@ pub fn run_snap(ctx: &ExecutionContext) -> Result<()> {
}
print_separator("snap");
ctx.run_type().execute(sudo).arg(snap).arg("refresh").status_checked()
ctx.execute(sudo).arg(snap).arg("refresh").status_checked()
}
pub fn run_pihole_update(ctx: &ExecutionContext) -> Result<()> {
@@ -959,7 +917,7 @@ pub fn run_pihole_update(ctx: &ExecutionContext) -> Result<()> {
print_separator("pihole");
ctx.run_type().execute(sudo).arg(pihole).arg("-up").status_checked()
ctx.execute(sudo).arg(pihole).arg("-up").status_checked()
}
pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
@@ -967,7 +925,7 @@ pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
print_separator("protonup");
let mut cmd = ctx.run_type().execute(protonup);
let mut cmd = ctx.execute(protonup);
if ctx.config().yes(Step::Protonup) {
cmd.arg("--yes");
}
@@ -982,7 +940,7 @@ pub fn run_distrobox_update(ctx: &ExecutionContext) -> Result<()> {
print_separator("Distrobox");
match (
match (
ctx.run_type().execute(distrobox).arg("upgrade"),
ctx.execute(distrobox).arg("upgrade"),
ctx.config().distrobox_containers(),
) {
(r, Some(c)) => {
@@ -1007,18 +965,10 @@ pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> {
print_separator("Devkitpro pacman");
ctx.run_type()
.execute(sudo)
.arg(&dkp_pacman)
.arg("-Syu")
.status_checked()?;
ctx.execute(sudo).arg(&dkp_pacman).arg("-Syu").status_checked()?;
if ctx.config().cleanup() {
ctx.run_type()
.execute(sudo)
.arg(&dkp_pacman)
.arg("-Scc")
.status_checked()?;
ctx.execute(sudo).arg(&dkp_pacman).arg("-Scc").status_checked()?;
}
Ok(())
@@ -1032,7 +982,7 @@ pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> {
if let Ok(etc_update) = require("etc-update") {
print_separator(t!("Configuration update"));
ctx.run_type().execute(sudo).arg(etc_update).status_checked()?;
ctx.execute(sudo).arg(etc_update).status_checked()?;
} else if let Ok(pacdiff) = require("pacdiff") {
if std::env::var("DIFFPROG").is_err() {
require("vim")?;
@@ -1050,7 +1000,7 @@ pub fn run_lure_update(ctx: &ExecutionContext) -> Result<()> {
print_separator("LURE");
let mut exe = ctx.run_type().execute(lure);
let mut exe = ctx.execute(lure);
if ctx.config().yes(Step::Lure) {
exe.args(["-i=false", "up"]);
@@ -1064,7 +1014,7 @@ 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 waydroid = require("waydroid")?;
let status = ctx.run_type().execute(&waydroid).arg("status").output_checked_utf8()?;
let status = ctx.execute(&waydroid).arg("status").output_checked_utf8()?;
// example output of `waydroid status`:
//
// ```sh
@@ -1102,11 +1052,7 @@ pub fn run_waydroid(ctx: &ExecutionContext) -> Result<()> {
);
}
}
ctx.run_type()
.execute(sudo)
.arg(&waydroid)
.arg("upgrade")
.status_checked()
ctx.execute(sudo).arg(&waydroid).arg("upgrade").status_checked()
}
pub fn run_auto_cpufreq(ctx: &ExecutionContext) -> Result<()> {
@@ -1115,11 +1061,7 @@ pub fn run_auto_cpufreq(ctx: &ExecutionContext) -> Result<()> {
print_separator("auto-cpufreq");
ctx.run_type()
.execute(sudo)
.arg(auto_cpu_freq)
.arg("--update")
.status_checked()
ctx.execute(sudo).arg(auto_cpu_freq).arg("--update").status_checked()
}
pub fn run_cinnamon_spices_updater(ctx: &ExecutionContext) -> Result<()> {
@@ -1127,10 +1069,7 @@ pub fn run_cinnamon_spices_updater(ctx: &ExecutionContext) -> Result<()> {
print_separator("Cinnamon spices");
ctx.run_type()
.execute(cinnamon_spice_updater)
.arg("--update-all")
.status_checked()
ctx.execute(cinnamon_spice_updater).arg("--update-all").status_checked()
}
#[cfg(test)]

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

@@ -16,19 +16,12 @@ pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
print_separator("MacPorts");
ctx.run_type()
.execute(sudo)
.args(["port", "selfupdate"])
.status_checked()?;
ctx.run_type()
.execute(sudo)
ctx.execute(sudo).args(["port", "selfupdate"]).status_checked()?;
ctx.execute(sudo)
.args(["port", "-u", "upgrade", "outdated"])
.status_checked()?;
if ctx.config().cleanup() {
ctx.run_type()
.execute(sudo)
.args(["port", "-N", "reclaim"])
.status_checked()?;
ctx.execute(sudo).args(["port", "-N", "reclaim"]).status_checked()?;
}
Ok(())
@@ -38,7 +31,7 @@ pub fn run_mas(ctx: &ExecutionContext) -> Result<()> {
let mas = require("mas")?;
print_separator(t!("macOS App Store"));
ctx.run_type().execute(mas).arg("upgrade").status_checked()
ctx.execute(mas).arg("upgrade").status_checked()
}
pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
@@ -59,7 +52,7 @@ pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
}
}
let mut command = ctx.run_type().execute("softwareupdate");
let mut command = ctx.execute("softwareupdate");
command.args(["--install", "--all"]);
if should_ask {
@@ -88,7 +81,7 @@ pub fn run_sparkle(ctx: &ExecutionContext) -> Result<()> {
.arg(application.path())
.output_checked_utf8();
if probe.is_ok() {
let mut command = ctx.run_type().execute(&sparkle);
let mut command = ctx.execute(&sparkle);
command.args(["bundle", "--check-immediately", "--application"]);
command.arg(application.path());
command.status_checked()?;
@@ -103,12 +96,7 @@ pub fn update_xcodes(ctx: &ExecutionContext) -> Result<()> {
let should_ask = !(ctx.config().yes(Step::Xcodes) || ctx.config().dry_run());
let releases = ctx
.run_type()
.execute(&xcodes)
.args(["update"])
.output_checked_utf8()?
.stdout;
let releases = ctx.execute(&xcodes).args(["update"]).output_checked_utf8()?.stdout;
let releases_installed: Vec<String> = releases
.lines()
@@ -165,12 +153,7 @@ pub fn update_xcodes(ctx: &ExecutionContext) -> Result<()> {
process_xcodes_releases(releases_regular, should_ask, ctx)?;
}
let releases_new = ctx
.run_type()
.execute(&xcodes)
.args(["list"])
.output_checked_utf8()?
.stdout;
let releases_new = ctx.execute(&xcodes).args(["list"]).output_checked_utf8()?.stdout;
let releases_gm_new_installed: HashSet<_> = releases_new
.lines()
@@ -200,7 +183,6 @@ pub fn update_xcodes(ctx: &ExecutionContext) -> Result<()> {
prompt_yesno(t!("Would you like to move the former Xcode release to the trash?").as_ref())?;
if answer_uninstall {
let _ = ctx
.run_type()
.execute(&xcodes)
.args([
"uninstall",
@@ -227,7 +209,6 @@ pub fn process_xcodes_releases(releases_filtered: Vec<String>, should_ask: bool,
let answer_install = prompt_yesno(t!("Would you like to install it?").as_ref())?;
if answer_install {
let _ = ctx
.run_type()
.execute(xcodes)
.args(["install", &releases_filtered.last().cloned().unwrap_or_default()])
.status_checked();

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

@@ -34,7 +34,7 @@ pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
vec!["/usr/sbin/syspatch"]
};
ctx.run_type().execute(sudo).args(&args).status_checked()
ctx.execute(sudo).args(&args).status_checked()
}
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
@@ -49,8 +49,7 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
}
if ctx.config().cleanup() {
ctx.run_type()
.execute(sudo)
ctx.execute(sudo)
.args(["/usr/sbin/pkg_delete", "-ac"])
.status_checked()?;
}
@@ -60,7 +59,7 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
args.push("-Dsnap");
}
ctx.run_type().execute(sudo).args(&args).status_checked()?;
ctx.execute(sudo).args(&args).status_checked()?;
Ok(())
}

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

@@ -26,8 +26,6 @@ use crate::error::SkipStep;
use crate::execution_context::ExecutionContext;
#[cfg(any(target_os = "linux", target_os = "macos"))]
use crate::executor::Executor;
#[cfg(any(target_os = "linux", target_os = "macos"))]
use crate::executor::RunType;
use crate::step::Step;
use crate::terminal::print_separator;
use crate::utils::{get_require_sudo_string, require, require_option, PathExt};
@@ -75,19 +73,41 @@ impl BrewVariant {
}
}
fn execute(self, run_type: RunType) -> Executor {
/// Execute an "internal" brew command, i.e. one that should always be run
/// even when dry-running. Basically just a wrapper around [`Command::new`]
/// that uses `arch` to run using the correct architecture if needed.
#[cfg(target_os = "macos")]
fn execute_internal(self) -> Command {
match self {
BrewVariant::MacIntel if cfg!(target_arch = "aarch64") => {
let mut command = run_type.execute("arch");
let mut command = Command::new("arch");
command.arg("-x86_64").arg(self.binary_name());
command
}
BrewVariant::MacArm if cfg!(target_arch = "x86_64") => {
let mut command = run_type.execute("arch");
let mut command = Command::new("arch");
command.arg("-arm64e").arg(self.binary_name());
command
}
_ => run_type.execute(self.binary_name()),
_ => Command::new(self.binary_name()),
}
}
/// Execute a brew command. Uses `arch` to run using the correct
/// architecture on macOS if needed.
fn execute(self, ctx: &ExecutionContext) -> Executor {
match self {
BrewVariant::MacIntel if cfg!(target_arch = "aarch64") => {
let mut command = ctx.execute("arch");
command.arg("-x86_64").arg(self.binary_name());
command
}
BrewVariant::MacArm if cfg!(target_arch = "x86_64") => {
let mut command = ctx.execute("arch");
command.arg("-arm64e").arg(self.binary_name());
command
}
_ => ctx.execute(self.binary_name()),
}
}
@@ -121,7 +141,6 @@ pub fn run_fisher(ctx: &ExecutionContext) -> Result<()> {
print_separator("Fisher");
let version_str = ctx
.run_type()
.execute(&fish)
.args(["-c", "fisher --version"])
.output_checked_utf8()?
@@ -130,13 +149,10 @@ pub fn run_fisher(ctx: &ExecutionContext) -> Result<()> {
if version_str.starts_with("fisher version 3.") {
// v3 - see https://github.com/topgrade-rs/topgrade/pull/37#issuecomment-1283844506
ctx.run_type().execute(&fish).args(["-c", "fisher"]).status_checked()
ctx.execute(&fish).args(["-c", "fisher"]).status_checked()
} else {
// v4
ctx.run_type()
.execute(&fish)
.args(["-c", "fisher update"])
.status_checked()
ctx.execute(&fish).args(["-c", "fisher update"]).status_checked()
}
}
@@ -145,8 +161,7 @@ pub fn run_bashit(ctx: &ExecutionContext) -> Result<()> {
print_separator("Bash-it");
ctx.run_type()
.execute("bash")
ctx.execute("bash")
.args(["-lic", &format!("bash-it update {}", ctx.config().bashit_branch())])
.status_checked()
}
@@ -169,7 +184,7 @@ pub fn run_oh_my_bash(ctx: &ExecutionContext) -> Result<()> {
let mut update_script = oh_my_bash;
update_script.push_str("/tools/upgrade.sh");
ctx.run_type().execute("bash").arg(update_script).status_checked()
ctx.execute("bash").arg(update_script).status_checked()
}
pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
@@ -178,7 +193,7 @@ pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
print_separator("oh-my-fish");
ctx.run_type().execute(fish).args(["-c", "omf update"]).status_checked()
ctx.execute(fish).args(["-c", "omf update"]).status_checked()
}
pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
@@ -187,14 +202,14 @@ pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
print_separator("Pkgin");
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.arg(&pkgin).arg("update");
if ctx.config().yes(Step::Pkgin) {
command.arg("-y");
}
command.status_checked()?;
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.arg(&pkgin).arg("upgrade");
if ctx.config().yes(Step::Pkgin) {
command.arg("-y");
@@ -210,10 +225,7 @@ pub fn run_fish_plug(ctx: &ExecutionContext) -> Result<()> {
print_separator("fish-plug");
ctx.run_type()
.execute(fish)
.args(["-c", "plug update"])
.status_checked()
ctx.execute(fish).args(["-c", "plug update"]).status_checked()
}
/// Upgrades `fundle` and `fundle` plugins.
@@ -227,8 +239,7 @@ pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
print_separator("fundle");
ctx.run_type()
.execute(fish)
ctx.execute(fish)
.args(["-c", "fundle self-update && fundle update"])
.status_checked()
}
@@ -260,8 +271,7 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
print_separator(t!("GNOME Shell extensions"));
ctx.run_type()
.execute(gdbus)
ctx.execute(gdbus)
.args([
"call",
"--session",
@@ -318,8 +328,7 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
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.run_type()
.execute(sudo)
ctx.execute(sudo)
.current_dir("/tmp") // brew needs a writable current directory
.args([
"--set-home",
@@ -332,11 +341,10 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
}
}
print_separator(variant.step_title());
let run_type = ctx.run_type();
variant.execute(run_type).arg("update").status_checked()?;
variant.execute(ctx).arg("update").status_checked()?;
let mut command = variant.execute(run_type);
let mut command = variant.execute(ctx);
command.args(["upgrade", "--formula"]);
if ctx.config().brew_fetch_head() {
@@ -346,11 +354,11 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
command.status_checked()?;
if ctx.config().cleanup() {
variant.execute(run_type).arg("cleanup").status_checked()?;
variant.execute(ctx).arg("cleanup").status_checked()?;
}
if ctx.config().brew_autoremove() {
variant.execute(run_type).arg("autoremove").status_checked()?;
variant.execute(ctx).arg("autoremove").status_checked()?;
}
Ok(())
@@ -363,10 +371,9 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
return Err(SkipStep(t!("Not a custom brew for macOS").to_string()).into());
}
print_separator(format!("{} - Cask", variant.step_title()));
let run_type = ctx.run_type();
let cask_upgrade_exists = variant
.execute(RunType::Wet)
.execute_internal()
.args(["--repository", "buo/cask-upgrade"])
.output_checked_utf8()
.map(|p| Path::new(p.stdout.trim()).exists())?;
@@ -391,10 +398,10 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
}
}
variant.execute(run_type).args(&brew_args).status_checked()?;
variant.execute(ctx).args(&brew_args).status_checked()?;
if ctx.config().cleanup() {
variant.execute(run_type).arg("cleanup").status_checked()?;
variant.execute(ctx).arg("cleanup").status_checked()?;
}
Ok(())
@@ -403,8 +410,6 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
pub fn run_guix(ctx: &ExecutionContext) -> Result<()> {
let guix = require("guix")?;
let run_type = ctx.run_type();
let output = Command::new(&guix).arg("pull").output_checked_utf8();
debug!("guix pull output: {:?}", output);
let should_upgrade = output.is_ok();
@@ -413,7 +418,7 @@ pub fn run_guix(ctx: &ExecutionContext) -> Result<()> {
print_separator("Guix");
if should_upgrade {
return run_type.execute(&guix).args(["package", "-u"]).status_checked();
return ctx.execute(&guix).args(["package", "-u"]).status_checked();
}
Err(SkipStep(t!("Guix Pull Failed, Skipping").to_string()).into())
}
@@ -441,10 +446,9 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
}
}
let run_type = ctx.run_type();
run_type.execute(nix_channel).arg("--update").status_checked()?;
ctx.execute(nix_channel).arg("--update").status_checked()?;
let mut get_version_cmd = ctx.run_type().execute(&nix);
let mut get_version_cmd = ctx.execute(&nix);
get_version_cmd.arg("--version");
let get_version_cmd_output = get_version_cmd.output_checked_utf8()?;
let get_version_cmd_first_line_stdout = get_version_cmd_output
@@ -498,8 +502,7 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
};
if Path::new(&manifest_json_path).exists() {
run_type
.execute(nix)
ctx.execute(nix)
.args(nix_args())
.arg("profile")
.arg("upgrade")
@@ -507,7 +510,7 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
.arg("--verbose")
.status_checked()
} else {
let mut command = run_type.execute(nix_env);
let mut command = ctx.execute(nix_env);
command.arg("--upgrade");
if let Some(args) = ctx.config().nix_env_arguments() {
command.args(args.split_whitespace());
@@ -553,11 +556,7 @@ pub fn run_nix_self_upgrade(ctx: &ExecutionContext) -> Result<()> {
.arg("upgrade-nix")
.status_checked()
} else {
ctx.run_type()
.execute(&nix)
.args(nix_args)
.arg("upgrade-nix")
.status_checked()
ctx.execute(&nix).args(nix_args).arg("upgrade-nix").status_checked()
}
}
@@ -635,8 +634,6 @@ fn flake_dir(var: &'static str) -> Option<PathBuf> {
///
/// See: https://github.com/viperML/nh
pub fn run_nix_helper(ctx: &ExecutionContext) -> Result<()> {
let run_type = ctx.run_type();
require("nix")?;
let nix_helper = require("nh")?;
@@ -669,7 +666,7 @@ pub fn run_nix_helper(ctx: &ExecutionContext) -> Result<()> {
let nh_switch = |ty: &'static str| -> Result<()> {
print_separator(format!("nh {ty}"));
let mut cmd = run_type.execute(&nix_helper);
let mut cmd = ctx.execute(&nix_helper);
cmd.arg(ty);
cmd.arg("switch");
cmd.arg("-u");
@@ -712,7 +709,7 @@ pub fn run_yadm(ctx: &ExecutionContext) -> Result<()> {
print_separator("yadm");
ctx.run_type().execute(yadm).arg("pull").status_checked()
ctx.execute(yadm).arg("pull").status_checked()
}
pub fn run_asdf(ctx: &ExecutionContext) -> Result<()> {
@@ -749,16 +746,10 @@ pub fn run_asdf(ctx: &ExecutionContext) -> Result<()> {
let version =
Version::parse(remaining).wrap_err_with(|| output_changed_message!("asdf version", "invalid version"))?;
if version < Version::new(0, 15, 0) {
ctx.run_type()
.execute(&asdf)
.arg("update")
.status_checked_with_codes(&[42])?;
ctx.execute(&asdf).arg("update").status_checked_with_codes(&[42])?;
}
ctx.run_type()
.execute(&asdf)
.args(["plugin", "update", "--all"])
.status_checked()
ctx.execute(&asdf).args(["plugin", "update", "--all"]).status_checked()
}
pub fn run_mise(ctx: &ExecutionContext) -> Result<()> {
@@ -766,12 +757,9 @@ pub fn run_mise(ctx: &ExecutionContext) -> Result<()> {
print_separator("mise");
ctx.run_type()
.execute(&mise)
.args(["plugins", "update"])
.status_checked()?;
ctx.execute(&mise).args(["plugins", "update"]).status_checked()?;
ctx.run_type().execute(&mise).arg("upgrade").status_checked()
ctx.execute(&mise).arg("upgrade").status_checked()
}
pub fn run_home_manager(ctx: &ExecutionContext) -> Result<()> {
@@ -779,7 +767,7 @@ pub fn run_home_manager(ctx: &ExecutionContext) -> Result<()> {
print_separator("home-manager");
let mut cmd = ctx.run_type().execute(home_manager);
let mut cmd = ctx.execute(home_manager);
cmd.arg("switch");
if let Some(extra_args) = ctx.config().home_manager() {
@@ -793,14 +781,14 @@ pub fn run_tldr(ctx: &ExecutionContext) -> Result<()> {
let tldr = require("tldr")?;
print_separator("TLDR");
ctx.run_type().execute(tldr).arg("--update").status_checked()
ctx.execute(tldr).arg("--update").status_checked()
}
pub fn run_pearl(ctx: &ExecutionContext) -> Result<()> {
let pearl = require("pearl")?;
print_separator("pearl");
ctx.run_type().execute(pearl).arg("update").status_checked()
ctx.execute(pearl).arg("update").status_checked()
}
pub fn run_pyenv(ctx: &ExecutionContext) -> Result<()> {
@@ -821,7 +809,7 @@ pub fn run_pyenv(ctx: &ExecutionContext) -> Result<()> {
return Err(SkipStep(t!("pyenv-update plugin is not installed").to_string()).into());
}
ctx.run_type().execute(pyenv).arg("update").status_checked()
ctx.execute(pyenv).arg("update").status_checked()
}
pub fn run_sdkman(ctx: &ExecutionContext) -> Result<()> {
@@ -850,34 +838,25 @@ pub fn run_sdkman(ctx: &ExecutionContext) -> Result<()> {
if selfupdate_enabled == "true" {
let cmd_selfupdate = format!("source {} && sdk selfupdate", &sdkman_init_path);
ctx.run_type()
.execute(&bash)
ctx.execute(&bash)
.args(["-c", cmd_selfupdate.as_str()])
.status_checked()?;
}
let cmd_update = format!("source {} && sdk update", &sdkman_init_path);
ctx.run_type()
.execute(&bash)
.args(["-c", cmd_update.as_str()])
.status_checked()?;
ctx.execute(&bash).args(["-c", cmd_update.as_str()]).status_checked()?;
let cmd_upgrade = format!("source {} && sdk upgrade", &sdkman_init_path);
ctx.run_type()
.execute(&bash)
.args(["-c", cmd_upgrade.as_str()])
.status_checked()?;
ctx.execute(&bash).args(["-c", cmd_upgrade.as_str()]).status_checked()?;
if ctx.config().cleanup() {
let cmd_flush_archives = format!("source {} && sdk flush archives", &sdkman_init_path);
ctx.run_type()
.execute(&bash)
ctx.execute(&bash)
.args(["-c", cmd_flush_archives.as_str()])
.status_checked()?;
let cmd_flush_temp = format!("source {} && sdk flush temp", &sdkman_init_path);
ctx.run_type()
.execute(&bash)
ctx.execute(&bash)
.args(["-c", cmd_flush_temp.as_str()])
.status_checked()?;
}
@@ -898,7 +877,7 @@ pub fn run_bun_packages(ctx: &ExecutionContext) -> Result<()> {
return Ok(());
}
ctx.run_type().execute(bun).args(["-g", "update"]).status_checked()
ctx.execute(bun).args(["-g", "update"]).status_checked()
}
/// Update dotfiles with `rcm(7)`.
@@ -908,14 +887,14 @@ pub fn run_rcm(ctx: &ExecutionContext) -> Result<()> {
let rcup = require("rcup")?;
print_separator("rcm");
ctx.run_type().execute(rcup).arg("-v").status_checked()
ctx.execute(rcup).arg("-v").status_checked()
}
pub fn run_maza(ctx: &ExecutionContext) -> Result<()> {
let maza = require("maza")?;
print_separator("maza");
ctx.run_type().execute(maza).arg("update").status_checked()
ctx.execute(maza).arg("update").status_checked()
}
pub fn reboot() -> Result<()> {

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

@@ -21,11 +21,11 @@ pub fn run_chocolatey(ctx: &ExecutionContext) -> Result<()> {
let mut command = match ctx.sudo() {
Some(sudo) => {
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.arg(choco);
command
}
None => ctx.run_type().execute(choco),
None => ctx.execute(choco),
};
command.args(["upgrade", "all"]);
@@ -42,22 +42,19 @@ pub fn run_winget(ctx: &ExecutionContext) -> Result<()> {
print_separator("winget");
ctx.run_type()
.execute(&winget)
.args(["source", "update"])
.status_checked()?;
ctx.execute(&winget).args(["source", "update"]).status_checked()?;
let mut command = if ctx.config().winget_use_sudo() {
match ctx.sudo() {
Some(sudo) => {
let mut command = ctx.run_type().execute(sudo);
let mut command = ctx.execute(sudo);
command.arg(winget);
command
}
None => ctx.run_type().execute(winget),
None => ctx.execute(winget),
}
} else {
ctx.run_type().execute(winget)
ctx.execute(winget)
};
let mut args = vec!["upgrade", "--all"];
@@ -75,15 +72,12 @@ pub fn run_scoop(ctx: &ExecutionContext) -> Result<()> {
print_separator("Scoop");
ctx.run_type().execute(&scoop).args(["update"]).status_checked()?;
ctx.run_type().execute(&scoop).args(["update", "*"]).status_checked()?;
ctx.execute(&scoop).args(["update"]).status_checked()?;
ctx.execute(&scoop).args(["update", "*"]).status_checked()?;
if ctx.config().cleanup() {
ctx.run_type().execute(&scoop).args(["cleanup", "*"]).status_checked()?;
ctx.run_type()
.execute(&scoop)
.args(["cache", "rm", "-a"])
.status_checked()?
ctx.execute(&scoop).args(["cleanup", "*"]).status_checked()?;
ctx.execute(&scoop).args(["cache", "rm", "-a"]).status_checked()?
}
Ok(())
}
@@ -97,7 +91,7 @@ pub fn update_wsl(ctx: &ExecutionContext) -> Result<()> {
print_separator(t!("Update WSL"));
let mut wsl_command = ctx.run_type().execute(wsl);
let mut wsl_command = ctx.execute(wsl);
wsl_command.args(["--update"]);
if ctx.config().wsl_update_pre_release() {
@@ -153,7 +147,7 @@ fn upgrade_wsl_distribution(wsl: &Path, dist: &str, ctx: &ExecutionContext) -> R
.trim_end()
.to_owned();
let mut command = ctx.run_type().execute(wsl);
let mut command = ctx.execute(wsl);
// The `arg` method automatically quotes its arguments.
// This means we can't append additional arguments to `topgrade` in WSL