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

Add CommandExt trait (#146)

Browse Source 
* Color CI output

* Improve `CommandExt`

* Add comments explaining `#[allow]`s

* Remove useless `dead_code` annotation

* Improve error messages

* Print errors when running a shell errors

* fixup! Remove useless `dead_code` annotation
This commit is contained in:
Rebecca Turner
2022-11-08 05:54:35 -05:00
committed by Thomas Schönauer
parent bd34a3bcd4
commit e84173be8f
32 changed files with 822 additions and 558 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
src/steps/generic.rs
View File

@@ -5,13 +5,14 @@ use std::process::Command;
use std::{env, path::Path};
use std::{fs, io::Write};
use anyhow::Result;
use anyhow::{Context, Result};
use directories::BaseDirs;
use log::debug;
use tempfile::tempfile_in;
use crate::command::{CommandExt, Utf8Output};
use crate::execution_context::ExecutionContext;
use crate::executor::{CommandExt, ExecutorOutput, RunType};
use crate::executor::{ExecutorOutput, RunType};
use crate::terminal::{print_separator, shell};
use crate::utils::{self, require_option, PathExt};
use crate::{
@@ -53,20 +54,20 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
ctx.run_type()
.execute(cargo_update)
.args(["install-update", "--git", "--all"])
.check_run()
.status_checked()
}
pub fn run_flutter_upgrade(run_type: RunType) -> Result<()> {
let flutter = utils::require("flutter")?;
print_separator("Flutter");
run_type.execute(flutter).arg("upgrade").check_run()
run_type.execute(flutter).arg("upgrade").status_checked()
}
pub fn run_go(run_type: RunType) -> Result<()> {
let go = utils::require("go")?;
let go_output = run_type.execute(go).args(["env", "GOPATH"]).check_output()?;
let gopath = go_output.trim();
let go_output = run_type.execute(go).args(["env", "GOPATH"]).output_checked_utf8()?;
let gopath = go_output.stdout.trim();
let go_global_update = utils::require("go-global-update")
.unwrap_or_else(|_| PathBuf::from(gopath).join("bin/go-global-update"))
@@ -74,7 +75,7 @@ pub fn run_go(run_type: RunType) -> Result<()> {
print_separator("Go");
run_type.execute(go_global_update).check_run()
run_type.execute(go_global_update).status_checked()
}
pub fn run_gem(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -91,14 +92,15 @@ pub fn run_gem(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
command.arg("--user-install");
}
command.check_run()
command.status_checked()
}
pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
let haxelib = utils::require("haxelib")?;
let haxelib_dir =
PathBuf::from(std::str::from_utf8(&Command::new(&haxelib).arg("config").output()?.stdout)?.trim()).require()?;
PathBuf::from(std::str::from_utf8(&Command::new(&haxelib).arg("config").output_checked()?.stdout)?.trim())
.require()?;
let directory_writable = tempfile_in(&haxelib_dir).is_ok();
debug!("{:?} writable: {}", haxelib_dir, directory_writable);
@@ -115,7 +117,7 @@ pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
c
};
command.arg("update").check_run()
command.arg("update").status_checked()
}
pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
@@ -123,7 +125,10 @@ pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
print_separator("Sheldon");
ctx.run_type().execute(sheldon).args(["lock", "--update"]).check_run()
ctx.run_type()
.execute(sheldon)
.args(["lock", "--update"])
.status_checked()
}
pub fn run_fossil(run_type: RunType) -> Result<()> {
@@ -131,7 +136,7 @@ pub fn run_fossil(run_type: RunType) -> Result<()> {
print_separator("Fossil");
run_type.execute(fossil).args(["all", "sync"]).check_run()
run_type.execute(fossil).args(["all", "sync"]).status_checked()
}
pub fn run_micro(run_type: RunType) -> Result<()> {
@@ -139,7 +144,11 @@ pub fn run_micro(run_type: RunType) -> Result<()> {
print_separator("micro");
let stdout = run_type.execute(micro).args(["-plugin", "update"]).string_output()?;
let stdout = run_type
.execute(micro)
.args(["-plugin", "update"])
.output_checked_utf8()?
.stdout;
std::io::stdout().write_all(stdout.as_bytes())?;
if stdout.contains("Nothing to install / update") || stdout.contains("One or more plugins installed") {
@@ -160,7 +169,10 @@ pub fn run_apm(run_type: RunType) -> Result<()> {
print_separator("Atom Package Manager");
run_type.execute(apm).args(["upgrade", "--confirm=false"]).check_run()
run_type
.execute(apm)
.args(["upgrade", "--confirm=false"])
.status_checked()
}
pub fn run_rustup(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -169,10 +181,10 @@ pub fn run_rustup(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
print_separator("rustup");
if rustup.canonicalize()?.is_descendant_of(base_dirs.home_dir()) {
run_type.execute(&rustup).args(["self", "update"]).check_run()?;
run_type.execute(&rustup).args(["self", "update"]).status_checked()?;
}
run_type.execute(&rustup).arg("update").check_run()
run_type.execute(&rustup).arg("update").status_checked()
}
pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
@@ -181,8 +193,8 @@ pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
print_separator("choosenim");
let run_type = ctx.run_type();
run_type.execute(&choosenim).args(["update", "self"]).check_run()?;
run_type.execute(&choosenim).args(["update", "stable"]).check_run()
run_type.execute(&choosenim).args(["update", "self"]).status_checked()?;
run_type.execute(&choosenim).args(["update", "stable"]).status_checked()
}
pub fn run_krew_upgrade(run_type: RunType) -> Result<()> {
@@ -190,7 +202,7 @@ pub fn run_krew_upgrade(run_type: RunType) -> Result<()> {
print_separator("Krew");
run_type.execute(krew).args(["upgrade"]).check_run()
run_type.execute(krew).args(["upgrade"]).status_checked()
}
pub fn run_gcloud_components_update(run_type: RunType) -> Result<()> {
@@ -204,7 +216,7 @@ pub fn run_gcloud_components_update(run_type: RunType) -> Result<()> {
run_type
.execute(gcloud)
.args(["components", "update", "--quiet"])
.check_run()
.status_checked()
}
}
@@ -213,7 +225,7 @@ pub fn run_jetpack(run_type: RunType) -> Result<()> {
print_separator("Jetpack");
run_type.execute(jetpack).args(["global", "update"]).check_run()
run_type.execute(jetpack).args(["global", "update"]).status_checked()
}
pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
@@ -221,7 +233,7 @@ pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
print_separator("rtcl");
ctx.run_type().execute(rupdate).check_run()
ctx.run_type().execute(rupdate).status_checked()
}
pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
@@ -229,11 +241,11 @@ pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
print_separator("OCaml Package Manager");
ctx.run_type().execute(&opam).arg("update").check_run()?;
ctx.run_type().execute(&opam).arg("upgrade").check_run()?;
ctx.run_type().execute(&opam).arg("update").status_checked()?;
ctx.run_type().execute(&opam).arg("upgrade").status_checked()?;
if ctx.config().cleanup() {
ctx.run_type().execute(&opam).arg("clean").check_run()?;
ctx.run_type().execute(&opam).arg("clean").status_checked()?;
}
Ok(())
@@ -243,14 +255,17 @@ pub fn run_vcpkg_update(run_type: RunType) -> Result<()> {
let vcpkg = utils::require("vcpkg")?;
print_separator("vcpkg");
run_type.execute(vcpkg).args(["upgrade", "--no-dry-run"]).check_run()
run_type
.execute(vcpkg)
.args(["upgrade", "--no-dry-run"])
.status_checked()
}
pub fn run_pipx_update(run_type: RunType) -> Result<()> {
let pipx = utils::require("pipx")?;
print_separator("pipx");
run_type.execute(pipx).arg("upgrade-all").check_run()
run_type.execute(pipx).arg("upgrade-all").status_checked()
}
pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
@@ -258,10 +273,9 @@ pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
let output = Command::new("conda")
.args(["config", "--show", "auto_activate_base"])
.output()?;
let string_output = String::from_utf8(output.stdout)?;
debug!("Conda output: {}", string_output);
if string_output.contains("False") {
.output_checked_utf8()?;
debug!("Conda output: {}", output.stdout);
if output.stdout.contains("False") {
return Err(SkipStep("auto_activate_base is set to False".to_string()).into());
}
@@ -270,14 +284,14 @@ pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
ctx.run_type()
.execute(conda)
.args(["update", "--all", "-y"])
.check_run()
.status_checked()
}
pub fn run_pip3_update(run_type: RunType) -> Result<()> {
let python3 = utils::require("python3")?;
Command::new(&python3)
.args(["-m", "pip"])
.check_output()
.output_checked_utf8()
.map_err(|_| SkipStep("pip does not exists".to_string()))?;
print_separator("pip3");
@@ -289,7 +303,7 @@ pub fn run_pip3_update(run_type: RunType) -> Result<()> {
run_type
.execute(&python3)
.args(["-m", "pip", "install", "--upgrade", "--user", "pip"])
.check_run()
.status_checked()
}
pub fn run_stack_update(run_type: RunType) -> Result<()> {
@@ -303,14 +317,14 @@ pub fn run_stack_update(run_type: RunType) -> Result<()> {
let stack = utils::require("stack")?;
print_separator("stack");
run_type.execute(stack).arg("upgrade").check_run()
run_type.execute(stack).arg("upgrade").status_checked()
}
pub fn run_ghcup_update(run_type: RunType) -> Result<()> {
let ghcup = utils::require("ghcup")?;
print_separator("ghcup");
run_type.execute(ghcup).arg("upgrade").check_run()
run_type.execute(ghcup).arg("upgrade").status_checked()
}
pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
@@ -326,13 +340,11 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
let kpsewhich = utils::require("kpsewhich")?;
let tlmgr_directory = {
let mut d = PathBuf::from(
std::str::from_utf8(
&Command::new(kpsewhich)
.arg("-var-value=SELFAUTOPARENT")
.output()?
.stdout,
)?
.trim(),
&Command::new(kpsewhich)
.arg("-var-value=SELFAUTOPARENT")
.output_checked_utf8()?
.stdout
.trim(),
);
d.push("tlpkg");
d
@@ -355,7 +367,7 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
};
command.args(["update", "--self", "--all"]);
command.check_run()
command.status_checked()
}
pub fn run_chezmoi_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -364,7 +376,7 @@ pub fn run_chezmoi_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()>
print_separator("chezmoi");
run_type.execute(chezmoi).arg("update").check_run()
run_type.execute(chezmoi).arg("update").status_checked()
}
pub fn run_myrepos_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -378,27 +390,27 @@ pub fn run_myrepos_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()>
.arg("--directory")
.arg(base_dirs.home_dir())
.arg("checkout")
.check_run()?;
.status_checked()?;
run_type
.execute(&myrepos)
.arg("--directory")
.arg(base_dirs.home_dir())
.arg("update")
.check_run()
.status_checked()
}
pub fn run_custom_command(name: &str, command: &str, ctx: &ExecutionContext) -> Result<()> {
print_separator(name);
ctx.run_type().execute(shell()).arg("-c").arg(command).check_run()
ctx.run_type().execute(shell()).arg("-c").arg(command).status_checked()
}
pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
let composer = utils::require("composer")?;
let composer_home = Command::new(&composer)
.args(["global", "config", "--absolute", "--quiet", "home"])
.check_output()
.output_checked_utf8()
.map_err(|e| (SkipStep(format!("Error getting the composer directory: {}", e))))
.map(|s| PathBuf::from(s.trim()))?
.map(|s| PathBuf::from(s.stdout.trim()))?
.require()?;
if !composer_home.is_descendant_of(ctx.base_dirs().home_dir()) {
@@ -425,26 +437,22 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
.execute(ctx.sudo().as_ref().unwrap())
.arg(&composer)
.arg("self-update")
.check_run()?;
.status_checked()?;
}
} else {
ctx.run_type().execute(&composer).arg("self-update").check_run()?;
ctx.run_type().execute(&composer).arg("self-update").status_checked()?;
}
}
}
let output = Command::new(&composer).args(["global", "update"]).output()?;
let status = output.status;
if !status.success() {
return Err(TopgradeError::ProcessFailed(status).into());
}
let stdout = String::from_utf8(output.stdout)?;
let stderr = String::from_utf8(output.stderr)?;
print!("{}\n{}", stdout, stderr);
if stdout.contains("valet") || stderr.contains("valet") {
if let Some(valet) = utils::which("valet") {
ctx.run_type().execute(valet).arg("install").check_run()?;
let output = ctx.run_type().execute(&composer).args(["global", "update"]).output()?;
if let ExecutorOutput::Wet(output) = output {
let output: Utf8Output = output.try_into()?;
print!("{}\n{}", output.stdout, output.stderr);
if output.stdout.contains("valet") || output.stderr.contains("valet") {
if let Some(valet) = utils::which("valet") {
ctx.run_type().execute(valet).arg("install").status_checked()?;
}
}
}
@@ -454,18 +462,15 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
let dotnet = utils::require("dotnet")?;
let output = Command::new(dotnet).args(["tool", "list", "--global"]).output()?;
let output = Command::new(dotnet)
.args(["tool", "list", "--global"])
.output_checked_utf8()?;
if !output.status.success() {
return Err(SkipStep(format!("dotnet failed with exit code {:?}", output.status)).into());
}
let output = String::from_utf8(output.stdout)?;
if !output.starts_with("Package Id") {
if !output.stdout.starts_with("Package Id") {
return Err(SkipStep(String::from("dotnet did not output packages")).into());
}
let mut packages = output.split('\n').skip(2).filter(|line| !line.is_empty()).peekable();
let mut packages = output.stdout.lines().skip(2).filter(|line| !line.is_empty()).peekable();
if packages.peek().is_none() {
return Err(SkipStep(String::from("No dotnet global tools installed")).into());
@@ -478,7 +483,8 @@ pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
ctx.run_type()
.execute("dotnet")
.args(["tool", "update", package_name, "--global"])
.check_run()?;
.status_checked()
.with_context(|| format!("Failed to update .NET package {package_name}"))?;
}
Ok(())
@@ -489,26 +495,26 @@ pub fn run_raco_update(run_type: RunType) -> Result<()> {
print_separator("Racket Package Manager");
run_type.execute(raco).args(["pkg", "update", "--all"]).check_run()
run_type.execute(raco).args(["pkg", "update", "--all"]).status_checked()
}
pub fn bin_update(ctx: &ExecutionContext) -> Result<()> {
let bin = utils::require("bin")?;
print_separator("Bin");
ctx.run_type().execute(bin).arg("update").check_run()
ctx.run_type().execute(bin).arg("update").status_checked()
}
pub fn spicetify_upgrade(ctx: &ExecutionContext) -> Result<()> {
let spicetify = utils::require("spicetify")?;
print_separator("Spicetify");
ctx.run_type().execute(spicetify).arg("upgrade").check_run()
ctx.run_type().execute(spicetify).arg("upgrade").status_checked()
}
pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
let gh = utils::require("gh")?;
let result = Command::new(&gh).args(["extensions", "list"]).check_output();
let result = Command::new(&gh).args(["extensions", "list"]).output_checked_utf8();
if result.is_err() {
debug!("GH result {:?}", result);
return Err(SkipStep(String::from("GH failed")).into());
@@ -518,7 +524,7 @@ pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
ctx.run_type()
.execute(&gh)
.args(["extension", "upgrade", "--all"])
.check_run()
.status_checked()
}
pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
@@ -529,5 +535,5 @@ pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
ctx.run_type()
.execute(julia)
.args(["-e", "using Pkg; Pkg.update()"])
.check_run()
.status_checked()
}