use std::ffi::OsString;
use std::path::{Path, PathBuf};
pub(crate) trait Probe {
fn var(&self, name: &str) -> Option<OsString>;
fn raw_var(&self, name: &str) -> Option<OsString> {
self.var(name)
}
fn home(&self) -> Option<PathBuf>;
fn rust_homes(&self) -> (Option<PathBuf>, Option<PathBuf>);
fn system_dirs(&self) -> Vec<PathBuf>;
}
pub(crate) struct ProcessProbe;
impl Probe for ProcessProbe {
fn var(&self, name: &str) -> Option<OsString> {
std::env::var_os(name).filter(|value| !value.is_empty())
}
fn raw_var(&self, name: &str) -> Option<OsString> {
std::env::var_os(name)
}
fn home(&self) -> Option<PathBuf> {
harn_vm::user_dirs::home_dir().filter(|home| home.is_absolute())
}
fn rust_homes(&self) -> (Option<PathBuf>, Option<PathBuf>) {
let homes = harn_vm::process_sandbox::rust_toolchain_homes();
let find = |name: &str| {
homes
.iter()
.find(|(key, _)| *key == name)
.map(|(_, path)| path.clone())
};
(find("CARGO_HOME"), find("RUSTUP_HOME"))
}
fn system_dirs(&self) -> Vec<PathBuf> {
if !cfg!(unix) {
return Vec::new();
}
[
"/opt/homebrew/bin",
"/usr/local/bin",
"/home/linuxbrew/.linuxbrew/bin",
]
.into_iter()
.map(PathBuf::from)
.collect()
}
}
pub(crate) fn install_dirs(probe: &dyn Probe, root: &Path) -> Vec<PathBuf> {
let home = probe.home();
let in_home = |rel: &str| home.as_ref().map(|home| home.join(rel));
let var_dir = |name: &str| {
probe
.var(name)
.map(PathBuf::from)
.filter(|dir| dir.is_absolute())
};
let npm_bin = |prefix: PathBuf| {
if cfg!(windows) {
prefix
} else {
prefix.join("bin")
}
};
let (cargo_home, _) = probe.rust_homes();
let mut dirs: Vec<Option<PathBuf>> = vec![
cargo_home.map(|cargo| cargo.join("bin")),
rustup_toolchain(probe, root).map(|toolchain| toolchain.bin),
var_dir("GOBIN"),
probe
.var("GOPATH")
.and_then(|gopath| std::env::split_paths(&gopath).next())
.filter(|dir| dir.is_absolute())
.map(|dir| dir.join("bin")),
in_home("go/bin"),
var_dir("NPM_CONFIG_PREFIX").map(npm_bin),
var_dir("npm_config_prefix").map(npm_bin),
in_home(".npm-global").map(npm_bin),
var_dir("PNPM_HOME"),
in_home(".volta/bin"),
in_home(".bun/bin"),
in_home(".local/bin"),
];
if cfg!(windows) {
dirs.push(var_dir("APPDATA").map(|appdata| appdata.join("npm")));
dirs.push(in_home("scoop/shims"));
}
dirs.extend(probe.system_dirs().into_iter().map(Some));
let mut unique: Vec<PathBuf> = Vec::new();
for dir in dirs.into_iter().flatten() {
if !unique.contains(&dir) {
unique.push(dir);
}
}
unique
}
pub(crate) struct RustupToolchain {
pub name: String,
pub bin: PathBuf,
}
pub(crate) fn rustup_toolchain(probe: &dyn Probe, root: &Path) -> Option<RustupToolchain> {
let (_, rustup_home) = probe.rust_homes();
let rustup_home = rustup_home?;
let settings = rustup_settings(&rustup_home);
let name = probe
.var("RUSTUP_TOOLCHAIN")
.map(|name| name.to_string_lossy().into_owned())
.or_else(|| {
root.ancestors().find_map(|dir| {
directory_override(settings.as_ref(), dir).or_else(|| pinned_toolchain(dir))
})
})
.or_else(|| {
settings
.as_ref()?
.get("default_toolchain")?
.as_str()
.map(str::to_string)
})?;
let toolchains = rustup_home.join("toolchains");
let dir = if toolchains.join(&name).is_dir() {
toolchains.join(&name)
} else {
let prefix = format!("{name}-");
let mut matches: Vec<PathBuf> = std::fs::read_dir(&toolchains)
.ok()?
.filter_map(Result::ok)
.filter(|entry| entry.file_name().to_string_lossy().starts_with(&prefix))
.map(|entry| entry.path())
.collect();
matches.sort();
matches.into_iter().next()?
};
Some(RustupToolchain {
name,
bin: dir.join("bin"),
})
}
fn rustup_settings(rustup_home: &Path) -> Option<toml::Table> {
std::fs::read_to_string(rustup_home.join("settings.toml"))
.ok()?
.parse()
.ok()
}
fn directory_override(settings: Option<&toml::Table>, dir: &Path) -> Option<String> {
let overrides = settings?.get("overrides")?.as_table()?;
let canonical = std::fs::canonicalize(dir).ok();
[Some(dir.to_path_buf()), canonical]
.into_iter()
.flatten()
.find_map(|dir| overrides.get(dir.to_string_lossy().as_ref())?.as_str())
.map(str::to_string)
}
fn pinned_toolchain(dir: &Path) -> Option<String> {
let toml = std::fs::read_to_string(dir.join("rust-toolchain.toml")).ok();
let legacy = || std::fs::read_to_string(dir.join("rust-toolchain")).ok();
let text = toml.or_else(legacy)?;
match text.parse::<toml::Table>() {
Ok(table) => table
.get("toolchain")
.and_then(|toolchain| toolchain.get("channel"))
.and_then(toml::Value::as_str)
.map(str::to_string),
Err(_) => Some(text.trim().to_string()).filter(|name| !name.is_empty()),
}
}
pub(crate) fn is_rustup_proxy(candidate: &Path) -> bool {
let named_rustup = |path: &Path| {
path.file_stem()
.is_some_and(|stem| stem.to_string_lossy().starts_with("rustup"))
};
if std::fs::canonicalize(candidate).is_ok_and(|target| named_rustup(&target)) {
return true;
}
#[cfg(unix)]
{
use std::os::unix::fs::MetadataExt;
let sibling = candidate.with_file_name("rustup");
if let (Ok(a), Ok(b)) = (std::fs::metadata(candidate), std::fs::metadata(&sibling)) {
return a.dev() == b.dev() && a.ino() == b.ino();
}
}
false
}
#[cfg(test)]
#[path = "install_tests.rs"]
mod tests;