pub struct InstallMethod {
pub method: &'static str,
pub package: &'static str,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum InstallTarget {
Project,
Machine,
}
impl InstallTarget {
pub const fn as_str(self) -> &'static str {
match self {
Self::Project => "project",
Self::Machine => "machine",
}
}
}
pub struct InstallCtx {
pub verbose: bool,
pub use_eatmydata: bool,
pub binary_pins: std::collections::BTreeMap<String, crate::tool_lock::BinaryPin>,
}
impl InstallMethod {
pub const fn new(method: &'static str, package: &'static str) -> Self {
Self { method, package }
}
pub fn targets(&self) -> &'static [InstallTarget] {
const MACHINE: &[InstallTarget] = &[InstallTarget::Machine];
const BOTH: &[InstallTarget] = &[InstallTarget::Project, InstallTarget::Machine];
match self.method {
"apt" | "dnf" | "pacman" | "brew" | "snap" => MACHINE,
"pip" | "uv" | "npm" | "cargo" | "gem" => BOTH,
"npm-ci" | "npm-install" => &[InstallTarget::Project],
"binary" => match binary_recipe(self.package) {
Some(BinaryRecipe {
archive: ArchiveKind::Deb { .. },
..
}) => MACHINE,
Some(_) => BOTH,
None => &[],
},
_ => &[],
}
}
pub fn command(&self) -> String {
let steps = describe(
self.method,
&[self.package],
&std::collections::BTreeMap::new(),
);
steps.first().map_or_else(
|| format!("({}) {}", self.method, self.package),
|argv| join_argv(argv),
)
}
}
impl ToolInfo {
pub fn preferred_target(&self) -> Option<InstallTarget> {
self.prefer.or_else(|| {
if self.project.is_some() {
Some(InstallTarget::Project)
} else if self.machine.is_some() {
Some(InstallTarget::Machine)
} else {
None
}
})
}
pub const fn slot(&self, target: InstallTarget) -> Option<&InstallMethod> {
match target {
InstallTarget::Project => self.project.as_ref(),
InstallTarget::Machine => self.machine.as_ref(),
}
}
pub fn preferred_method(&self) -> Option<&InstallMethod> {
self.slot(self.preferred_target()?)
}
pub fn methods(&self) -> Vec<(&InstallMethod, Vec<InstallTarget>)> {
let mut out: Vec<(&InstallMethod, Vec<InstallTarget>)> = Vec::new();
for target in [InstallTarget::Project, InstallTarget::Machine] {
if let Some(m) = self.slot(target) {
match out
.iter_mut()
.find(|(seen, _)| seen.method == m.method && seen.package == m.package)
{
Some((_, targets)) => targets.push(target),
None => out.push((m, vec![target])),
}
}
}
out.extend(self.alternatives.iter().map(|m| (m, Vec::new())));
out
}
}
pub fn describe(
method: &str,
packages: &[&str],
binary_pins: &std::collections::BTreeMap<String, crate::tool_lock::BinaryPin>,
) -> Vec<Vec<String>> {
let sudo = sudo_argv();
let strs = |parts: &[&str]| -> Vec<String> { parts.iter().map(|s| (*s).to_string()).collect() };
let prefix = |head: &[&str], tail: &[&str]| -> Vec<String> {
sudo.iter()
.chain(head.iter())
.chain(tail.iter())
.map(|s| (*s).to_string())
.collect()
};
match method {
"apt" => {
let update = prefix(&["apt-get", "update"], &[]);
let mut install = prefix(&["apt-get", "install", "-y"], &[]);
install.extend(packages.iter().map(|s| (*s).to_string()));
vec![update, install]
}
"dnf" => {
let mut argv = prefix(&["dnf", "install", "-y"], &[]);
argv.extend(packages.iter().map(|s| (*s).to_string()));
vec![argv]
}
"pacman" => {
let mut argv = prefix(&["pacman", "-S", "--noconfirm"], &[]);
argv.extend(packages.iter().map(|s| (*s).to_string()));
vec![argv]
}
"brew" => {
let mut argv = strs(&["brew", "install"]);
argv.extend(packages.iter().map(|s| (*s).to_string()));
vec![argv]
}
"snap" => {
let mut argv = prefix(&["snap", "install"], &[]);
argv.extend(packages.iter().map(|s| (*s).to_string()));
vec![argv]
}
"pip" => vec![{
let mut a = strs(&["pip", "install"]);
a.extend(packages.iter().map(|s| (*s).to_string()));
a
}],
"uv" => vec![{
let mut a = uv_pip_install_argv();
a.extend(packages.iter().map(|s| (*s).to_string()));
a
}],
"npm" => vec![{
let mut a = strs(&["npm", "install", "-g"]);
a.extend(packages.iter().map(|s| (*s).to_string()));
a
}],
"npm-ci" => vec![strs(&["npm", "ci"])],
"npm-install" => vec![strs(&["npm", "install"])],
"cargo" => vec![{
let mut a = cargo_install_argv();
a.extend(packages.iter().map(|s| (*s).to_string()));
a
}],
"gem" => vec![{
let mut a = gem_install_argv();
a.extend(packages.iter().map(|s| (*s).to_string()));
a
}],
"binary" => packages
.iter()
.flat_map(|p| describe_binary(p, binary_pins))
.collect(),
"manual" => packages
.iter()
.map(|p| vec!["# manual:".to_string(), (*p).to_string()])
.collect(),
_ => packages
.iter()
.map(|p| vec![format!("# unknown method '{}':", method), (*p).to_string()])
.collect(),
}
}
pub fn run(method: &str, packages: &[&str], ctx: &InstallCtx) -> anyhow::Result<()> {
use anyhow::Context as _;
use std::process::Command;
if packages.is_empty() {
return Ok(());
}
let exec = |argv: &[String]| -> anyhow::Result<()> {
if ctx.verbose {
println!("Running: {}", join_argv(argv));
}
let status = Command::new(&argv[0])
.args(&argv[1..])
.status()
.with_context(|| format!("failed to spawn: {}", join_argv(argv)))?;
if !status.success() {
anyhow::bail!(
"{} exited with code {}",
join_argv(argv),
status
.code()
.map_or_else(|| "unknown".to_string(), |c| c.to_string())
);
}
Ok(())
};
let sudo = sudo_argv();
let eatmydata: &[&str] = if ctx.use_eatmydata && which::which("eatmydata").is_ok() {
&["eatmydata"]
} else {
&[]
};
let pkgmgr_argv = |head: &[&str]| -> Vec<String> {
sudo.iter()
.chain(eatmydata.iter())
.chain(head.iter())
.map(|s| (*s).to_string())
.collect()
};
match method {
"apt" => {
let update = pkgmgr_argv(&["apt-get", "update"]);
exec(&update)?;
let mut argv = pkgmgr_argv(&["apt-get", "install", "-y"]);
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"dnf" => {
let mut argv = pkgmgr_argv(&["dnf", "install", "-y"]);
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"pacman" => {
let mut argv = pkgmgr_argv(&["pacman", "-S", "--noconfirm"]);
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"brew" => {
let mut argv = vec!["brew".to_string(), "install".to_string()];
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"snap" => {
let mut argv: Vec<String> = sudo
.iter()
.chain(["snap", "install"].iter())
.map(|s| (*s).to_string())
.collect();
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"pip" => {
let mut argv = vec!["pip".to_string(), "install".to_string()];
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"uv" => {
let mut argv = uv_pip_install_argv();
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"npm" => {
let mut argv = vec!["npm".to_string(), "install".to_string(), "-g".to_string()];
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"npm-ci" => exec(&["npm".to_string(), "ci".to_string()]),
"npm-install" => exec(&["npm".to_string(), "install".to_string()]),
"cargo" => {
let mut argv = cargo_install_argv();
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"gem" => {
let mut argv = gem_install_argv();
argv.extend(packages.iter().map(|s| (*s).to_string()));
exec(&argv)
}
"binary" => {
for pkg in packages {
run_binary(pkg, ctx)?;
}
Ok(())
}
"manual" => anyhow::bail!(
"method '{}' is manual-only — install these packages by hand: {}",
method,
packages.join(", ")
),
other => anyhow::bail!("unknown install method '{other}'"),
}
}
pub fn install_into_prefix(
pkg: &crate::tool_store::Package,
prefix: &std::path::Path,
ctx: &InstallCtx,
) -> anyhow::Result<()> {
let root = prefix.to_string_lossy();
let (name, version) = (pkg.name.as_str(), pkg.version.as_str());
let request = format!("{name}@{version}");
match pkg.method.as_str() {
"cargo" => exec_inherited_env(
&["cargo", "install", "--locked", "--root", &root, &request],
&[],
ctx.verbose,
),
"npm" => exec_inherited_env(
&["npm", "install", "--global", "--prefix", &root, &request],
&[],
ctx.verbose,
),
"gem" => {
let bin = prefix.join("bin");
exec_inherited_env(
&[
"gem",
"install",
"--install-dir",
&root,
"--bindir",
&bin.to_string_lossy(),
"--no-document",
"--version",
version,
name,
],
&[("GEM_HOME", &root), ("GEM_PATH", &root)],
ctx.verbose,
)
}
"binary" => install_binary_into_prefix(name, version, prefix, ctx),
other => anyhow::bail!("install method '{other}' does not install into a project"),
}
}
fn install_binary_into_prefix(
name: &str,
version: &str,
prefix: &std::path::Path,
ctx: &InstallCtx,
) -> anyhow::Result<()> {
use anyhow::Context as _;
let recipe = binary_recipe(name)
.ok_or_else(|| anyhow::anyhow!("no binary install recipe for '{name}'"))?;
let pin = ctx
.binary_pins
.get(name)
.with_context(|| format!("binary {name} has no rsconstruct.lock entry"))?;
let work = prefix.join(".work");
std::fs::create_dir_all(&work)
.with_context(|| format!("Failed to create {}", work.display()))?;
let fetched = fetch_binary(
&recipe,
&pin.url,
Some(&pin.sha256),
&work.to_string_lossy(),
ctx.verbose,
)?;
let payload = std::path::Path::new(&fetched.payload);
let sha = file_sha256(payload)?;
if version != format!("sha256-{sha}") {
anyhow::bail!(
"the executable unpacked from {} has sha256 {sha}, but rsconstruct.lock wants {version}",
pin.url
);
}
let bin = prefix.join("bin");
std::fs::create_dir_all(&bin).with_context(|| format!("Failed to create {}", bin.display()))?;
let dest = bin.join(recipe.dest);
std::fs::rename(payload, &dest).with_context(|| {
format!(
"Failed to move {} into place as {}",
payload.display(),
dest.display()
)
})?;
std::fs::remove_dir_all(&work).with_context(|| format!("Failed to remove {}", work.display()))
}
fn sudo_argv() -> &'static [&'static str] {
if crate::platform::needs_sudo() {
&["sudo"]
} else {
&[]
}
}
fn cargo_install_argv() -> Vec<String> {
vec![
"cargo".to_string(),
"install".to_string(),
"--locked".to_string(),
"--force".to_string(),
]
}
fn gem_install_argv() -> Vec<String> {
let mut argv = vec!["gem".to_string(), "install".to_string()];
if gem_needs_user_install() {
argv.push("--user-install".to_string());
}
argv
}
fn uv_pip_install_argv() -> Vec<String> {
let probe = python_probe();
uv_pip_install_argv_for(probe.in_venv, probe.user_prefix.as_deref())
}
fn uv_pip_install_argv_for(in_venv: bool, user_prefix: Option<&str>) -> Vec<String> {
let mut argv: Vec<String> = ["uv", "pip", "install", "--python", "python3"]
.iter()
.map(|s| (*s).to_string())
.collect();
if !in_venv {
argv.push("--system".to_string());
}
if let Some(user_base) = user_prefix {
argv.push("--prefix".to_string());
argv.push(user_base.to_string());
}
argv
}
#[derive(Clone, Default)]
struct PythonProbe {
in_venv: bool,
user_prefix: Option<String>,
prefix: Option<std::path::PathBuf>,
}
pub fn python_env_is_inside(root: &std::path::Path) -> bool {
let probe = python_probe();
let (Some(prefix), Ok(root)) = (probe.prefix, root.canonicalize()) else {
return false;
};
probe.in_venv && prefix.canonicalize().is_ok_and(|p| p.starts_with(&root))
}
fn python_probe() -> PythonProbe {
static PROBE: std::sync::OnceLock<PythonProbe> = std::sync::OnceLock::new();
PROBE
.get_or_init(|| {
let Ok(out) = std::process::Command::new("python3")
.args([
"-c",
"import sys, sysconfig, site; \
print(int(sys.prefix != sys.base_prefix)); \
print(sysconfig.get_path('purelib')); \
print(site.getuserbase()); \
print(sys.prefix)",
])
.output()
else {
return PythonProbe::default();
};
if !out.status.success() {
return PythonProbe::default();
}
let stdout = String::from_utf8_lossy(&out.stdout);
let mut lines = stdout.lines();
let in_venv = lines.next().is_some_and(|l| l == "1");
let purelib = lines.next().map_or("", str::trim);
let user_base = lines.next().map_or("", str::trim);
let prefix = lines
.next()
.map(str::trim)
.filter(|p| !p.is_empty())
.map(std::path::PathBuf::from);
let user_prefix = if in_venv
|| purelib.is_empty()
|| user_base.is_empty()
|| nearest_existing_ancestor_is_writable(std::path::Path::new(purelib))
{
None
} else {
Some(user_base.to_string())
};
PythonProbe {
in_venv,
user_prefix,
prefix,
}
})
.clone()
}
fn gem_needs_user_install() -> bool {
static NEEDS: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
*NEEDS.get_or_init(|| {
if crate::platform::is_root() {
return false;
}
let Ok(out) = std::process::Command::new("gem")
.args(["env", "gemdir"])
.output()
else {
return false;
};
if !out.status.success() {
return false;
}
let stdout = String::from_utf8_lossy(&out.stdout);
let gemdir = std::path::Path::new(stdout.trim());
if gemdir.as_os_str().is_empty() {
return false;
}
!nearest_existing_ancestor_is_writable(gemdir)
})
}
fn nearest_existing_ancestor_is_writable(path: &std::path::Path) -> bool {
let mut p = path;
loop {
if p.exists() {
return crate::platform::path_is_writable(p);
}
match p.parent() {
Some(parent) => p = parent,
None => return false,
}
}
}
pub fn augment_path_with_node_modules_bin() {
let Ok(cwd) = std::env::current_dir() else {
return;
};
let bin = cwd.join("node_modules").join(".bin");
if !bin.is_dir() {
return;
}
let path = std::env::var_os("PATH").unwrap_or_default();
if let Some(new_path) = path_with_prepended_dir(&path, &bin) {
crate::platform::set_env("PATH", &new_path);
}
}
pub fn path_with_prepended_dir(
path: &std::ffi::OsStr,
dir: &std::path::Path,
) -> Option<std::ffi::OsString> {
let existing: Vec<std::path::PathBuf> = std::env::split_paths(path).collect();
if existing.first().is_some_and(|first| first == dir) {
return None;
}
let rest = existing.into_iter().filter(|p| p != dir);
std::env::join_paths(std::iter::once(dir.to_path_buf()).chain(rest)).ok()
}
pub fn augment_path_with_user_gem_bins() {
let Some(home) = std::env::var_os("HOME") else {
return;
};
let gem_home = std::env::var_os("GEM_HOME");
let dirs = user_gem_bin_dirs(std::path::Path::new(&home), gem_home.as_deref());
if dirs.is_empty() {
return;
}
let path = std::env::var_os("PATH").unwrap_or_default();
if let Some(new_path) = path_with_appended_dirs(&path, &dirs) {
crate::platform::set_env("PATH", &new_path);
}
}
fn user_gem_bin_dirs(
home: &std::path::Path,
gem_home: Option<&std::ffi::OsStr>,
) -> Vec<std::path::PathBuf> {
let mut dirs = Vec::new();
if let Some(gem_home) = gem_home {
let bin = std::path::Path::new(gem_home).join("bin");
if bin.is_dir() {
dirs.push(bin);
}
}
for base in [home.join(".gem/ruby"), home.join(".local/share/gem/ruby")] {
let Ok(entries) = std::fs::read_dir(&base) else {
continue;
};
let mut versions: Vec<std::path::PathBuf> = entries
.flatten()
.map(|e| e.path().join("bin"))
.filter(|p| p.is_dir())
.collect();
versions.sort();
dirs.append(&mut versions);
}
dirs
}
fn path_with_appended_dirs(
path: &std::ffi::OsStr,
dirs: &[std::path::PathBuf],
) -> Option<std::ffi::OsString> {
let existing: Vec<std::path::PathBuf> = std::env::split_paths(path).collect();
let missing: Vec<std::path::PathBuf> = dirs
.iter()
.filter(|d| !existing.contains(d))
.cloned()
.collect();
if missing.is_empty() {
return None;
}
std::env::join_paths(existing.into_iter().chain(missing)).ok()
}
fn join_argv(argv: &[String]) -> String {
argv.join(" ")
}
const INSTALL_WORK_DIR: &str = "/tmp";
fn describe_binary(
pkg: &str,
binary_pins: &std::collections::BTreeMap<String, crate::tool_lock::BinaryPin>,
) -> Vec<Vec<String>> {
let Some(recipe) = binary_recipe(pkg) else {
return vec![vec![format!("# unknown binary recipe '{pkg}'")]];
};
let mut steps: Vec<Vec<String>> = Vec::new();
let pin = binary_pins.get(pkg);
let url = match (pin, &recipe.archive) {
(Some(pin), _) => pin.url.clone(),
(
None,
ArchiveKind::Deb {
source:
DebSource::GithubRelease {
repo,
asset_pattern,
},
},
) => {
steps.push(vec![format!(
"# resolve latest '{asset_pattern}' .deb asset from {repo}"
)]);
"<resolved-asset-url>".to_string()
}
(
None,
ArchiveKind::Deb {
source: DebSource::Url(url),
},
) => (*url).to_string(),
(None, _) => recipe.url.to_string(),
};
let plan = fetch_plan(&recipe, &url, INSTALL_WORK_DIR);
steps.push(plan.curl);
if let Some(pin) = pin {
steps.push(vec![format!(
"# sha256 of {} must be {} (rsconstruct.lock)",
plan.download, pin.sha256
)]);
}
steps.extend(plan.unpack.iter().map(Step::argv));
steps.push(install_argv(&recipe, &plan.payload));
steps
}
enum Step {
Exec(Vec<String>),
Rename {
from: String,
to: String,
},
Remove(String),
MakeExecutable(String),
}
impl Step {
fn argv(&self) -> Vec<String> {
match self {
Self::Exec(argv) => argv.clone(),
Self::Rename { from, to } => vec!["mv".to_string(), from.clone(), to.clone()],
Self::Remove(path) => vec!["rm".to_string(), path.clone()],
Self::MakeExecutable(path) => {
vec!["chmod".to_string(), "+x".to_string(), path.clone()]
}
}
}
fn run(&self, verbose: bool) -> anyhow::Result<()> {
use anyhow::Context as _;
match self {
Self::Exec(argv) => exec_inherited(
&argv.iter().map(String::as_str).collect::<Vec<_>>(),
verbose,
),
Self::Rename { from, to } => {
std::fs::rename(from, to).with_context(|| format!("rename {from} -> {to}"))
}
Self::Remove(path) => {
std::fs::remove_file(path).with_context(|| format!("remove {path}"))
}
Self::MakeExecutable(path) => {
crate::platform::set_permissions_mode(std::path::Path::new(path), 0o755)
.with_context(|| format!("chmod +x {path}"))
}
}
}
}
struct FetchPlan {
download: String,
curl: Vec<String>,
unpack: Vec<Step>,
payload: String,
}
fn fetch_plan(recipe: &BinaryRecipe, url: &str, base: &str) -> FetchPlan {
let dest = recipe.dest;
let final_tmp = format!("{base}/{dest}");
let exec = |parts: &[&str]| Step::Exec(parts.iter().map(|s| (*s).to_string()).collect());
let (download, unpack) = match recipe.archive {
ArchiveKind::Deb { .. } => {
let download = format!("{base}/{dest}.deb");
return FetchPlan {
curl: crate::download::curl_argv(url, &download),
payload: download.clone(),
download,
unpack: Vec::new(),
};
}
ArchiveKind::TarGz { inner } | ArchiveKind::Zip { inner } => {
let download = format!("{base}/{dest}.dl");
let extract = match recipe.archive {
ArchiveKind::TarGz { .. } => exec(&["tar", "-xzf", &download, "-C", base, inner]),
_ => exec(&["unzip", "-o", &download, inner, "-d", base]),
};
let mut unpack = vec![extract];
let inner_path = format!("{base}/{inner}");
if inner_path != final_tmp {
unpack.push(Step::Rename {
from: inner_path,
to: final_tmp.clone(),
});
}
unpack.push(Step::Remove(download.clone()));
(download, unpack)
}
ArchiveKind::Gunzip => {
let download = format!("{base}/{dest}.dl");
let gz = format!("{download}.gz");
let unpack = vec![
Step::Rename {
from: download.clone(),
to: gz.clone(),
},
exec(&["gunzip", "-f", &gz]),
Step::Rename {
from: download.clone(),
to: final_tmp.clone(),
},
];
(download, unpack)
}
ArchiveKind::Raw => {
let download = format!("{base}/{dest}.dl");
let unpack = vec![Step::Rename {
from: download.clone(),
to: final_tmp.clone(),
}];
(download, unpack)
}
};
let mut unpack = unpack;
unpack.push(Step::MakeExecutable(final_tmp.clone()));
FetchPlan {
curl: crate::download::curl_argv(url, &download),
download,
unpack,
payload: final_tmp,
}
}
fn install_argv(recipe: &BinaryRecipe, payload: &str) -> Vec<String> {
let mut argv: Vec<String> = sudo_argv().iter().map(|s| (*s).to_string()).collect();
if matches!(recipe.archive, ArchiveKind::Deb { .. }) {
argv.extend(["apt-get", "install", "-y", payload].map(str::to_string));
} else {
argv.extend([
"mv".to_string(),
payload.to_string(),
format!("/usr/local/bin/{}", recipe.dest),
]);
}
argv
}
fn latest_github_release(repo: &str) -> anyhow::Result<serde_json::Value> {
crate::download::get_json(&format!(
"https://api.github.com/repos/{repo}/releases/latest"
))
}
const GITHUB_LATEST_DOWNLOAD: &str = "/releases/latest/download/";
fn pin_github_latest_url(url: &str, tag: &str) -> Option<String> {
let rest = url.strip_prefix("https://github.com/")?;
let at = rest.find(GITHUB_LATEST_DOWNLOAD)?;
let repo = &rest[..at];
let asset = &rest[at + GITHUB_LATEST_DOWNLOAD.len()..];
Some(format!(
"https://github.com/{repo}/releases/download/{tag}/{asset}"
))
}
fn github_repo_of(url: &str) -> Option<&str> {
let rest = url.strip_prefix("https://github.com/")?;
let owner_end = rest.find('/')?;
let repo_end = rest[owner_end + 1..]
.find('/')
.map_or(rest.len(), |i| owner_end + 1 + i);
Some(&rest[..repo_end])
}
fn resolve_latest_deb_asset(repo: &str, asset_pattern: &str) -> anyhow::Result<String> {
use anyhow::Context as _;
let release = latest_github_release(repo)?;
release["assets"]
.as_array()
.with_context(|| format!("GitHub release for {repo} has no 'assets' array"))?
.iter()
.find_map(|a| {
let name = a["name"].as_str()?;
let is_deb = std::path::Path::new(name)
.extension()
.is_some_and(|ext| ext.eq_ignore_ascii_case("deb"));
(name.contains(asset_pattern) && is_deb)
.then(|| a["browser_download_url"].as_str())?
.map(std::string::ToString::to_string)
})
.with_context(|| {
format!("No .deb asset matching '{asset_pattern}' in the latest {repo} release")
})
}
fn exec_inherited(argv: &[&str], verbose: bool) -> anyhow::Result<()> {
exec_inherited_env(argv, &[], verbose)
}
fn exec_inherited_env(argv: &[&str], env: &[(&str, &str)], verbose: bool) -> anyhow::Result<()> {
use anyhow::Context as _;
if verbose {
println!("Running: {}", argv.join(" "));
}
let status = std::process::Command::new(argv[0])
.args(&argv[1..])
.envs(env.iter().copied())
.status()
.with_context(|| format!("failed to spawn: {}", argv.join(" ")))?;
if !status.success() {
anyhow::bail!(
"{} exited with code {}",
argv.join(" "),
status
.code()
.map_or_else(|| "unknown".to_string(), |c| c.to_string())
);
}
Ok(())
}
pub fn file_sha256(path: &std::path::Path) -> anyhow::Result<String> {
use anyhow::Context as _;
use sha2::Digest as _;
let mut file = std::fs::File::open(path)
.with_context(|| format!("Failed to open {} for hashing", path.display()))?;
let mut hasher = sha2::Sha256::new();
std::io::copy(&mut file, &mut hasher)
.with_context(|| format!("Failed to read {} for hashing", path.display()))?;
Ok(hex::encode(hasher.finalize()))
}
#[derive(Debug)]
struct FetchedBinary {
download_sha256: String,
payload: String,
}
fn fetch_binary(
recipe: &BinaryRecipe,
url: &str,
expected_sha256: Option<&str>,
base: &str,
verbose: bool,
) -> anyhow::Result<FetchedBinary> {
let plan = fetch_plan(recipe, url, base);
exec_inherited(
&plan.curl.iter().map(String::as_str).collect::<Vec<_>>(),
verbose,
)?;
let download_sha256 = file_sha256(std::path::Path::new(&plan.download))?;
if let Some(expected) = expected_sha256
&& expected != download_sha256
{
std::fs::remove_file(&plan.download).ok();
anyhow::bail!(
"{url} does not match rsconstruct.lock: sha256 {download_sha256}, locked {expected}"
);
}
for step in &plan.unpack {
step.run(verbose)?;
}
Ok(FetchedBinary {
download_sha256,
payload: plan.payload,
})
}
fn unpinned_binary_url(recipe: &BinaryRecipe) -> anyhow::Result<String> {
match recipe.archive {
ArchiveKind::Deb {
source:
DebSource::GithubRelease {
repo,
asset_pattern,
},
} => resolve_latest_deb_asset(repo, asset_pattern),
ArchiveKind::Deb {
source: DebSource::Url(url),
} => Ok(url.to_string()),
_ => Ok(recipe.url.to_string()),
}
}
fn run_binary(pkg: &str, ctx: &InstallCtx) -> anyhow::Result<()> {
let recipe = binary_recipe(pkg)
.ok_or_else(|| anyhow::anyhow!("no binary install recipe for '{pkg}'"))?;
let pin = ctx.binary_pins.get(pkg);
let url = match pin {
Some(pin) => pin.url.clone(),
None => unpinned_binary_url(&recipe)?,
};
let fetched = fetch_binary(
&recipe,
&url,
pin.map(|p| p.sha256.as_str()),
INSTALL_WORK_DIR,
ctx.verbose,
)?;
let argv = install_argv(&recipe, &fetched.payload);
let result = exec_inherited(
&argv.iter().map(String::as_str).collect::<Vec<_>>(),
ctx.verbose,
);
if matches!(recipe.archive, ArchiveKind::Deb { .. }) {
std::fs::remove_file(&fetched.payload).ok();
}
result
}
pub fn binary_is_pinnable(pkg: &str) -> bool {
binary_recipe(pkg).is_some_and(|r| {
!matches!(
r.archive,
ArchiveKind::Deb {
source: DebSource::Url(_)
}
)
})
}
pub fn binary_is_repo_local(pkg: &str) -> bool {
binary_recipe(pkg).is_some_and(|r| !matches!(r.archive, ArchiveKind::Deb { .. }))
}
pub fn lock_binary(
ctx: &crate::build_context::BuildContext,
pkg: &str,
verbose: bool,
) -> anyhow::Result<crate::tool_lock::BinaryPin> {
use anyhow::Context as _;
let recipe = binary_recipe(pkg)
.ok_or_else(|| anyhow::anyhow!("no binary install recipe for '{pkg}'"))?;
if !binary_is_pinnable(pkg) {
anyhow::bail!("the '{pkg}' binary is a vendor URL with no versioned release to lock");
}
let url = if recipe.url.contains(GITHUB_LATEST_DOWNLOAD) {
let repo = github_repo_of(recipe.url)
.with_context(|| format!("cannot tell the GitHub repo of {}", recipe.url))?;
let release = latest_github_release(repo)?;
let tag = release["tag_name"]
.as_str()
.with_context(|| format!("the latest {repo} release has no tag_name"))?;
pin_github_latest_url(recipe.url, tag)
.with_context(|| format!("cannot pin {} to release {tag}", recipe.url))?
} else {
unpinned_binary_url(&recipe)?
};
let base = std::env::temp_dir().join(format!("rsconstruct-lock-{}-{pkg}", std::process::id()));
std::fs::create_dir_all(&base)
.with_context(|| format!("Failed to create {}", base.display()))?;
let result = (|| {
let fetched = fetch_binary(&recipe, &url, None, &base.to_string_lossy(), verbose)?;
let mut pin = crate::tool_lock::BinaryPin {
url: url.clone(),
sha256: fetched.download_sha256,
executable_sha256: None,
deb_package: None,
deb_version: None,
};
if matches!(recipe.archive, ArchiveKind::Deb { .. }) {
let mut cmd = std::process::Command::new("dpkg-deb");
cmd.args(["-f", &fetched.payload, "Package", "Version"]);
let out = crate::processor::run_command_capture(ctx, &cmd)
.with_context(|| format!("failed to run `dpkg-deb -f {}`", fetched.payload))?;
if !out.status.success() {
anyhow::bail!(
"`dpkg-deb -f {}` failed: {}",
fetched.payload,
String::from_utf8_lossy(&out.stderr).trim()
);
}
let fields = String::from_utf8_lossy(&out.stdout).into_owned();
let field = |name: &str| {
fields.lines().find_map(|l| {
l.strip_prefix(name)
.and_then(|v| v.strip_prefix(':'))
.map(|v| v.trim().to_string())
})
};
pin.deb_package = field("Package");
pin.deb_version = field("Version");
if pin.deb_package.is_none() || pin.deb_version.is_none() {
anyhow::bail!("{url}: the .deb names no Package/Version");
}
} else {
pin.executable_sha256 = Some(file_sha256(std::path::Path::new(&fetched.payload))?);
}
Ok(pin)
})();
std::fs::remove_dir_all(&base).ok();
result
}
struct BinaryRecipe {
url: &'static str,
archive: ArchiveKind,
dest: &'static str,
}
enum ArchiveKind {
TarGz {
inner: &'static str,
},
Zip {
inner: &'static str,
},
Gunzip,
Raw,
Deb {
source: DebSource,
},
}
enum DebSource {
GithubRelease {
repo: &'static str,
asset_pattern: &'static str,
},
Url(&'static str),
}
fn binary_recipe(pkg: &str) -> Option<BinaryRecipe> {
match pkg {
"oxlint" => Some(BinaryRecipe {
url: "https://github.com/oxc-project/oxc/releases/download/oxlint_v1.86.0/oxlint-x86_64-unknown-linux-gnu.tar.gz",
archive: ArchiveKind::TarGz {
inner: "oxlint-x86_64-unknown-linux-gnu",
},
dest: "oxlint",
}),
"rumdl" => Some(BinaryRecipe {
url: "https://github.com/rvben/rumdl/releases/download/v0.2.66/rumdl-v0.2.66-x86_64-unknown-linux-gnu.tar.gz",
archive: ArchiveKind::TarGz { inner: "rumdl" },
dest: "rumdl",
}),
"zola" => Some(BinaryRecipe {
url: "https://github.com/getzola/zola/releases/download/v0.23.3/zola-v0.23.3-x86_64-unknown-linux-gnu.tar.gz",
archive: ArchiveKind::TarGz { inner: "zola" },
dest: "zola",
}),
"taplo" => Some(BinaryRecipe {
url: "https://github.com/tamasfe/taplo/releases/latest/download/taplo-linux-x86_64.gz",
archive: ArchiveKind::Gunzip,
dest: "taplo",
}),
"actionlint" => Some(BinaryRecipe {
url: "https://github.com/rhysd/actionlint/releases/download/v1.7.12/actionlint_1.7.12_linux_amd64.tar.gz",
archive: ArchiveKind::TarGz {
inner: "actionlint",
},
dest: "actionlint",
}),
"selene" => Some(BinaryRecipe {
url: "https://github.com/Kampfkarren/selene/releases/download/0.32.0/selene-0.32.0-linux.zip",
archive: ArchiveKind::Zip { inner: "selene" },
dest: "selene",
}),
"hadolint" => Some(BinaryRecipe {
url: "https://github.com/hadolint/hadolint/releases/latest/download/hadolint-Linux-x86_64",
archive: ArchiveKind::Raw,
dest: "hadolint",
}),
"biome" => Some(BinaryRecipe {
url: "https://github.com/biomejs/biome/releases/latest/download/biome-linux-x64",
archive: ArchiveKind::Raw,
dest: "biome",
}),
"checkpatch.pl" => Some(BinaryRecipe {
url: "https://raw.githubusercontent.com/torvalds/linux/e5f92606156a6a823992294d214c285b49cd72e9/scripts/checkpatch.pl",
archive: ArchiveKind::Raw,
dest: "checkpatch.pl",
}),
"drawio" => Some(BinaryRecipe {
url: "https://github.com/jgraph/drawio-desktop/releases/latest",
archive: ArchiveKind::Deb {
source: DebSource::GithubRelease {
repo: "jgraph/drawio-desktop",
asset_pattern: "amd64",
},
},
dest: "drawio",
}),
"google-chrome-stable" => Some(BinaryRecipe {
url: "https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb",
archive: ArchiveKind::Deb {
source: DebSource::Url(
"https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb",
),
},
dest: "google-chrome",
}),
_ => None,
}
}
pub struct ToolInfo {
pub name: &'static str,
pub runtime: &'static str,
pub project: Option<InstallMethod>,
pub machine: Option<InstallMethod>,
pub alternatives: &'static [InstallMethod],
pub prefer: Option<InstallTarget>,
}
pub static TOOLS: &[ToolInfo] = &[
ToolInfo {
name: "uv",
runtime: "python",
project: Some(InstallMethod::new("pip", "uv")),
machine: Some(InstallMethod::new("pip", "uv")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "python3",
runtime: "python",
project: None,
machine: Some(InstallMethod::new("apt", "python3")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "node",
runtime: "node",
project: None,
machine: Some(InstallMethod::new("apt", "nodejs")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "ruby",
runtime: "ruby",
project: None,
machine: Some(InstallMethod::new("apt", "ruby")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "cargo",
runtime: "rust",
project: None,
machine: Some(InstallMethod::new("apt", "cargo")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "perl",
runtime: "perl",
project: None,
machine: Some(InstallMethod::new("apt", "perl")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "perltidy",
runtime: "perl",
project: None,
machine: Some(InstallMethod::new("apt", "perltidy")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "arm-none-eabi-gcc",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "gcc-arm-none-eabi")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "arm-none-eabi-ar",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "binutils-arm-none-eabi")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "arm-none-eabi-objcopy",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "binutils-arm-none-eabi")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "gcc",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "gcc")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "g++",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "g++")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "clang",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "clang")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "clang++",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "clang")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "make",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "make")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "pdflatex",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "texlive-latex-base")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "dot",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "graphviz")),
alternatives: &[],
prefer: None,
},
ToolInfo {
name: "clojure",
runtime: "jvm",
project: None,
machine: Some(InstallMethod::new("apt", "clojure")),
alternatives: &[InstallMethod::new("brew", "clojure/tools/clojure")],
prefer: None,
},
ToolInfo {
name: "true",
runtime: "system",
project: None,
machine: Some(InstallMethod::new("apt", "coreutils")),
alternatives: &[],
prefer: None,
},
];
inventory::collect!(ToolInfo);
pub fn all_tools() -> impl Iterator<Item = &'static ToolInfo> {
TOOLS.iter().chain(inventory::iter::<ToolInfo>)
}
pub fn tool_info(tool: &str) -> Option<&'static ToolInfo> {
all_tools().find(|t| t.name == tool)
}
#[cfg(test)]
mod registry_tests {
use super::*;
#[test]
fn tool_names_are_unique_across_central_and_submitted() {
let mut seen = std::collections::HashSet::new();
let mut dups: Vec<&str> = Vec::new();
for t in all_tools() {
if !seen.insert(t.name) {
dups.push(t.name);
}
}
dups.sort_unstable();
assert!(dups.is_empty(), "duplicate tool registry entries: {dups:?}");
}
#[test]
fn every_slot_holds_a_method_for_its_target() {
let mut bad: Vec<String> = Vec::new();
for t in all_tools() {
for target in [InstallTarget::Project, InstallTarget::Machine] {
if let Some(m) = t.slot(target)
&& !m.targets().contains(&target)
{
bad.push(format!(
"{}: {} slot holds {} {}, which cannot install to the {}",
t.name,
target.as_str(),
m.method,
m.package,
target.as_str(),
));
}
}
if t.project.is_none() && t.machine.is_none() {
bad.push(format!(
"{}: neither a project nor a machine install",
t.name
));
}
if let Some(prefer) = t.prefer {
let default = if t.project.is_some() {
InstallTarget::Project
} else {
InstallTarget::Machine
};
if t.slot(prefer).is_none() {
bad.push(format!(
"{}: prefers the {}, but has no {} install",
t.name,
prefer.as_str(),
prefer.as_str(),
));
} else if prefer == default {
bad.push(format!(
"{}: `prefer` repeats the default ({}); leave it None",
t.name,
prefer.as_str(),
));
}
}
}
assert!(bad.is_empty(), "install slots: {bad:#?}");
}
#[test]
fn alternatives_are_known_and_distinct_from_the_slots() {
let mut bad: Vec<String> = Vec::new();
for t in all_tools() {
for alt in t.alternatives {
if alt.targets().is_empty() {
bad.push(format!(
"{}: alternative {} {} installs nowhere",
t.name, alt.method, alt.package
));
}
let repeats = [t.project.as_ref(), t.machine.as_ref()]
.into_iter()
.flatten()
.any(|m| m.method == alt.method && m.package == alt.package);
if repeats {
bad.push(format!(
"{}: alternative {} {} repeats a slot",
t.name, alt.method, alt.package
));
}
}
}
assert!(bad.is_empty(), "install alternatives: {bad:#?}");
}
fn submitted_tool_names(source: &str) -> Vec<&str> {
source
.split("crate::tools::ToolInfo {")
.skip(1)
.filter_map(|rest| rest.split_once("name: \"")?.1.split_once('"'))
.map(|(name, _)| name)
.collect()
}
#[test]
fn central_registry_holds_only_unowned_tools() {
let processors = crate::builder::create_all_default_processors().unwrap();
let mut runners: std::collections::BTreeMap<String, Vec<String>> =
std::collections::BTreeMap::new();
for (pname, processor) in &processors {
for tool in processor.required_tools() {
runners.entry(tool).or_default().push(pname.clone());
}
}
let mut bad: Vec<String> = Vec::new();
for tool in TOOLS {
if let Some([only]) = runners.get(tool.name).map(Vec::as_slice) {
bad.push(format!(
"{}: only {only} runs it, so it belongs in that processor's file",
tool.name
));
}
}
for plugin in crate::registries::all_plugins() {
let pname = plugin.pname();
let file = format!("src/{}.rs", pname.replace('.', "/"));
let source = std::fs::read_to_string(&file)
.unwrap_or_else(|e| panic!("{pname}: cannot read {file}: {e}"));
for name in submitted_tool_names(&source) {
let others: Vec<&String> = runners
.get(name)
.into_iter()
.flatten()
.filter(|p| **p != pname)
.collect();
if !others.is_empty() {
bad.push(format!(
"{name}: declared in {file} but also run by {others:?}, so it is \
shared and belongs in the central table"
));
}
}
}
bad.sort();
assert!(bad.is_empty(), "tool registry ownership: {bad:#?}");
}
}
pub fn tool_install_command(tool: &str) -> Option<String> {
tool_info(tool)
.and_then(ToolInfo::preferred_method)
.map(InstallMethod::command)
}
pub fn tool_runtime(tool: &str) -> Option<&'static str> {
tool_info(tool).map(|t| t.runtime)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sudo_argv_matches_runtime() {
let prefix = sudo_argv();
if crate::platform::needs_sudo() {
assert_eq!(prefix, &["sudo"]);
} else {
assert!(prefix.is_empty(), "{prefix:?}");
}
}
#[test]
fn user_gem_bin_dirs_collects_existing_layouts() {
let home = tempfile::TempDir::new().unwrap();
let none_yet = user_gem_bin_dirs(home.path(), None);
assert!(none_yet.is_empty(), "{none_yet:?}");
let upstream = home.path().join(".gem/ruby/3.2.0/bin");
let debian = home.path().join(".local/share/gem/ruby/3.3.0/bin");
let gem_home = home.path().join("mygems");
std::fs::create_dir_all(&upstream).unwrap();
std::fs::create_dir_all(&debian).unwrap();
std::fs::create_dir_all(gem_home.join("bin")).unwrap();
std::fs::create_dir_all(home.path().join(".gem/ruby/2.7.0")).unwrap();
let dirs = user_gem_bin_dirs(home.path(), Some(gem_home.as_os_str()));
assert_eq!(dirs, vec![gem_home.join("bin"), upstream, debian]);
}
#[test]
fn path_with_appended_dirs_appends_only_missing() {
use std::path::PathBuf;
let path = std::ffi::OsString::from("/usr/bin:/home/u/.gem/ruby/3.2.0/bin");
let dirs = vec![
PathBuf::from("/home/u/.gem/ruby/3.2.0/bin"),
PathBuf::from("/home/u/mygems/bin"),
];
let new_path = path_with_appended_dirs(&path, &dirs).unwrap();
assert_eq!(
new_path,
"/usr/bin:/home/u/.gem/ruby/3.2.0/bin:/home/u/mygems/bin"
);
assert!(path_with_appended_dirs(&new_path, &dirs).is_none());
assert!(path_with_appended_dirs(&path, &[]).is_none());
}
#[test]
fn path_with_prepended_dir_puts_dir_first_once() {
use std::path::Path;
let bin = Path::new("/proj/node_modules/.bin");
let path = std::ffi::OsString::from("/usr/bin:/proj/node_modules/.bin:/bin");
let new_path = path_with_prepended_dir(&path, bin).unwrap();
assert_eq!(new_path, "/proj/node_modules/.bin:/usr/bin:/bin");
assert!(path_with_prepended_dir(&new_path, bin).is_none());
let without = std::ffi::OsString::from("/usr/bin:/bin");
assert_eq!(
path_with_prepended_dir(&without, bin).unwrap(),
"/proj/node_modules/.bin:/usr/bin:/bin"
);
}
#[test]
fn ancestor_writability_walks_to_existing_dir() {
let dir = tempfile::TempDir::new().unwrap();
assert!(nearest_existing_ancestor_is_writable(
&dir.path().join("a/b/c")
));
if !crate::platform::is_root() {
crate::platform::set_permissions_mode(dir.path(), 0o555).unwrap();
assert!(!nearest_existing_ancestor_is_writable(
&dir.path().join("a/b/c")
));
crate::platform::set_permissions_mode(dir.path(), 0o755).unwrap();
}
}
#[test]
fn apt_describe_shape_is_correct() {
let steps = describe("apt", &["cowsay"], &no_pins());
assert_eq!(steps.len(), 2);
let update = &steps[0];
let upd_idx = update
.iter()
.position(|s| s == "apt-get")
.expect("apt-get in update argv");
assert_eq!(update[upd_idx + 1], "update");
assert_eq!(update.len(), upd_idx + 2);
let install = &steps[1];
let pkgmgr_idx = install
.iter()
.position(|s| s == "apt-get")
.expect("apt-get in install argv");
assert_eq!(install[pkgmgr_idx + 1], "install");
assert_eq!(install[pkgmgr_idx + 2], "-y");
assert_eq!(install[pkgmgr_idx + 3], "cowsay");
if install[0] == "sudo" {
assert_eq!(pkgmgr_idx, 1);
} else {
assert_eq!(pkgmgr_idx, 0);
}
}
#[test]
fn apt_batch_describe_collapses() {
let steps = describe("apt", &["foo", "bar", "baz"], &no_pins());
assert_eq!(steps.len(), 2);
let install = &steps[1];
let pkgmgr_idx = install
.iter()
.position(|s| s == "apt-get")
.expect("apt-get in argv");
assert_eq!(&install[pkgmgr_idx + 3..], &["foo", "bar", "baz"]);
}
#[test]
fn cargo_describe_is_locked_and_forced_without_sudo() {
let steps = describe("cargo", &["cargo-deny", "mdbook"], &no_pins());
assert_eq!(steps.len(), 1);
assert_eq!(
steps[0],
vec![
"cargo",
"install",
"--locked",
"--force",
"cargo-deny",
"mdbook"
]
);
}
#[test]
fn github_latest_urls_pin_to_a_tag() {
assert_eq!(
pin_github_latest_url(
"https://github.com/tamasfe/taplo/releases/latest/download/taplo-linux-x86_64.gz",
"0.10.0"
)
.as_deref(),
Some("https://github.com/tamasfe/taplo/releases/download/0.10.0/taplo-linux-x86_64.gz")
);
assert_eq!(
pin_github_latest_url("https://dl.google.com/x.deb", "1"),
None
);
assert_eq!(
github_repo_of("https://github.com/hadolint/hadolint/releases/latest/download/h"),
Some("hadolint/hadolint")
);
}
#[test]
fn only_versioned_binary_recipes_are_pinnable() {
assert!(!binary_is_pinnable("google-chrome-stable"));
for pkg in ["rumdl", "taplo", "hadolint", "drawio", "checkpatch.pl"] {
assert!(binary_is_pinnable(pkg), "{pkg}");
}
assert!(!binary_is_pinnable("no-such-recipe"));
}
#[test]
fn pip_describe_never_has_sudo() {
let steps = describe("pip", &["ruff"], &no_pins());
assert_eq!(steps.len(), 1);
let argv = &steps[0];
assert_eq!(argv[0], "pip");
assert!(!argv.contains(&"sudo".to_string()));
}
#[test]
fn uv_describe_targets_path_python3_without_sudo() {
let steps = describe(
"uv",
&["flask==3.1.0", "pywin32==312 ; sys_platform == 'win32'"],
&no_pins(),
);
assert_eq!(steps.len(), 1);
let argv = &steps[0];
assert_eq!(
argv[..5],
["uv", "pip", "install", "--python", "python3"].map(String::from)
);
assert_eq!(
argv.contains(&"--system".to_string()),
!python_probe().in_venv
);
assert_eq!(
&argv[argv.len() - 2..],
&["flask==3.1.0", "pywin32==312 ; sys_platform == 'win32'"]
);
assert!(!argv.contains(&"sudo".to_string()));
}
#[test]
fn uv_argv_non_venv_uses_system_and_optional_prefix() {
assert_eq!(
uv_pip_install_argv_for(false, None),
["uv", "pip", "install", "--python", "python3", "--system"].map(String::from)
);
assert_eq!(
uv_pip_install_argv_for(false, Some("/home/u/.local")),
[
"uv",
"pip",
"install",
"--python",
"python3",
"--system",
"--prefix",
"/home/u/.local"
]
.map(String::from)
);
}
#[test]
fn uv_argv_venv_omits_system() {
let argv = uv_pip_install_argv_for(true, None);
assert_eq!(
argv,
["uv", "pip", "install", "--python", "python3"].map(String::from)
);
assert!(!argv.contains(&"--system".to_string()));
}
#[test]
fn binary_describe_has_no_shell_metachars() {
for pkg in &["taplo", "rumdl", "zola", "oxlint", "selene"] {
let steps = describe("binary", &[pkg], &no_pins());
assert!(steps.len() >= 3, "binary {pkg} should have >=3 steps");
for step in &steps {
for arg in step {
for forbidden in &['|', '>', '<', ';', '&'] {
assert!(
!arg.contains(*forbidden),
"binary {pkg} step contains shell metachar '{forbidden}': {arg:?}"
);
}
}
}
}
}
fn no_pins() -> std::collections::BTreeMap<String, crate::tool_lock::BinaryPin> {
std::collections::BTreeMap::new()
}
fn argv(parts: &[&str]) -> Vec<String> {
parts.iter().map(|s| (*s).to_string()).collect()
}
#[test]
fn binary_describe_names_the_pinned_url() {
let latest =
"https://github.com/tamasfe/taplo/releases/latest/download/taplo-linux-x86_64.gz";
let pinned =
"https://github.com/tamasfe/taplo/releases/download/0.10.0/taplo-linux-x86_64.gz";
let mut pins = no_pins();
pins.insert(
"taplo".to_string(),
crate::tool_lock::BinaryPin {
url: pinned.to_string(),
sha256: "ab12".to_string(),
executable_sha256: None,
deb_package: None,
deb_version: None,
},
);
let steps = describe("binary", &["taplo"], &pins);
assert_eq!(
steps[0].last().map(String::as_str),
Some(pinned),
"{steps:?}"
);
assert!(
steps[1][0].starts_with('#') && steps[1][0].contains("ab12"),
"the locked hash is part of the plan: {steps:?}"
);
let steps = describe("binary", &["taplo"], &no_pins());
assert_eq!(
steps[0].last().map(String::as_str),
Some(latest),
"{steps:?}"
);
}
#[test]
fn binary_describe_shows_the_steps_fetch_takes() {
let steps = describe("binary", &["taplo"], &no_pins());
assert_eq!(steps.len(), 6, "{steps:?}");
assert_eq!(steps[0][0], "curl");
assert_eq!(
&steps[1..5],
&[
argv(&["mv", "/tmp/taplo.dl", "/tmp/taplo.dl.gz"]),
argv(&["gunzip", "-f", "/tmp/taplo.dl.gz"]),
argv(&["mv", "/tmp/taplo.dl", "/tmp/taplo"]),
argv(&["chmod", "+x", "/tmp/taplo"]),
]
);
assert!(
steps[5].ends_with(&argv(&["mv", "/tmp/taplo", "/usr/local/bin/taplo"])),
"{steps:?}"
);
let steps = describe("binary", &["oxlint"], &no_pins());
assert!(
steps.contains(&argv(&[
"mv",
"/tmp/oxlint-x86_64-unknown-linux-gnu",
"/tmp/oxlint"
])),
"{steps:?}"
);
assert!(
steps.contains(&argv(&["rm", "/tmp/oxlint.dl"])),
"{steps:?}"
);
let steps = describe("binary", &["rumdl"], &no_pins());
assert!(
!steps.contains(&argv(&["mv", "/tmp/rumdl", "/tmp/rumdl"])),
"{steps:?}"
);
}
#[test]
fn fetch_binary_unpacks_gzip_and_renamed_tar_members() {
let tmp = tempfile::TempDir::new().unwrap();
let base = tmp.path().to_string_lossy().into_owned();
let src = tmp.path().join("src");
std::fs::create_dir_all(&src).unwrap();
let is_executable = |path: &str| {
let meta = std::fs::metadata(path).unwrap();
crate::platform::get_mode(&meta) & 0o111 != 0
};
std::fs::write(src.join("payload"), b"#!/bin/sh\necho gz\n").unwrap();
let status = std::process::Command::new("gzip")
.arg("-k")
.arg(src.join("payload"))
.status()
.unwrap();
assert!(status.success());
let recipe = BinaryRecipe {
url: "",
archive: ArchiveKind::Gunzip,
dest: "fake-gz-tool",
};
let url = format!("file://{}", src.join("payload.gz").display());
let fetched = fetch_binary(&recipe, &url, None, &base, false).unwrap();
assert_eq!(fetched.payload, format!("{base}/fake-gz-tool"));
assert_eq!(
std::fs::read(&fetched.payload).unwrap(),
b"#!/bin/sh\necho gz\n"
);
assert!(is_executable(&fetched.payload));
assert!(!tmp.path().join("fake-gz-tool.dl").exists());
assert!(!tmp.path().join("fake-gz-tool.dl.gz").exists());
assert_eq!(
fetched.download_sha256,
file_sha256(&src.join("payload.gz")).unwrap()
);
std::fs::write(src.join("tool-x86_64-unknown-linux-gnu"), b"tar member").unwrap();
let status = std::process::Command::new("tar")
.arg("-czf")
.arg(src.join("tool.tar.gz"))
.arg("-C")
.arg(&src)
.arg("tool-x86_64-unknown-linux-gnu")
.status()
.unwrap();
assert!(status.success());
let recipe = BinaryRecipe {
url: "",
archive: ArchiveKind::TarGz {
inner: "tool-x86_64-unknown-linux-gnu",
},
dest: "fake-tar-tool",
};
let url = format!("file://{}", src.join("tool.tar.gz").display());
let fetched = fetch_binary(&recipe, &url, None, &base, false).unwrap();
assert_eq!(fetched.payload, format!("{base}/fake-tar-tool"));
assert_eq!(std::fs::read(&fetched.payload).unwrap(), b"tar member");
assert!(is_executable(&fetched.payload));
assert!(!tmp.path().join("tool-x86_64-unknown-linux-gnu").exists());
assert!(!tmp.path().join("fake-tar-tool.dl").exists());
let err = fetch_binary(&recipe, &url, Some("0000"), &base, false).unwrap_err();
assert!(
err.to_string().contains("does not match rsconstruct.lock"),
"{err}"
);
assert!(!tmp.path().join("fake-tar-tool.dl").exists());
}
}