3019 lines
110 KiB
Rust
3019 lines
110 KiB
Rust
//! Unified package catalogue: search, inventory, information and maintenance.
|
|
//!
|
|
//! Every result is derived from real backend metadata through the same
|
|
//! argument-vector command layer used elsewhere. A lane reports one of three
|
|
//! honest states: **unavailable** (tooling absent), **failed** (the tool ran
|
|
//! and did not answer), or **empty** (a successful query with no results).
|
|
//! Package facts are never invented, and no query mutates the system.
|
|
|
|
use std::path::Path;
|
|
|
|
use phoebus_core::catalog::{
|
|
CatalogEntry, CatalogReport, PackageInfoMatch, PackageInfoReport, SourceReport,
|
|
};
|
|
use phoebus_core::effects::{ResolvedPlan, UpdateSource, UpdateTransaction};
|
|
use phoebus_core::selection::Backend;
|
|
use phoebus_core::update::UnifiedUpdateOverview;
|
|
|
|
use crate::command::{CommandOutput, CommandSpec};
|
|
use crate::error::{ExecError, Result};
|
|
use crate::exec::Exec;
|
|
use crate::{appimage, chooser, ebuild, nix, portage, snap};
|
|
|
|
/// The lanes an unfiltered request covers, in display order.
|
|
fn all_lanes() -> Vec<Backend> {
|
|
vec![
|
|
Backend::PortageSource,
|
|
Backend::Flatpak,
|
|
Backend::Snap,
|
|
Backend::AppImage,
|
|
Backend::Nix,
|
|
Backend::CustomEbuild,
|
|
]
|
|
}
|
|
|
|
fn selected_lanes(filter: Option<Backend>) -> Vec<Backend> {
|
|
match filter {
|
|
Some(backend) => vec![backend],
|
|
None => all_lanes(),
|
|
}
|
|
}
|
|
|
|
fn is_portage(backend: Backend) -> bool {
|
|
backend.is_portage() || backend == Backend::PortageSource
|
|
}
|
|
|
|
fn lane_matches(candidate: Backend, filter: Backend) -> bool {
|
|
candidate == filter || (is_portage(candidate) && is_portage(filter))
|
|
}
|
|
|
|
fn spec(root: &Path, program: &str, args: &[&str]) -> CommandSpec {
|
|
let args: Vec<String> = args.iter().map(|s| s.to_string()).collect();
|
|
if crate::actions::is_host_root(root) {
|
|
let spec = CommandSpec::new("query", "package catalogue", program).args(args);
|
|
// Flatpak may prompt for a privileged appstream refresh; detach it.
|
|
if program == "flatpak" {
|
|
spec.detached()
|
|
} else {
|
|
spec
|
|
}
|
|
} else {
|
|
portage::chroot_spec("query", "package catalogue", root, program, &args)
|
|
}
|
|
}
|
|
|
|
/// Capture a read-only command against the intended system.
|
|
fn capture(
|
|
exec: &Exec,
|
|
root: &Path,
|
|
program: &str,
|
|
args: &[&str],
|
|
) -> std::result::Result<CommandOutput, ExecError> {
|
|
exec.runner.execute(&spec(root, program, args))
|
|
}
|
|
|
|
/// Run a mutating command against the intended system.
|
|
fn run_mut(exec: &Exec, root: &Path, program: &str, args: &[&str]) -> Result<()> {
|
|
exec.run(spec(root, program, args).show_output())
|
|
.map(|_| ())
|
|
}
|
|
|
|
/// A command that could not even be started means the lane is unavailable, not
|
|
/// that the query failed.
|
|
fn is_unavailable(error: &ExecError) -> bool {
|
|
matches!(error, ExecError::Spawn { .. } | ExecError::MissingTool(_))
|
|
}
|
|
|
|
fn stderr_tail(text: &str) -> String {
|
|
let lines: Vec<&str> = text.lines().filter(|l| !l.trim().is_empty()).collect();
|
|
let tail = lines
|
|
.get(lines.len().saturating_sub(2)..)
|
|
.unwrap_or(&[])
|
|
.join("; ");
|
|
if tail.is_empty() {
|
|
"no diagnostic output".to_string()
|
|
} else {
|
|
tail
|
|
}
|
|
}
|
|
|
|
/// Whether the Flatpak client answers in the intended target. For an alternate
|
|
/// root the check runs inside the target chroot, never against the host.
|
|
pub(crate) fn flatpak_available(exec: &Exec, root: &Path) -> bool {
|
|
matches!(capture(exec, root, "flatpak", &["--version"]), Ok(o) if o.success)
|
|
}
|
|
|
|
/// Snap operations act on the running daemon and cannot be redirected into an
|
|
/// alternate root. Availability must therefore refer to the running system;
|
|
/// pretending a target lane is usable would mutate the host.
|
|
fn snap_target_usable(exec: &Exec, root: &Path) -> bool {
|
|
crate::actions::is_host_root(root) && matches!(snap::status(exec), Ok(s) if s.usable())
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Search
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Cross-source package search. `filter` constrains the search to one lane.
|
|
pub fn search(exec: &Exec, root: &Path, query: &str, filter: Option<Backend>) -> CatalogReport {
|
|
let mut report = CatalogReport::new(query);
|
|
let broader = query
|
|
.split_whitespace()
|
|
.next()
|
|
.filter(|term| *term != query);
|
|
for lane in selected_lanes(filter) {
|
|
let mut source = search_lane(exec, root, query, lane);
|
|
if source.ok && source.entries.is_empty() {
|
|
if let Some(term) = broader {
|
|
let fallback = search_lane(exec, root, term, lane);
|
|
if fallback.ok && !fallback.entries.is_empty() {
|
|
source = fallback;
|
|
source.note = format!(
|
|
"{}; no full-name match, broadened search to `{term}`",
|
|
source.note
|
|
);
|
|
} else if !fallback.ok {
|
|
source.note.push_str("; broader search did not answer");
|
|
}
|
|
}
|
|
}
|
|
report.push(source);
|
|
}
|
|
report
|
|
}
|
|
|
|
fn search_lane(exec: &Exec, root: &Path, query: &str, lane: Backend) -> SourceReport {
|
|
match lane {
|
|
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => {
|
|
search_portage(exec, root, query, lane)
|
|
}
|
|
Backend::Flatpak => search_flatpak(exec, root, query, lane),
|
|
Backend::Snap => search_snap(exec, root, query, lane),
|
|
Backend::AppImage => search_appimage(exec, root, query, lane),
|
|
Backend::Nix => search_nix(exec, root, query, lane),
|
|
Backend::CustomEbuild => search_ebuild(root, query, lane),
|
|
}
|
|
}
|
|
|
|
fn search_portage(exec: &Exec, root: &Path, query: &str, backend: Backend) -> SourceReport {
|
|
match capture(
|
|
exec,
|
|
root,
|
|
"emerge",
|
|
&["--search", "--color=n", "--", query],
|
|
) {
|
|
Ok(out) if out.success => {
|
|
let entries = portage::parse_search(&out.stdout_lossy())
|
|
.into_iter()
|
|
.map(|hit| {
|
|
let mut entry = CatalogEntry::new(backend, hit.atom)
|
|
.installed(hit.version_installed.is_some());
|
|
if let Some(version) = hit.version_available {
|
|
entry = entry.version(version);
|
|
}
|
|
if let Some(description) = hit.description {
|
|
entry = entry.description(description);
|
|
}
|
|
entry
|
|
})
|
|
.collect();
|
|
SourceReport::ok(
|
|
backend,
|
|
"configured Portage repositories (emerge --search)",
|
|
entries,
|
|
)
|
|
}
|
|
Ok(out) => SourceReport::failed(
|
|
backend,
|
|
format!(
|
|
"emerge --search failed: {}",
|
|
stderr_tail(&out.stderr_lossy())
|
|
),
|
|
),
|
|
Err(e) if is_unavailable(&e) => {
|
|
SourceReport::unsupported(backend, "Portage (emerge) is not present in the target")
|
|
}
|
|
Err(e) => SourceReport::failed(backend, format!("emerge --search could not run: {e}")),
|
|
}
|
|
}
|
|
|
|
/// An external overlay index result is a lead for review, never an install
|
|
/// candidate. GPO is an unofficial index and the named repository may not be
|
|
/// enabled, synced, trusted, or compatible with this system.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ExternalOverlayLead {
|
|
pub atom: String,
|
|
}
|
|
|
|
fn encode_query(query: &str) -> String {
|
|
let mut encoded = String::new();
|
|
for byte in query.bytes() {
|
|
if byte.is_ascii_alphanumeric() || b"-._~".contains(&byte) {
|
|
encoded.push(char::from(byte));
|
|
} else {
|
|
encoded.push_str(&format!("%{byte:02X}"));
|
|
}
|
|
}
|
|
encoded
|
|
}
|
|
|
|
fn valid_gpo_atom(atom: &str) -> bool {
|
|
let Some((category, package)) = atom.split_once('/') else {
|
|
return false;
|
|
};
|
|
!category.is_empty()
|
|
&& !package.is_empty()
|
|
&& !package.contains('/')
|
|
&& [category, package].iter().all(|part| {
|
|
part.bytes().all(|byte| {
|
|
byte.is_ascii_lowercase() || byte.is_ascii_digit() || b"+_.-".contains(&byte)
|
|
})
|
|
})
|
|
}
|
|
|
|
fn parse_gpo_search(html: &str, query: &str) -> Vec<ExternalOverlayLead> {
|
|
let terms: Vec<String> = query
|
|
.split_whitespace()
|
|
.map(str::to_ascii_lowercase)
|
|
.collect();
|
|
let mut atoms: Vec<String> = html
|
|
.split("href=\"/")
|
|
.skip(1)
|
|
.filter_map(|fragment| fragment.split_once('"').map(|(path, _)| path))
|
|
.filter(|atom| valid_gpo_atom(atom))
|
|
.filter(|atom| {
|
|
terms
|
|
.iter()
|
|
.all(|term| atom.to_ascii_lowercase().contains(term))
|
|
})
|
|
.map(str::to_string)
|
|
.collect();
|
|
let normalized_query = terms.join("-");
|
|
atoms.sort_by_key(|atom| {
|
|
let package = atom.rsplit('/').next().unwrap_or(atom);
|
|
let rank = if package == normalized_query {
|
|
0
|
|
} else if package == format!("{normalized_query}-desktop") {
|
|
1
|
|
} else if package.starts_with(&format!("{normalized_query}-")) {
|
|
2
|
|
} else {
|
|
3
|
|
};
|
|
(rank, atom.len(), atom.clone())
|
|
});
|
|
atoms.dedup();
|
|
atoms.truncate(12);
|
|
atoms
|
|
.into_iter()
|
|
.map(|atom| ExternalOverlayLead { atom })
|
|
.collect()
|
|
}
|
|
|
|
/// Opt-in, read-only discovery of packages indexed on GPO. Results never enter
|
|
/// the verified local catalogue or the installation candidate set.
|
|
pub fn search_external_overlays(
|
|
exec: &Exec,
|
|
root: &Path,
|
|
query: &str,
|
|
) -> std::result::Result<Vec<ExternalOverlayLead>, String> {
|
|
if !phoebus_core::action::valid_search_query(query) {
|
|
return Err("invalid overlay search query".into());
|
|
}
|
|
let url = format!(
|
|
"https://gpo.zugaina.org/Search?search={}",
|
|
encode_query(query)
|
|
);
|
|
let out = capture(
|
|
exec,
|
|
root,
|
|
"curl",
|
|
&[
|
|
"--fail",
|
|
"--silent",
|
|
"--show-error",
|
|
"--proto",
|
|
"=https",
|
|
"--connect-timeout",
|
|
"3",
|
|
"--max-time",
|
|
"8",
|
|
"--max-filesize",
|
|
"524288",
|
|
&url,
|
|
],
|
|
)
|
|
.map_err(|_| "GPO lookup unavailable (curl or network error)".to_string())?;
|
|
if !out.success {
|
|
return Err("GPO lookup unavailable (service or network error)".into());
|
|
}
|
|
Ok(parse_gpo_search(&out.stdout_lossy(), query))
|
|
}
|
|
|
|
fn parse_flatpak_lines(text: &str) -> Vec<Vec<String>> {
|
|
text.lines()
|
|
.filter(|l| !l.trim().is_empty())
|
|
.map(|line| {
|
|
if line.contains('\t') {
|
|
line.split('\t').map(|s| s.trim().to_string()).collect()
|
|
} else {
|
|
line.split_whitespace()
|
|
.map(|s| s.trim().to_string())
|
|
.collect()
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn installed_flatpak_ids(exec: &Exec, root: &Path) -> Option<Vec<String>> {
|
|
let out = capture(
|
|
exec,
|
|
root,
|
|
"flatpak",
|
|
&["list", "--app", "--columns=application"],
|
|
)
|
|
.ok()?;
|
|
if !out.success {
|
|
return None;
|
|
}
|
|
Some(
|
|
out.stdout_lossy()
|
|
.lines()
|
|
.map(|l| l.trim().to_string())
|
|
.filter(|l| !l.is_empty())
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
fn search_flatpak(exec: &Exec, root: &Path, query: &str, backend: Backend) -> SourceReport {
|
|
if !flatpak_available(exec, root) {
|
|
return SourceReport::unsupported(
|
|
backend,
|
|
"the Flatpak client is not available in the target",
|
|
);
|
|
}
|
|
let out = match capture(
|
|
exec,
|
|
root,
|
|
"flatpak",
|
|
&[
|
|
"search",
|
|
"--columns=application,version,description",
|
|
"--",
|
|
query,
|
|
],
|
|
) {
|
|
Ok(out) => out,
|
|
Err(e) => {
|
|
return SourceReport::failed(backend, format!("flatpak search could not run: {e}"))
|
|
}
|
|
};
|
|
if !out.success {
|
|
return SourceReport::failed(
|
|
backend,
|
|
format!(
|
|
"flatpak search failed: {}",
|
|
stderr_tail(&out.stderr_lossy())
|
|
),
|
|
);
|
|
}
|
|
let installed = installed_flatpak_ids(exec, root).unwrap_or_default();
|
|
let entries = parse_flatpak_lines(&out.stdout_lossy())
|
|
.into_iter()
|
|
.filter_map(|cols| {
|
|
let id = cols.first()?.clone();
|
|
if !phoebus_core::action::valid_flatpak_app_id(&id) {
|
|
return None;
|
|
}
|
|
let mut entry = CatalogEntry::new(backend, &id).installed(installed.contains(&id));
|
|
if let Some(version) = cols.get(1).filter(|v| !v.is_empty()) {
|
|
entry = entry.version(version.clone());
|
|
}
|
|
if let Some(description) = cols.get(2).filter(|v| !v.is_empty()) {
|
|
entry = entry.description(description.clone());
|
|
}
|
|
Some(entry)
|
|
})
|
|
.collect();
|
|
SourceReport::ok(backend, "flathub remote search", entries)
|
|
}
|
|
|
|
fn search_snap(exec: &Exec, root: &Path, query: &str, backend: Backend) -> SourceReport {
|
|
if !crate::actions::is_host_root(root) {
|
|
return SourceReport::unsupported(
|
|
backend,
|
|
"Snap cannot be queried for an alternate root; it acts on the running daemon",
|
|
);
|
|
}
|
|
if !snap_target_usable(exec, root) {
|
|
return SourceReport::unsupported(backend, "snapd is not installed or active");
|
|
}
|
|
let out = match capture(exec, root, "snap", &["find", query, "--color=never"]) {
|
|
Ok(out) => out,
|
|
Err(e) => return SourceReport::failed(backend, format!("snap find could not run: {e}")),
|
|
};
|
|
if !out.success {
|
|
return SourceReport::failed(
|
|
backend,
|
|
format!("snap find failed: {}", stderr_tail(&out.stderr_lossy())),
|
|
);
|
|
}
|
|
let installed: Vec<String> = snap::list(exec)
|
|
.map(|list| list.into_iter().map(|e| e.name).collect())
|
|
.unwrap_or_default();
|
|
let entries = snap::parse_find(&out.stdout_lossy())
|
|
.into_iter()
|
|
.map(|candidate| {
|
|
let mut entry = CatalogEntry::new(backend, &candidate.name)
|
|
.installed(installed.contains(&candidate.name));
|
|
if !candidate.version.is_empty() {
|
|
entry = entry.version(candidate.version);
|
|
}
|
|
if !candidate.summary.is_empty() {
|
|
entry = entry.description(candidate.summary);
|
|
}
|
|
entry
|
|
})
|
|
.collect();
|
|
SourceReport::ok(backend, "Snap Store search", entries)
|
|
}
|
|
|
|
const APPIMAGE_FEED_URL: &str = "https://appimage.github.io/feed.json";
|
|
const APPIMAGE_FEED_MAX_RESULTS: usize = 30;
|
|
|
|
fn appimage_description(raw: &str) -> String {
|
|
let mut plain = String::with_capacity(raw.len().min(512));
|
|
let mut in_tag = false;
|
|
for ch in raw.chars() {
|
|
match ch {
|
|
'<' => {
|
|
in_tag = true;
|
|
plain.push(' ');
|
|
}
|
|
'>' if in_tag => in_tag = false,
|
|
_ if !in_tag && !ch.is_control() => plain.push(ch),
|
|
_ => {}
|
|
}
|
|
}
|
|
plain
|
|
.replace("&", "&")
|
|
.replace("'", "'")
|
|
.replace("'", "'")
|
|
.replace(""", "\"")
|
|
.replace("<", "<")
|
|
.replace(">", ">")
|
|
.split_whitespace()
|
|
.take(36)
|
|
.collect::<Vec<_>>()
|
|
.join(" ")
|
|
}
|
|
|
|
/// The community feed indexes publisher pages, not immutable AppImage files.
|
|
/// These are discovery leads only: `appimage_acquire` still requires an
|
|
/// independently reviewed URL and SHA-256.
|
|
fn parse_appimage_feed(text: &str, query: &str) -> std::result::Result<Vec<CatalogEntry>, String> {
|
|
let feed: serde_json::Value =
|
|
serde_json::from_str(text).map_err(|_| "AppImage catalog returned invalid JSON")?;
|
|
let items = feed
|
|
.get("items")
|
|
.and_then(serde_json::Value::as_array)
|
|
.ok_or("AppImage catalog has no items array")?;
|
|
let needle = query.trim().to_ascii_lowercase().replace(['_', '-'], " ");
|
|
if needle.is_empty() {
|
|
return Ok(Vec::new());
|
|
}
|
|
let terms: Vec<&str> = needle.split_whitespace().collect();
|
|
let mut matches = Vec::new();
|
|
for item in items {
|
|
let Some(name) = item.get("name").and_then(serde_json::Value::as_str) else {
|
|
continue;
|
|
};
|
|
let name = name.trim();
|
|
if name.is_empty() || name.len() > 120 || name.chars().any(char::is_control) {
|
|
continue;
|
|
}
|
|
let description = appimage_description(
|
|
item.get("description")
|
|
.and_then(serde_json::Value::as_str)
|
|
.unwrap_or(""),
|
|
);
|
|
let normalized_name = name.to_ascii_lowercase().replace(['_', '-'], " ");
|
|
let rank = if normalized_name == needle {
|
|
0
|
|
} else if normalized_name.contains(&needle) {
|
|
1
|
|
} else if terms.iter().all(|term| normalized_name.contains(term)) {
|
|
2
|
|
} else if normalized_name.len() >= 5 && needle.ends_with(&normalized_name) {
|
|
3
|
|
} else if description.to_ascii_lowercase().contains(&needle) {
|
|
4
|
|
} else {
|
|
continue;
|
|
};
|
|
let mut entry = CatalogEntry::new(Backend::AppImage, name).scope("catalog lead");
|
|
if !description.is_empty() {
|
|
entry = entry.description(description);
|
|
}
|
|
if let Some(url) = item
|
|
.get("links")
|
|
.and_then(serde_json::Value::as_array)
|
|
.into_iter()
|
|
.flatten()
|
|
.find(|link| link.get("type").and_then(serde_json::Value::as_str) == Some("Download"))
|
|
.and_then(|link| link.get("url"))
|
|
.and_then(serde_json::Value::as_str)
|
|
.filter(|url| {
|
|
url.starts_with("https://")
|
|
&& url.len() <= 2048
|
|
&& !url.chars().any(char::is_whitespace)
|
|
&& !url.chars().any(char::is_control)
|
|
})
|
|
{
|
|
entry = entry.url(url);
|
|
}
|
|
matches.push((rank, entry));
|
|
}
|
|
matches.sort_by(|(rank_a, a), (rank_b, b)| rank_a.cmp(rank_b).then_with(|| a.id.cmp(&b.id)));
|
|
matches.dedup_by(|(_, a), (_, b)| a.id.eq_ignore_ascii_case(&b.id));
|
|
Ok(matches
|
|
.into_iter()
|
|
.take(APPIMAGE_FEED_MAX_RESULTS)
|
|
.map(|(_, entry)| entry)
|
|
.collect())
|
|
}
|
|
|
|
fn search_appimage(exec: &Exec, root: &Path, query: &str, backend: Backend) -> SourceReport {
|
|
let lower = query.to_ascii_lowercase();
|
|
let mut entries: Vec<CatalogEntry> = appimage::list(root)
|
|
.unwrap_or_default()
|
|
.into_iter()
|
|
.filter(|r| {
|
|
r.name.to_ascii_lowercase().contains(&lower)
|
|
|| r.provenance.to_ascii_lowercase().contains(&lower)
|
|
})
|
|
.map(|r| {
|
|
CatalogEntry::new(backend, r.name)
|
|
.version(r.version)
|
|
.description("managed AppImage (no sandbox)")
|
|
.installed(true)
|
|
})
|
|
.collect();
|
|
if !crate::actions::is_host_root(root) {
|
|
return SourceReport::ok(
|
|
backend,
|
|
"managed AppImages in the target; online catalog searches require the running system",
|
|
entries,
|
|
);
|
|
}
|
|
let out = match capture(
|
|
exec,
|
|
root,
|
|
"curl",
|
|
&[
|
|
"--fail",
|
|
"--silent",
|
|
"--show-error",
|
|
"--location",
|
|
"--proto",
|
|
"=https",
|
|
"--proto-redir",
|
|
"=https",
|
|
"--connect-timeout",
|
|
"3",
|
|
"--max-time",
|
|
"8",
|
|
"--max-filesize",
|
|
"4194304",
|
|
APPIMAGE_FEED_URL,
|
|
],
|
|
) {
|
|
Ok(out) if out.success => out,
|
|
Ok(_) => return appimage_catalog_unavailable(backend, entries, "catalog download failed"),
|
|
Err(e) if is_unavailable(&e) => {
|
|
return appimage_catalog_unavailable(backend, entries, "curl is unavailable")
|
|
}
|
|
Err(_) => return appimage_catalog_unavailable(backend, entries, "catalog lookup failed"),
|
|
};
|
|
let remote = match parse_appimage_feed(&out.stdout_lossy(), query) {
|
|
Ok(remote) => remote,
|
|
Err(reason) => return appimage_catalog_unavailable(backend, entries, reason),
|
|
};
|
|
for entry in remote {
|
|
if !entries
|
|
.iter()
|
|
.any(|installed| installed.id.eq_ignore_ascii_case(&entry.id))
|
|
{
|
|
entries.push(entry);
|
|
}
|
|
}
|
|
SourceReport::ok(
|
|
backend,
|
|
"Phoebus-managed images and appimage.github.io leads; catalog entries are not verified install candidates",
|
|
entries,
|
|
)
|
|
}
|
|
|
|
fn appimage_catalog_unavailable(
|
|
backend: Backend,
|
|
entries: Vec<CatalogEntry>,
|
|
reason: impl AsRef<str>,
|
|
) -> SourceReport {
|
|
let note = format!(
|
|
"{reason}; AppImage catalog unavailable",
|
|
reason = reason.as_ref()
|
|
);
|
|
if entries.is_empty() {
|
|
SourceReport::failed(backend, note)
|
|
} else {
|
|
SourceReport::ok(
|
|
backend,
|
|
format!("{note}; showing managed images only"),
|
|
entries,
|
|
)
|
|
}
|
|
}
|
|
|
|
fn search_nix(exec: &Exec, root: &Path, query: &str, backend: Backend) -> SourceReport {
|
|
if !nix::installed(root) {
|
|
return SourceReport::unsupported(backend, "Nix is not installed");
|
|
}
|
|
let binary = "/nix/var/nix/profiles/default/bin/nix";
|
|
let out = match capture(exec, root, binary, &["search", "nixpkgs", query, "--json"]) {
|
|
Ok(out) => out,
|
|
Err(e) => return SourceReport::failed(backend, format!("nix search could not run: {e}")),
|
|
};
|
|
if !out.success {
|
|
return SourceReport::failed(
|
|
backend,
|
|
format!(
|
|
"nix search failed (offline or flake metadata unavailable): {}",
|
|
stderr_tail(&out.stderr_lossy())
|
|
),
|
|
);
|
|
}
|
|
let value: serde_json::Value = match serde_json::from_str(&out.stdout_lossy()) {
|
|
Ok(value) => value,
|
|
Err(e) => {
|
|
return SourceReport::failed(backend, format!("nix search returned no JSON: {e}"))
|
|
}
|
|
};
|
|
let mut entries = Vec::new();
|
|
if let Some(map) = value.as_object() {
|
|
for (attr, meta) in map {
|
|
let id = attr.rsplit('.').next().unwrap_or(attr).to_string();
|
|
let mut entry = CatalogEntry::new(backend, id);
|
|
if let Some(version) = meta.get("version").and_then(|v| v.as_str()) {
|
|
if !version.is_empty() {
|
|
entry = entry.version(version);
|
|
}
|
|
}
|
|
if let Some(description) = meta.get("description").and_then(|v| v.as_str()) {
|
|
if !description.is_empty() {
|
|
entry = entry.description(description);
|
|
}
|
|
}
|
|
entries.push(entry);
|
|
}
|
|
}
|
|
SourceReport::ok(backend, "nixpkgs search (realised metadata)", entries)
|
|
}
|
|
|
|
fn search_ebuild(root: &Path, query: &str, backend: Backend) -> SourceReport {
|
|
let lower = query.to_ascii_lowercase();
|
|
let entries = ebuild::list(root)
|
|
.into_iter()
|
|
.filter(|e| {
|
|
e.atom.to_ascii_lowercase().contains(&lower)
|
|
|| e.package_name().to_ascii_lowercase().contains(&lower)
|
|
})
|
|
.map(|e| CatalogEntry::new(backend, e.atom).version(e.version))
|
|
.collect();
|
|
SourceReport::ok(backend, "staged Phoebus overlay ebuilds", entries)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Inventory
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Installed-package inventory across the available lanes, optionally filtered
|
|
/// to one lane and by a free-text substring.
|
|
pub fn inventory(
|
|
exec: &Exec,
|
|
root: &Path,
|
|
filter: Option<Backend>,
|
|
text: Option<&str>,
|
|
) -> CatalogReport {
|
|
let mut report = CatalogReport::new(text.unwrap_or("(all)"));
|
|
for lane in selected_lanes(filter) {
|
|
let source = match lane {
|
|
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => {
|
|
inventory_portage(root, lane)
|
|
}
|
|
Backend::Flatpak => inventory_flatpak(exec, root, lane),
|
|
Backend::Snap => inventory_snap(exec, root, lane),
|
|
Backend::AppImage => inventory_appimage(root, lane),
|
|
Backend::Nix => inventory_nix(root, lane),
|
|
Backend::CustomEbuild => SourceReport::unsupported(
|
|
lane,
|
|
"custom ebuilds are installed through Portage and are listed there, never twice",
|
|
),
|
|
};
|
|
report.push(source);
|
|
}
|
|
if let Some(text) = text {
|
|
let lower = text.to_ascii_lowercase();
|
|
for source in &mut report.sources {
|
|
source.entries.retain(|e| {
|
|
e.id.to_ascii_lowercase().contains(&lower)
|
|
|| e.description
|
|
.as_deref()
|
|
.map(|d| d.to_ascii_lowercase().contains(&lower))
|
|
.unwrap_or(false)
|
|
});
|
|
}
|
|
}
|
|
report
|
|
}
|
|
|
|
fn inventory_portage(root: &Path, backend: Backend) -> SourceReport {
|
|
let installed = portage::installed_packages(root);
|
|
let entries = installed
|
|
.into_iter()
|
|
.map(|p| {
|
|
CatalogEntry::new(backend, p.atom)
|
|
.version(p.version)
|
|
.installed(true)
|
|
})
|
|
.collect();
|
|
SourceReport::ok(backend, "Portage VDB (var/db/pkg)", entries)
|
|
}
|
|
|
|
fn inventory_flatpak(exec: &Exec, root: &Path, backend: Backend) -> SourceReport {
|
|
if !flatpak_available(exec, root) {
|
|
return SourceReport::unsupported(
|
|
backend,
|
|
"the Flatpak client is not available in the target",
|
|
);
|
|
}
|
|
let out = match capture(
|
|
exec,
|
|
root,
|
|
"flatpak",
|
|
&["list", "--app", "--columns=application,version,origin"],
|
|
) {
|
|
Ok(out) => out,
|
|
Err(e) => return SourceReport::failed(backend, format!("flatpak list could not run: {e}")),
|
|
};
|
|
if !out.success {
|
|
return SourceReport::failed(
|
|
backend,
|
|
format!("flatpak list failed: {}", stderr_tail(&out.stderr_lossy())),
|
|
);
|
|
}
|
|
let entries = parse_flatpak_lines(&out.stdout_lossy())
|
|
.into_iter()
|
|
.filter_map(|cols| {
|
|
let id = cols.first()?.clone();
|
|
if id.is_empty() {
|
|
return None;
|
|
}
|
|
let mut entry = CatalogEntry::new(backend, &id).installed(true);
|
|
if let Some(version) = cols.get(1).filter(|v| !v.is_empty()) {
|
|
entry = entry.version(version.clone());
|
|
}
|
|
if let Some(origin) = cols.get(2).filter(|v| !v.is_empty()) {
|
|
entry = entry.scope(origin.clone());
|
|
}
|
|
Some(entry)
|
|
})
|
|
.collect();
|
|
SourceReport::ok(backend, "installed Flatpak applications", entries)
|
|
}
|
|
|
|
fn inventory_snap(exec: &Exec, root: &Path, backend: Backend) -> SourceReport {
|
|
if !crate::actions::is_host_root(root) {
|
|
return SourceReport::unsupported(
|
|
backend,
|
|
"Snap cannot be inspected for an alternate root; it acts on the running daemon",
|
|
);
|
|
}
|
|
if !snap_target_usable(exec, root) {
|
|
return SourceReport::unsupported(backend, "snapd is not installed or active");
|
|
}
|
|
match snap::list(exec) {
|
|
Ok(list) => {
|
|
let entries = list
|
|
.into_iter()
|
|
.map(|e| {
|
|
let mut entry = CatalogEntry::new(backend, e.name)
|
|
.version(e.version)
|
|
.scope(e.channel)
|
|
.installed(true);
|
|
if !e.publisher.is_empty() {
|
|
entry = entry.description(format!("publisher: {}", e.publisher));
|
|
}
|
|
entry
|
|
})
|
|
.collect();
|
|
SourceReport::ok(backend, "installed snaps", entries)
|
|
}
|
|
Err(e) => SourceReport::failed(backend, format!("snap list failed: {e}")),
|
|
}
|
|
}
|
|
|
|
fn inventory_appimage(root: &Path, backend: Backend) -> SourceReport {
|
|
let entries = appimage::list(root)
|
|
.unwrap_or_default()
|
|
.into_iter()
|
|
.map(|r| {
|
|
CatalogEntry::new(backend, r.name)
|
|
.version(r.version)
|
|
.description(format!("{} ({})", r.provenance, r.arch))
|
|
.installed(true)
|
|
})
|
|
.collect();
|
|
SourceReport::ok(backend, "Phoebus-managed AppImages", entries)
|
|
}
|
|
|
|
fn inventory_nix(root: &Path, backend: Backend) -> SourceReport {
|
|
let Some(store_paths) = nix::store_path_count(root) else {
|
|
return SourceReport::unsupported(backend, "Nix is not installed");
|
|
};
|
|
let inventory = nix::installed_packages(root);
|
|
let entries = inventory
|
|
.packages
|
|
.into_iter()
|
|
.map(|p| {
|
|
let mut entry = CatalogEntry::new(backend, p.path)
|
|
.scope(p.profile)
|
|
.installed(true);
|
|
if let Some(version) = p.version {
|
|
entry = entry.version(version);
|
|
}
|
|
entry = entry.description(format!("Nix package `{}` ({})", p.name, p.store_path));
|
|
entry
|
|
})
|
|
.collect();
|
|
let mut note = format!(
|
|
"active Nix profiles; {store_paths} additional store path(s) are realised \
|
|
dependencies, not installed packages"
|
|
);
|
|
for additional in inventory.notes {
|
|
note.push_str("; ");
|
|
note.push_str(&additional);
|
|
}
|
|
SourceReport::ok(backend, note, entries)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Package information
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Detailed information about a package, across lanes unless filtered. An
|
|
/// ambiguous query returns every real match rather than guessing.
|
|
pub fn package_info(
|
|
exec: &Exec,
|
|
root: &Path,
|
|
package: &str,
|
|
filter: Option<Backend>,
|
|
) -> PackageInfoReport {
|
|
let lanes = selected_lanes(filter);
|
|
// The filter is applied before any backend is queried, so a
|
|
// source-constrained request never probes (or reports) another lane.
|
|
let installed = chooser::installed_copies_filtered(exec, root, package, filter);
|
|
let installed_portage = if filter.map(is_portage).unwrap_or(true) {
|
|
portage::installed_packages(root)
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
let mut matches: Vec<PackageInfoMatch> = Vec::new();
|
|
let mut notes: Vec<String> = Vec::new();
|
|
|
|
let push_unique = |matches: &mut Vec<PackageInfoMatch>, candidate: PackageInfoMatch| {
|
|
let already = matches
|
|
.iter()
|
|
.any(|m| m.source == candidate.source && m.id == candidate.id);
|
|
if !already {
|
|
matches.push(candidate);
|
|
}
|
|
};
|
|
|
|
for lane in lanes {
|
|
let resolution = chooser::resolve_for_backend(exec, root, lane, package);
|
|
for candidate in resolution.candidates.iter().filter(|c| c.available) {
|
|
let installed_copy = installed.copies.iter().find(|copy| {
|
|
copy.id == candidate.id || (is_portage(lane) && copy.backend == "portage-source")
|
|
});
|
|
// A bare-name Portage candidate (`firefox`) is the same installed
|
|
// package as its VDB atom (`www-client/firefox`); use the atom so
|
|
// the report never splits one package into two rows.
|
|
let record = if is_portage(lane) {
|
|
installed_portage.iter().find(|p| {
|
|
p.atom == candidate.id
|
|
|| installed_copy.map(|c| c.id == p.atom).unwrap_or(false)
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
let effective_id = record
|
|
.map(|r| r.atom.clone())
|
|
.unwrap_or_else(|| candidate.id.clone());
|
|
let mut info = PackageInfoMatch {
|
|
source: lane,
|
|
id: effective_id,
|
|
version: candidate
|
|
.version
|
|
.clone()
|
|
.or_else(|| record.map(|r| r.version.clone()))
|
|
.or_else(|| installed_copy.map(|c| c.version.clone())),
|
|
description: candidate.notes.first().cloned(),
|
|
installed: installed_copy.is_some() || record.is_some(),
|
|
dependencies: Vec::new(),
|
|
reverse_dependencies: Vec::new(),
|
|
size: size_label(candidate),
|
|
provenance: candidate.provenance.clone(),
|
|
permissions: candidate.permissions.clone(),
|
|
notes: candidate.notes.clone(),
|
|
};
|
|
if let Some(record) = record {
|
|
if let Some(repo) = &record.repository {
|
|
info.provenance = repo.clone();
|
|
info.notes.push(format!("repository: {repo}"));
|
|
}
|
|
if let Some(size) = record.size_bytes {
|
|
info.size = Some(format!("{size} bytes installed"));
|
|
}
|
|
if let Some(rdepend) = &record.rdepend {
|
|
info.dependencies = split_depend(rdepend);
|
|
}
|
|
}
|
|
if is_portage(lane) && info.dependencies.is_empty() {
|
|
let detail = chooser::candidate_detail(exec, root, lane, &candidate.id);
|
|
info.dependencies = detail.dependencies;
|
|
}
|
|
push_unique(&mut matches, info);
|
|
}
|
|
if resolution.is_ambiguous() {
|
|
notes.push(format!(
|
|
"{}: multiple candidates matched ({})",
|
|
lane.as_str(),
|
|
resolution.ambiguous.join(", ")
|
|
));
|
|
}
|
|
}
|
|
|
|
// Installed copies with no corresponding available candidate (for example
|
|
// an installed Flatpak whose remote search is unavailable) are still real.
|
|
for copy in &installed.copies {
|
|
let source = parse_installed_backend(©.backend);
|
|
let Some(source) = source else {
|
|
continue;
|
|
};
|
|
if filter.map(|f| !lane_matches(source, f)).unwrap_or(false) {
|
|
continue;
|
|
}
|
|
let record = if is_portage(source) {
|
|
installed_portage.iter().find(|p| p.atom == copy.id)
|
|
} else {
|
|
None
|
|
};
|
|
let mut info = PackageInfoMatch {
|
|
source,
|
|
id: copy.id.clone(),
|
|
version: Some(copy.version.clone()),
|
|
description: None,
|
|
installed: true,
|
|
dependencies: record
|
|
.and_then(|r| r.rdepend.as_ref())
|
|
.map(|d| split_depend(d))
|
|
.unwrap_or_default(),
|
|
reverse_dependencies: Vec::new(),
|
|
size: record
|
|
.and_then(|r| r.size_bytes)
|
|
.map(|s| format!("{s} bytes installed")),
|
|
provenance: record
|
|
.and_then(|r| r.repository.clone())
|
|
.unwrap_or_else(|| "installed".into()),
|
|
permissions: Vec::new(),
|
|
notes: Vec::new(),
|
|
};
|
|
if let Some(repo) = record.and_then(|r| r.repository.clone()) {
|
|
info.notes.push(format!("repository: {repo}"));
|
|
}
|
|
push_unique(&mut matches, info);
|
|
}
|
|
|
|
if matches.len() > 1 {
|
|
notes.push("ambiguous: choose a source or use a full backend id".into());
|
|
}
|
|
|
|
PackageInfoReport {
|
|
query: package.to_string(),
|
|
ambiguous: matches.len() > 1,
|
|
matches,
|
|
notes,
|
|
}
|
|
}
|
|
|
|
fn parse_installed_backend(name: &str) -> Option<Backend> {
|
|
match name {
|
|
"portage-source" | "portage" => Some(Backend::PortageSource),
|
|
"flatpak" => Some(Backend::Flatpak),
|
|
"snap" => Some(Backend::Snap),
|
|
"appimage" => Some(Backend::AppImage),
|
|
"nix" => Some(Backend::Nix),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn size_label(candidate: &phoebus_core::selection::Candidate) -> Option<String> {
|
|
let mut parts = Vec::new();
|
|
if let Some(download) = candidate.download_mib.filter(|v| *v > 0) {
|
|
parts.push(format!("{download} MiB download"));
|
|
}
|
|
if let Some(install) = candidate.install_mib.filter(|v| *v > 0) {
|
|
parts.push(format!("{install} MiB installed"));
|
|
}
|
|
if parts.is_empty() {
|
|
None
|
|
} else {
|
|
Some(parts.join(", "))
|
|
}
|
|
}
|
|
|
|
/// Split a Portage dependency string into bounded, non-empty atoms.
|
|
fn split_depend(value: &str) -> Vec<String> {
|
|
value
|
|
.split_whitespace()
|
|
.map(|s| s.trim_start_matches(['!', '?']).trim())
|
|
.filter(|s| s.contains('/') && !s.starts_with('|'))
|
|
.map(|s| s.to_string())
|
|
.take(64)
|
|
.collect()
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Maintenance
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Which installed package owns a file path (Portage).
|
|
pub fn package_owners(exec: &Exec, root: &Path, path: &str) -> Result<String> {
|
|
// Prefer `qfile` (portage-utils), then `equery belongs` (gentoolkit). The
|
|
// tool must be present in the intended target, not merely on the host.
|
|
if crate::exec::tool_in_target(root, "qfile") {
|
|
let out = capture(exec, root, "qfile", &[path])?;
|
|
if !out.success {
|
|
return Ok(format!("no installed package owns {path}"));
|
|
}
|
|
return Ok(format!(
|
|
"packages owning {path}:\n{}",
|
|
out.stdout_lossy().trim()
|
|
));
|
|
}
|
|
if crate::exec::tool_in_target(root, "equery") {
|
|
let out = capture(exec, root, "equery", &["belongs", path])?;
|
|
if !out.success {
|
|
return Ok(format!("no installed package owns {path}"));
|
|
}
|
|
return Ok(format!(
|
|
"packages owning {path}:\n{}",
|
|
out.stdout_lossy().trim()
|
|
));
|
|
}
|
|
Err(ExecError::operation(
|
|
"sys",
|
|
"package owners",
|
|
"no file-ownership tool is available; install app-portage/portage-utils (qfile) or \
|
|
app-portage/gentoolkit (equery)",
|
|
))
|
|
}
|
|
|
|
/// The declared dependency fields of an installed VDB record.
|
|
fn declared_dependencies(record: &portage::InstalledPortage) -> Vec<portage::DeclaredDependency> {
|
|
let mut deps = Vec::new();
|
|
for text in [&record.depend, &record.rdepend, &record.bdepend]
|
|
.into_iter()
|
|
.flatten()
|
|
{
|
|
deps.extend(portage::parse_dependencies(text));
|
|
}
|
|
deps
|
|
}
|
|
|
|
/// Whether `atom` (a `category/name`) matches a requested package (bare name,
|
|
/// full atom, or atom-with-version).
|
|
fn atom_matches(atom: &str, package: &str) -> bool {
|
|
let wanted = portage::normalize_dep_atom(package);
|
|
atom == wanted
|
|
|| wanted.ends_with(&format!("/{package}"))
|
|
|| atom.ends_with(&format!("/{package}"))
|
|
}
|
|
|
|
/// Forward or reverse dependencies of an installed Portage package.
|
|
///
|
|
/// Dependencies come from the authoritative installed metadata (the VDB
|
|
/// `DEPEND`/`RDEPEND`/`BDEPEND` fields), so already-satisfied dependencies are
|
|
/// included and conditional/versioned dependencies keep their context. An
|
|
/// install plan from `emerge --pretend` is deliberately not used: it describes
|
|
/// pending merges, not the full dependency graph. For a package that is not
|
|
/// installed, `qdepends` (portage-utils) is used when present, else the query is
|
|
/// refused with a clear limitation rather than guessing.
|
|
pub fn package_dependencies(
|
|
exec: &Exec,
|
|
root: &Path,
|
|
package: &str,
|
|
reverse: bool,
|
|
) -> Result<String> {
|
|
let installed = portage::installed_packages(root);
|
|
let installed_atoms: std::collections::BTreeSet<String> =
|
|
installed.iter().map(|p| p.atom.clone()).collect();
|
|
let self_atom = installed
|
|
.iter()
|
|
.find(|p| atom_matches(&p.atom, package))
|
|
.map(|p| p.atom.clone());
|
|
|
|
let mut lines: Vec<String> = Vec::new();
|
|
if reverse {
|
|
for record in &installed {
|
|
// A genuine self-reference is a package declaring a dependency on
|
|
// *itself*; it is not a reverse dependency of any other package.
|
|
// The dependent is `record`, so compare `record.atom` with the
|
|
// queried package — not the dependency target, which is exactly
|
|
// what must match.
|
|
if self_atom.as_deref() == Some(record.atom.as_str()) {
|
|
continue;
|
|
}
|
|
for dep in declared_dependencies(record) {
|
|
if atom_matches(&dep.atom, package) {
|
|
let conditional = dep
|
|
.condition
|
|
.as_deref()
|
|
.map(|c| format!("[{c}] "))
|
|
.unwrap_or_default();
|
|
lines.push(format!("{conditional}{} (from {})", dep.raw, record.atom));
|
|
}
|
|
}
|
|
}
|
|
lines.sort();
|
|
lines.dedup();
|
|
if lines.is_empty() {
|
|
return Ok(format!(
|
|
"no installed package depends on {package}\n (installed metadata is authoritative \
|
|
for reverse dependencies; nothing references it)"
|
|
));
|
|
}
|
|
return Ok(format!(
|
|
"installed packages depending on {package}:\n {}",
|
|
lines.join("\n ")
|
|
));
|
|
}
|
|
|
|
// Forward: prefer the installed metadata; fall back to the tree via
|
|
// qdepends only when the package is not installed.
|
|
let deps: Vec<(String, Option<String>, bool)> =
|
|
if let Some(record) = installed.iter().find(|p| atom_matches(&p.atom, package)) {
|
|
declared_dependencies(record)
|
|
.into_iter()
|
|
.filter(|d| Some(&d.atom) != self_atom.as_ref())
|
|
.map(|d| (d.raw, d.condition, d.negative))
|
|
.collect()
|
|
} else if crate::exec::tool_in_target(root, "qdepends") {
|
|
let out = capture(exec, root, "qdepends", &["-Q", "--", package])?;
|
|
if !out.success {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"dependencies",
|
|
format!(
|
|
"qdepends could not resolve dependencies for {package}: {}",
|
|
stderr_tail(&out.stderr_lossy())
|
|
),
|
|
));
|
|
}
|
|
portage::parse_dependencies(&out.stdout_lossy())
|
|
.into_iter()
|
|
.map(|d| (d.raw, d.condition, d.negative))
|
|
.collect()
|
|
} else {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"dependencies",
|
|
format!(
|
|
"{package} is not installed, and no dependency inspection tool is available; \
|
|
install app-portage/portage-utils (qdepends) or inspect it through Portage"
|
|
),
|
|
));
|
|
};
|
|
|
|
if deps.is_empty() {
|
|
return Ok(format!(
|
|
"{package} has no declared dependencies in the installed metadata"
|
|
));
|
|
}
|
|
let mut rendered = Vec::new();
|
|
for (raw, condition, negative) in deps {
|
|
let atom = portage::normalize_dep_atom(&raw);
|
|
let satisfied = if negative {
|
|
"blocker"
|
|
} else if installed_atoms.contains(&atom) {
|
|
"installed"
|
|
} else {
|
|
"not installed"
|
|
};
|
|
let conditional = condition
|
|
.as_deref()
|
|
.map(|c| format!("[{c}] "))
|
|
.unwrap_or_default();
|
|
rendered.push(format!("{conditional}{raw} ({satisfied})"));
|
|
}
|
|
rendered.sort();
|
|
rendered.dedup();
|
|
Ok(format!(
|
|
"{package} declares {} dependency token(s):\n {}",
|
|
rendered.len(),
|
|
rendered.join("\n ")
|
|
))
|
|
}
|
|
|
|
/// Remove packages no longer required by any installed package (Portage).
|
|
///
|
|
/// The selection is previewed with `emerge --pretend --depclean` first; if
|
|
/// nothing is selected nothing is removed. User data is not touched.
|
|
pub fn depclean(exec: &Exec, root: &Path) -> Result<String> {
|
|
let pretend = capture(
|
|
exec,
|
|
root,
|
|
"emerge",
|
|
&["--pretend", "--depclean", "--color=n"],
|
|
)?;
|
|
if !pretend.success {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"depclean",
|
|
format!(
|
|
"emerge --pretend --depclean failed: {}",
|
|
stderr_tail(&pretend.stderr_lossy())
|
|
),
|
|
));
|
|
}
|
|
let preview = pretend.stdout_lossy();
|
|
let selected_nothing = preview.lines().any(|line| {
|
|
let text = line.trim().trim_start_matches(['>', ' ']).trim();
|
|
text.starts_with("0 packages selected")
|
|
});
|
|
if preview.contains("No packages selected") || selected_nothing {
|
|
return Ok(format!(
|
|
"nothing to remove; no unused packages were selected\npreview:\n{}",
|
|
preview.trim()
|
|
));
|
|
}
|
|
// `--ask=n` keeps the destructive run non-interactive: the human
|
|
// confirmation happened in the approval layer, and Portage must not try to
|
|
// read a second answer from the (already consumed) stdin.
|
|
run_mut(
|
|
exec,
|
|
root,
|
|
"emerge",
|
|
&["--depclean", "--ask=n", "--color=n"],
|
|
)?;
|
|
Ok(format!(
|
|
"removed unused packages; configuration files and user data were preserved\n\
|
|
reviewed selection (emerge --pretend --depclean):\n{}",
|
|
preview.trim()
|
|
))
|
|
}
|
|
|
|
/// The destructive arguments for a named Portage cleaner, if it is present.
|
|
fn destructive_args_for(root: &Path, cleaner: &str) -> Option<Vec<String>> {
|
|
crate::actions::portage_cleaners(root)
|
|
.into_iter()
|
|
.find(|(name, _, _)| *name == cleaner)
|
|
.map(|(_, _, destructive)| destructive)
|
|
}
|
|
|
|
/// Remove unreferenced package caches / store paths. Never removes an
|
|
/// installed package.
|
|
///
|
|
/// When a reviewed plan is supplied, **only the cleaners and item sets that
|
|
/// were reviewed are executed**; the destructive invocation uses the same
|
|
/// selection policy as the preview. Every cleaner's outcome is preserved: a
|
|
/// cleaner that ran and failed makes the whole action fail (with partial
|
|
/// successes still reported), and a missing cleaner is distinguished from one
|
|
/// that ran and found nothing. A cleanup that could not run at all is a
|
|
/// failure, not a silent success.
|
|
pub fn clean_cache(
|
|
exec: &Exec,
|
|
root: &Path,
|
|
filter: Option<Backend>,
|
|
approved: Option<&phoebus_core::effects::ResolvedPlan>,
|
|
) -> Result<String> {
|
|
let lanes: Vec<Backend> = match filter {
|
|
Some(backend) => vec![backend],
|
|
None => vec![Backend::PortageSource, Backend::Nix],
|
|
};
|
|
let mut report = String::new();
|
|
report.push_str("cache cleanup (installed packages are never removed)\n");
|
|
let mut completed = 0usize;
|
|
let mut failed = false;
|
|
|
|
for lane in lanes {
|
|
if lane.is_portage() {
|
|
// The reviewed cleaner set, when present, is the only thing that may
|
|
// run. Otherwise fall back to every cleaner present in the target.
|
|
let reviewed: Vec<String> = match approved {
|
|
Some(plan) => plan
|
|
.cleanup
|
|
.iter()
|
|
.filter(|c| !c.unavailable)
|
|
.map(|c| c.cleaner.clone())
|
|
.collect(),
|
|
None => crate::actions::portage_cleaners(root)
|
|
.into_iter()
|
|
.map(|(name, _, _)| name.to_string())
|
|
.collect(),
|
|
};
|
|
let mut attempted = false;
|
|
for cleaner in reviewed {
|
|
let Some(args) = destructive_args_for(root, &cleaner) else {
|
|
failed = true;
|
|
report.push_str(&format!(
|
|
" [portage] {cleaner} failed: the reviewed cleaner is no longer \
|
|
available in the target\n"
|
|
));
|
|
continue;
|
|
};
|
|
attempted = true;
|
|
let refs: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
|
|
match run_mut(exec, root, &cleaner, &refs) {
|
|
Ok(()) => {
|
|
completed += 1;
|
|
report.push_str(&format!(" [portage] {cleaner} completed\n"));
|
|
}
|
|
Err(e) => {
|
|
failed = true;
|
|
report.push_str(&format!(" [portage] {cleaner} failed: {e}\n"));
|
|
}
|
|
}
|
|
}
|
|
if !attempted {
|
|
report.push_str(
|
|
" [portage] unavailable: no cleaner in the target (install \
|
|
app-portage/gentoolkit for eclean-dist / eclean-pkg)\n",
|
|
);
|
|
}
|
|
} else if lane == Backend::Nix {
|
|
let reviewed = match approved {
|
|
Some(plan) => plan
|
|
.cleanup
|
|
.iter()
|
|
.find(|c| c.cleaner == "nix-store --gc")
|
|
.map(|c| !c.unavailable),
|
|
None => Some(nix::installed(root)),
|
|
};
|
|
match reviewed {
|
|
None => report.push_str(" [nix] not executed: not part of the reviewed plan\n"),
|
|
Some(false) => {
|
|
report.push_str(" [nix] unavailable: Nix is not installed\n");
|
|
}
|
|
Some(true) => match nix::gc(exec, root) {
|
|
Ok(()) => {
|
|
completed += 1;
|
|
report.push_str(
|
|
" [nix] unreferenced store paths collected (nix-store --gc)\n",
|
|
);
|
|
}
|
|
Err(e) => {
|
|
failed = true;
|
|
report.push_str(&format!(" [nix] cleanup failed: {e}\n"));
|
|
}
|
|
},
|
|
}
|
|
} else {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"clean cache",
|
|
format!(
|
|
"the {} lane has no package cache to clean; refusing",
|
|
lane.as_str()
|
|
),
|
|
));
|
|
}
|
|
}
|
|
|
|
if failed {
|
|
return Err(ExecError::operation("sys", "clean cache", report));
|
|
}
|
|
if completed == 0 {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"clean cache",
|
|
format!("{report}no cleaner ran"),
|
|
));
|
|
}
|
|
Ok(report)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Updates
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Check for updates across the supported lanes, optionally restricted to one.
|
|
pub fn check_updates(exec: &Exec, root: &Path, filter: Option<Backend>) -> UnifiedUpdateOverview {
|
|
// The filter is applied before any backend is queried, not merely to the
|
|
// displayed results.
|
|
crate::update::check_unified_updates_filtered(exec, root, filter)
|
|
}
|
|
|
|
/// Whether the reviewed plan recorded that a source could not be resolved.
|
|
fn source_resolution_failed(approved: &ResolvedPlan, tag: &str) -> bool {
|
|
approved
|
|
.consequences
|
|
.iter()
|
|
.any(|c| c.starts_with(&format!("[{tag}] updates could not be resolved")))
|
|
}
|
|
|
|
/// Revalidate an approved Flatpak transaction immediately before mutation.
|
|
/// The freshly resolved set must equal the approved set exactly (identity,
|
|
/// immutable commit, scope): a changed commit with an unchanged human version,
|
|
/// a newly appeared update, or a vanished one all fail.
|
|
fn revalidate_flatpak(exec: &Exec, root: &Path, approved: &[UpdateTransaction]) -> Result<()> {
|
|
let current = crate::actions::flatpak_update_transactions(exec, root)?;
|
|
if current != approved {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"apply flatpak updates",
|
|
format!(
|
|
"the reviewed Flatpak transaction changed before execution ({} reviewed, {} now); \
|
|
not applying it",
|
|
approved.len(),
|
|
current.len()
|
|
),
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Revalidate an approved Snap transaction immediately before mutation.
|
|
fn revalidate_snap(exec: &Exec, root: &Path, approved: &[UpdateTransaction]) -> Result<()> {
|
|
let current = crate::actions::snap_update_transactions(exec, root)?;
|
|
if current != approved {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"apply snap updates",
|
|
format!(
|
|
"the reviewed Snap transaction changed before execution ({} reviewed, {} now); \
|
|
not applying it",
|
|
approved.len(),
|
|
current.len()
|
|
),
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Installed Flatpak commits keyed by ref.
|
|
/// The installed active commit for every ref, from
|
|
/// `flatpak list --system --columns=ref,active`. `list` reports the bare ref
|
|
/// (without the `app/`/`runtime/` type prefix) and an abbreviated commit.
|
|
fn installed_flatpak_active(
|
|
exec: &Exec,
|
|
root: &Path,
|
|
) -> Result<std::collections::BTreeMap<String, String>> {
|
|
let out = capture(
|
|
exec,
|
|
root,
|
|
"flatpak",
|
|
&["list", "--system", "--columns=ref,active"],
|
|
)?;
|
|
if !out.success {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"verify flatpak updates",
|
|
format!("flatpak list failed: {}", stderr_tail(&out.stderr_lossy())),
|
|
));
|
|
}
|
|
let mut map = std::collections::BTreeMap::new();
|
|
for line in out.stdout_lossy().lines() {
|
|
let mut cols = line.splitn(2, '\t');
|
|
let (Some(reference), Some(active)) = (cols.next(), cols.next()) else {
|
|
continue;
|
|
};
|
|
if !reference.trim().is_empty() && !active.trim().is_empty() {
|
|
map.insert(reference.trim().to_string(), active.trim().to_string());
|
|
}
|
|
}
|
|
Ok(map)
|
|
}
|
|
|
|
/// Strip the `app/`/`runtime/` type prefix so a remote ref can be matched
|
|
/// against a `flatpak list` bare ref.
|
|
fn strip_flatpak_type(reference: &str) -> &str {
|
|
reference
|
|
.strip_prefix("app/")
|
|
.or_else(|| reference.strip_prefix("runtime/"))
|
|
.unwrap_or(reference)
|
|
}
|
|
|
|
fn execute_flatpak(exec: &Exec, root: &Path, txns: &[UpdateTransaction]) -> Result<String> {
|
|
for txn in txns {
|
|
// Scope to the system installation and pin the exact reviewed commit so
|
|
// a remote that republishes in the window cannot deploy unreviewed.
|
|
let mut args = vec![
|
|
"update".to_string(),
|
|
"--system".to_string(),
|
|
"--noninteractive".to_string(),
|
|
"-y".to_string(),
|
|
];
|
|
if let Some(commit) = &txn.next_revision {
|
|
args.push(format!("--commit={commit}"));
|
|
}
|
|
args.push(txn.identity.clone());
|
|
let refs: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
|
|
run_mut(exec, root, "flatpak", &refs)?;
|
|
}
|
|
// Post-execution verification: every reviewed ref must now be at the
|
|
// reviewed commit (compared by prefix, since `flatpak list` abbreviates).
|
|
let active = installed_flatpak_active(exec, root)?;
|
|
for txn in txns {
|
|
let key = strip_flatpak_type(&txn.identity);
|
|
let actual = active.get(key);
|
|
let reached = match (txn.next_revision.as_deref(), actual) {
|
|
(Some(next), Some(a)) => next.starts_with(a.as_str()),
|
|
_ => false,
|
|
};
|
|
if !reached {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"verify flatpak updates",
|
|
format!(
|
|
"{} did not reach the reviewed commit {} (now {:?})",
|
|
txn.identity,
|
|
txn.next_revision.as_deref().unwrap_or("?"),
|
|
actual
|
|
),
|
|
));
|
|
}
|
|
}
|
|
Ok(format!(
|
|
" [flatpak] updated {} reviewed ref(s) to their reviewed commits\n",
|
|
txns.len()
|
|
))
|
|
}
|
|
|
|
/// Installed Snap revisions keyed by name.
|
|
fn installed_snap_revisions(exec: &Exec) -> Result<std::collections::BTreeMap<String, String>> {
|
|
let entries = snap::list(exec)?;
|
|
Ok(entries.into_iter().map(|e| (e.name, e.revision)).collect())
|
|
}
|
|
|
|
fn execute_snap(exec: &Exec, txns: &[UpdateTransaction]) -> Result<String> {
|
|
for txn in txns {
|
|
snap::refresh(exec, Some(txn.identity.as_str()))?;
|
|
}
|
|
let revisions = installed_snap_revisions(exec)?;
|
|
for txn in txns {
|
|
let actual = revisions.get(&txn.identity);
|
|
if txn.next_revision.is_some() && actual != txn.next_revision.as_ref() {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"verify snap updates",
|
|
format!(
|
|
"{} did not reach the reviewed revision {} (now {:?})",
|
|
txn.identity,
|
|
txn.next_revision.as_deref().unwrap_or("?"),
|
|
actual
|
|
),
|
|
));
|
|
}
|
|
}
|
|
Ok(format!(
|
|
" [snap] refreshed {} reviewed snap(s) to their reviewed revisions\n",
|
|
txns.len()
|
|
))
|
|
}
|
|
|
|
/// Apply updates across the supported lanes and report a truthful per-source
|
|
/// outcome. Flatpak and Snap execute **exactly the reviewed transactions**
|
|
/// carried in `approved` (after revalidating each source immediately before its
|
|
/// mutation); freshly discovered updates are never used as replacement
|
|
/// approval. A source that ran and failed is reported as failed with partial
|
|
/// successes preserved, and the whole action then fails.
|
|
pub fn apply_updates(
|
|
exec: &Exec,
|
|
root: &Path,
|
|
filter: Option<Backend>,
|
|
approved: Option<&ResolvedPlan>,
|
|
) -> Result<String> {
|
|
let lanes: Vec<Backend> = match filter {
|
|
Some(backend) => vec![backend],
|
|
None => vec![Backend::PortageSource, Backend::Flatpak, Backend::Snap],
|
|
};
|
|
let mut report = String::new();
|
|
report.push_str("update application (per-source outcome)\n");
|
|
let mut failed = false;
|
|
let mut completed = 0usize;
|
|
|
|
for lane in lanes {
|
|
if lane.is_portage() {
|
|
match crate::actions::portage_world_update(exec, root) {
|
|
Ok(()) => {
|
|
completed += 1;
|
|
report.push_str(" [portage] updated (emerge -uDN @world)\n");
|
|
}
|
|
Err(e) => {
|
|
failed = true;
|
|
report.push_str(&format!(" [portage] failed: {e}\n"));
|
|
}
|
|
}
|
|
} else if lane == Backend::Flatpak {
|
|
let Some(plan) = approved else {
|
|
failed = true;
|
|
report.push_str(
|
|
" [flatpak] refused: no reviewed transaction; refusing to discover unreviewed\n",
|
|
);
|
|
continue;
|
|
};
|
|
let txns: Vec<UpdateTransaction> = plan
|
|
.updates
|
|
.iter()
|
|
.filter(|t| t.source == UpdateSource::Flatpak)
|
|
.cloned()
|
|
.collect();
|
|
if txns.is_empty() {
|
|
if source_resolution_failed(plan, "flatpak") {
|
|
report.push_str(
|
|
" [flatpak] not executed: resolution failed at review; not re-discovered\n",
|
|
);
|
|
} else {
|
|
completed += 1;
|
|
report.push_str(" [flatpak] no updates were reviewed\n");
|
|
}
|
|
continue;
|
|
}
|
|
if !flatpak_available(exec, root) {
|
|
failed = true;
|
|
report.push_str(
|
|
" [flatpak] failed: the reviewed transaction cannot run; the client is not \
|
|
available in the target\n",
|
|
);
|
|
continue;
|
|
}
|
|
if !txns.iter().all(|t| t.exact) {
|
|
failed = true;
|
|
report.push_str(
|
|
" [flatpak] refused: the reviewed transaction is not exactly bindable \
|
|
(a ref or commit is missing)\n",
|
|
);
|
|
continue;
|
|
}
|
|
if let Err(e) = revalidate_flatpak(exec, root, &txns) {
|
|
failed = true;
|
|
report.push_str(&format!(" [flatpak] failed: {e}\n"));
|
|
continue;
|
|
}
|
|
match execute_flatpak(exec, root, &txns) {
|
|
Ok(note) => {
|
|
completed += 1;
|
|
report.push_str(¬e);
|
|
}
|
|
Err(e) => {
|
|
failed = true;
|
|
report.push_str(&format!(" [flatpak] failed: {e}\n"));
|
|
}
|
|
}
|
|
} else if lane == Backend::Snap {
|
|
if !crate::actions::is_host_root(root) {
|
|
failed = true;
|
|
report
|
|
.push_str(" [snap] refused: Snap cannot be redirected to an alternate root\n");
|
|
continue;
|
|
}
|
|
let Some(plan) = approved else {
|
|
failed = true;
|
|
report.push_str(
|
|
" [snap] refused: no reviewed transaction; refusing to discover unreviewed\n",
|
|
);
|
|
continue;
|
|
};
|
|
let txns: Vec<UpdateTransaction> = plan
|
|
.updates
|
|
.iter()
|
|
.filter(|t| t.source == UpdateSource::Snap)
|
|
.cloned()
|
|
.collect();
|
|
if txns.is_empty() {
|
|
if source_resolution_failed(plan, "snap") {
|
|
report.push_str(
|
|
" [snap] not executed: resolution failed at review; not re-discovered\n",
|
|
);
|
|
} else {
|
|
completed += 1;
|
|
report.push_str(" [snap] no updates were reviewed\n");
|
|
}
|
|
continue;
|
|
}
|
|
let usable = matches!(snap::status(exec), Ok(s) if s.usable());
|
|
if !usable {
|
|
failed = true;
|
|
report.push_str(
|
|
" [snap] failed: the reviewed transaction cannot run; snapd is not installed \
|
|
or active\n",
|
|
);
|
|
continue;
|
|
}
|
|
if !txns.iter().all(|t| t.exact) {
|
|
failed = true;
|
|
report.push_str(
|
|
" [snap] refused: the reviewed transaction is not exactly bindable \
|
|
(a revision is missing)\n",
|
|
);
|
|
continue;
|
|
}
|
|
if let Err(e) = revalidate_snap(exec, root, &txns) {
|
|
failed = true;
|
|
report.push_str(&format!(" [snap] failed: {e}\n"));
|
|
continue;
|
|
}
|
|
match execute_snap(exec, &txns) {
|
|
Ok(note) => {
|
|
completed += 1;
|
|
report.push_str(¬e);
|
|
}
|
|
Err(e) => {
|
|
failed = true;
|
|
report.push_str(&format!(" [snap] failed: {e}\n"));
|
|
}
|
|
}
|
|
} else if filter.is_some() {
|
|
// An explicit request for a lane with no safe system-level update
|
|
// transaction is refused, not silently reported as "updated".
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"apply updates",
|
|
format!(
|
|
"{} updates cannot be applied safely by `sys` from the system; {}",
|
|
lane.as_str(),
|
|
crate::actions::update_limitation(lane)
|
|
),
|
|
));
|
|
} else {
|
|
report.push_str(&format!(
|
|
" [{}] not applied: {}\n",
|
|
lane.as_str(),
|
|
crate::actions::update_limitation(lane)
|
|
));
|
|
}
|
|
}
|
|
|
|
if failed {
|
|
return Err(ExecError::operation("sys", "apply updates", report));
|
|
}
|
|
if completed == 0 {
|
|
return Err(ExecError::operation(
|
|
"sys",
|
|
"apply updates",
|
|
format!("{report}no source was updated"),
|
|
));
|
|
}
|
|
Ok(report)
|
|
}
|
|
|
|
/// Comprehensive overview of system health, bootloader state, storage headroom,
|
|
/// reboot requirements, and package lane readiness.
|
|
pub fn system_status_report(exec: &Exec, root: &Path) -> Result<String> {
|
|
let mut out = String::new();
|
|
out.push_str("=== Phoebus System Status ===\n\n");
|
|
|
|
// 1. Boot & Kernel Assessment
|
|
out.push_str("[Boot & Kernel]\n");
|
|
let mut entries_found = Vec::new();
|
|
for candidate_dir in [
|
|
root.join("efi/loader/entries"),
|
|
root.join("boot/loader/entries"),
|
|
root.join("boot/efi/loader/entries"),
|
|
] {
|
|
if candidate_dir.is_dir() {
|
|
if let Ok(rd) = std::fs::read_dir(&candidate_dir) {
|
|
for e in rd.flatten() {
|
|
let path = e.path();
|
|
if path.extension().and_then(|x| x.to_str()) == Some("conf") {
|
|
if let Some(fname) = path.file_name().and_then(|n| n.to_str()) {
|
|
let (stem, tries) = phoebus_core::boot::parse_bls_filename(fname);
|
|
entries_found.push((fname.to_string(), stem, tries));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if !entries_found.is_empty() {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if entries_found.is_empty() {
|
|
out.push_str(" BLS Entries: None detected in /efi or /boot\n");
|
|
} else {
|
|
out.push_str(" BLS Boot Entries:\n");
|
|
for (fname, stem, tries) in &entries_found {
|
|
let assessment = match tries {
|
|
Some(t) => format!("assessment in progress ({t} tries remaining)"),
|
|
None if stem.contains("recovery") => "recovery fallback".into(),
|
|
None => "verified good".into(),
|
|
};
|
|
out.push_str(&format!(" - {fname} [{assessment}]\n"));
|
|
}
|
|
}
|
|
|
|
// 2. Reboot & Rollback State
|
|
out.push_str("\n[Reboot & Recovery State]\n");
|
|
let reboot_flag =
|
|
root.join("run/reboot-required").exists() || root.join("var/run/reboot-required").exists();
|
|
let rollback_state = crate::rollback::load_state(root);
|
|
let reboot_status =
|
|
if rollback_state.status == phoebus_core::rollback::RollbackStatus::Activated {
|
|
format!(
|
|
"REQUIRED (rollback activated to target `{}`; reboot to complete switch)",
|
|
rollback_state.target_snapshot
|
|
)
|
|
} else if reboot_flag {
|
|
"REQUIRED (system updates pending reboot)".to_string()
|
|
} else {
|
|
"None (running system configuration is current)".to_string()
|
|
};
|
|
out.push_str(&format!(" Reboot Required: {reboot_status}\n"));
|
|
out.push_str(&format!(
|
|
" Rollback Engine: {:?} (target: {}, root: {})\n",
|
|
rollback_state.status,
|
|
if rollback_state.target_snapshot.is_empty() {
|
|
"(none)"
|
|
} else {
|
|
&rollback_state.target_snapshot
|
|
},
|
|
rollback_state.root_subvol
|
|
));
|
|
|
|
// 3. Storage Headroom & Gates
|
|
out.push_str("\n[Storage & Safety Gates]\n");
|
|
let free_mib = crate::chooser::free_storage_mib(exec, root);
|
|
let free_gib = (free_mib as f64) / 1024.0;
|
|
let gate_status = if free_mib >= crate::update::MIN_UPDATE_FREE_SPACE_MIB {
|
|
"HEALTHY (meets >= 10 GiB gate)"
|
|
} else if free_mib == 0 {
|
|
"UNKNOWN (cannot determine free space)"
|
|
} else {
|
|
"WARNING (below 10 GiB safety gate; updates will be refused)"
|
|
};
|
|
out.push_str(&format!(
|
|
" Root Free Space: {:.1} GiB [{gate_status}]\n",
|
|
free_gib
|
|
));
|
|
|
|
// 4. Btrfs Snapshots
|
|
out.push_str("\n[Btrfs Recovery Snapshots]\n");
|
|
let history = crate::snapshot::read_history(root).unwrap_or_default();
|
|
out.push_str(&format!(
|
|
" Committed Snapshots: {}\n",
|
|
history.records.len()
|
|
));
|
|
if let Some(newest) = history.records.last() {
|
|
out.push_str(&format!(
|
|
" Newest Recovery Point: {} ({}) [{:?}]\n",
|
|
newest.id, newest.operation, newest.status
|
|
));
|
|
}
|
|
|
|
// 5. Package Lanes Readiness
|
|
out.push_str("\n[Package Lanes Readiness]\n");
|
|
let facts = crate::chooser::hardware_facts(exec, root);
|
|
let lanes = [
|
|
(Backend::PortageSource, "Portage (Source)", true),
|
|
(
|
|
Backend::PortageBinary,
|
|
"Portage (Binhost)",
|
|
facts.binhost_available,
|
|
),
|
|
(
|
|
Backend::Flatpak,
|
|
"Flatpak",
|
|
facts.available_backends.contains(&Backend::Flatpak),
|
|
),
|
|
(
|
|
Backend::Nix,
|
|
"Nix",
|
|
facts.available_backends.contains(&Backend::Nix),
|
|
),
|
|
(
|
|
Backend::Snap,
|
|
"Snap",
|
|
facts.available_backends.contains(&Backend::Snap),
|
|
),
|
|
(Backend::AppImage, "AppImage", true),
|
|
(Backend::CustomEbuild, "Custom Ebuild", true),
|
|
];
|
|
for (_backend, label, ready) in lanes {
|
|
let status = if ready { "READY" } else { "NOT CONFIGURED" };
|
|
out.push_str(&format!(" {:<20}: [{status}]\n", label));
|
|
}
|
|
|
|
Ok(out)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::command::{CommandOutput, RecordingRunner};
|
|
use crate::log::Logger;
|
|
use phoebus_core::Redactor;
|
|
use std::time::Duration;
|
|
|
|
fn make_exec(runner: RecordingRunner) -> Exec {
|
|
let path = tempfile::tempdir().unwrap().keep();
|
|
let logger = Logger::open(path.join("l.log"), Redactor::new(), false);
|
|
Exec::new(Box::new(runner), logger, false, path.join("root"), path)
|
|
}
|
|
|
|
fn ok(stdout: &str) -> CommandOutput {
|
|
CommandOutput {
|
|
status: 0,
|
|
success: true,
|
|
stdout: stdout.as_bytes().to_vec(),
|
|
stderr: Vec::new(),
|
|
duration: Duration::from_millis(1),
|
|
}
|
|
}
|
|
|
|
fn fail(stderr: &str) -> CommandOutput {
|
|
CommandOutput {
|
|
status: 1,
|
|
success: false,
|
|
stdout: Vec::new(),
|
|
stderr: stderr.as_bytes().to_vec(),
|
|
duration: Duration::from_millis(1),
|
|
}
|
|
}
|
|
|
|
const EMERGE_SEARCH: &str = "\
|
|
* www-client/firefox
|
|
Latest version available: 128.0
|
|
Latest version installed: 127.0
|
|
Description: Firefox Web Browser
|
|
";
|
|
|
|
#[test]
|
|
fn search_reports_portage_results_and_distinguishes_empty() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response("emerge", ok(EMERGE_SEARCH));
|
|
let exec = make_exec(runner);
|
|
// Host root so the recording runner sees `emerge` directly, exactly as
|
|
// it does for a normal `sys` invocation.
|
|
let report = search(
|
|
&exec,
|
|
Path::new("/"),
|
|
"firefox",
|
|
Some(Backend::PortageSource),
|
|
);
|
|
assert_eq!(report.sources.len(), 1);
|
|
let source = &report.sources[0];
|
|
assert!(source.supported && source.ok);
|
|
assert_eq!(source.entries.len(), 1);
|
|
assert_eq!(source.entries[0].id, "www-client/firefox");
|
|
assert!(source.entries[0].installed);
|
|
assert_eq!(source.entries[0].version.as_deref(), Some("128.0"));
|
|
}
|
|
|
|
#[test]
|
|
fn external_overlay_search_reports_leads_without_install_candidates() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response(
|
|
"curl",
|
|
ok(r#"<a href="/Overlays/gentoo-zh">nav</a>
|
|
<a href="/app-misc/chatgpt-desktop"><div>app-misc/chatgpt-desktop
|
|
<div>Desktop application for ChatGPT and Codex</div></div></a>
|
|
<a href="/app-misc/chatgpt-desktop">duplicate</a>
|
|
<a href="/app-misc/../../bad">unsafe</a>"#),
|
|
);
|
|
let exec = make_exec(runner.clone());
|
|
let leads = search_external_overlays(&exec, Path::new("/"), "chatgpt desktop")
|
|
.expect("external search response");
|
|
assert_eq!(leads.len(), 1);
|
|
assert_eq!(leads[0].atom, "app-misc/chatgpt-desktop");
|
|
let calls = runner.recorded();
|
|
assert_eq!(calls.len(), 1);
|
|
assert_eq!(calls[0].program, "curl");
|
|
assert!(calls[0].args.iter().any(|arg| arg == "--max-time"));
|
|
assert!(calls[0]
|
|
.args
|
|
.iter()
|
|
.any(|arg| arg.ends_with("Search?search=chatgpt%20desktop")));
|
|
}
|
|
|
|
#[test]
|
|
fn external_overlay_lookup_fails_closed_when_unavailable() {
|
|
let runner = RecordingRunner::new();
|
|
runner.fail("curl", "offline");
|
|
let exec = make_exec(runner);
|
|
assert!(search_external_overlays(&exec, Path::new("/"), "chatgpt").is_err());
|
|
}
|
|
|
|
const APPIMAGE_FEED: &str = r#"{"version":1,"items":[
|
|
{"name":"Chatty_Desktop","description":"A desktop chat client","links":[{"type":"Download","url":"https://example.org/chatty/releases"}]},
|
|
{"name":"Desktop_Chatty","description":"Another client","links":[{"type":"Download","url":"http://example.org/insecure"}]},
|
|
{"name":"Notes","description":"<p>A chatty desktop note taker & organizer</p>","links":[]},
|
|
{"name":"\u001b[31mbad","description":"chatty desktop","links":[]}
|
|
]}"#;
|
|
|
|
#[test]
|
|
fn appimage_feed_results_are_ranked_and_labeled_as_leads() {
|
|
let matches = parse_appimage_feed(APPIMAGE_FEED, "chatty desktop").unwrap();
|
|
assert_eq!(matches.len(), 3);
|
|
assert_eq!(matches[0].id, "Chatty_Desktop");
|
|
assert_eq!(matches[0].scope.as_deref(), Some("catalog lead"));
|
|
assert!(!matches[0].installed);
|
|
assert_eq!(matches[0].version, None);
|
|
assert_eq!(
|
|
matches[0].url.as_deref(),
|
|
Some("https://example.org/chatty/releases")
|
|
);
|
|
assert_eq!(matches[1].id, "Desktop_Chatty");
|
|
assert_eq!(matches[1].url, None, "HTTP links are not exposed");
|
|
assert_eq!(matches[2].id, "Notes");
|
|
assert_eq!(
|
|
matches[2].description.as_deref(),
|
|
Some("A chatty desktop note taker & organizer")
|
|
);
|
|
assert!(parse_appimage_feed(r#"{"items":{}}"#, "chatty").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn appimage_feed_finds_a_product_when_query_includes_its_vendor() {
|
|
let feed = r#"{"items":[{"name":"Etcher","description":"Flash OS images","links":[]}]}"#;
|
|
let matches = parse_appimage_feed(feed, "balenaEtcher").unwrap();
|
|
assert_eq!(matches.len(), 1);
|
|
assert_eq!(matches[0].id, "Etcher");
|
|
}
|
|
|
|
#[test]
|
|
fn appimage_search_fetches_bounded_catalog_and_reports_offline_failure() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response("curl", ok(APPIMAGE_FEED));
|
|
let exec = make_exec(runner.clone());
|
|
let report = search(
|
|
&exec,
|
|
Path::new("/"),
|
|
"chatty desktop",
|
|
Some(Backend::AppImage),
|
|
);
|
|
let source = &report.sources[0];
|
|
assert!(source.ok);
|
|
assert_eq!(source.entries.len(), 3);
|
|
assert!(source.note.contains("not verified install candidates"));
|
|
assert!(report
|
|
.render()
|
|
.contains("catalog page: https://example.org/chatty/releases"));
|
|
let calls = runner.recorded();
|
|
assert_eq!(calls.len(), 1);
|
|
assert_eq!(calls[0].program, "curl");
|
|
assert!(calls[0].args.iter().any(|arg| arg == "--max-time"));
|
|
assert!(calls[0].args.iter().any(|arg| arg == "--max-filesize"));
|
|
assert!(calls[0].args.iter().any(|arg| arg == APPIMAGE_FEED_URL));
|
|
|
|
let offline = RecordingRunner::new();
|
|
offline.fail("curl", "offline");
|
|
let exec = make_exec(offline);
|
|
let report = search(
|
|
&exec,
|
|
Path::new("/"),
|
|
"chatty desktop",
|
|
Some(Backend::AppImage),
|
|
);
|
|
assert!(!report.sources[0].ok);
|
|
assert!(report.sources[0].note.contains("catalog unavailable"));
|
|
}
|
|
|
|
#[test]
|
|
fn a_failed_search_is_not_reported_as_empty() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response("emerge", fail("!!! offline"));
|
|
let exec = make_exec(runner);
|
|
let report = search(
|
|
&exec,
|
|
Path::new("/"),
|
|
"firefox",
|
|
Some(Backend::PortageSource),
|
|
);
|
|
let source = &report.sources[0];
|
|
assert!(source.supported);
|
|
assert!(!source.ok, "a failed search must not look ok");
|
|
assert!(source.note.contains("failed"));
|
|
}
|
|
|
|
#[test]
|
|
fn unavailable_nix_is_explicit_in_search_and_inventory() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let report = search(&exec, Path::new(&exec.root), "nodejs", Some(Backend::Nix));
|
|
assert!(!report.sources[0].supported);
|
|
assert!(report.sources[0].note.contains("not installed"));
|
|
|
|
let inv = inventory(&exec, Path::new(&exec.root), Some(Backend::Nix), None);
|
|
assert!(!inv.sources[0].supported);
|
|
}
|
|
|
|
#[test]
|
|
fn inventory_reads_the_portage_vdb_and_never_counts_custom_ebuilds() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
let dir = root.join("var/db/pkg/app-editors/vim-9.1.0");
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
std::fs::write(dir.join("SIZE"), "4096").unwrap();
|
|
|
|
let report = inventory(&exec, root, None, None);
|
|
let portage = report
|
|
.sources
|
|
.iter()
|
|
.find(|s| s.backend == Backend::PortageSource)
|
|
.unwrap();
|
|
assert_eq!(portage.entries.len(), 1);
|
|
assert_eq!(portage.entries[0].id, "app-editors/vim");
|
|
let custom = report
|
|
.sources
|
|
.iter()
|
|
.find(|s| s.backend == Backend::CustomEbuild)
|
|
.unwrap();
|
|
assert!(
|
|
!custom.supported,
|
|
"custom ebuilds are not counted separately"
|
|
);
|
|
assert_eq!(report.total(), 1, "the installed package is counted once");
|
|
}
|
|
|
|
#[test]
|
|
fn inventory_text_filter_matches_id_or_description() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
let dir = root.join("var/db/pkg/app-editors/vim-9.1.0");
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
std::fs::create_dir_all(root.join("var/db/pkg/net-misc/curl-8.0")).unwrap();
|
|
|
|
let report = inventory(&exec, root, None, Some("vim"));
|
|
let portage = report
|
|
.sources
|
|
.iter()
|
|
.find(|s| s.backend == Backend::PortageSource)
|
|
.unwrap();
|
|
assert_eq!(portage.entries.len(), 1);
|
|
assert_eq!(portage.entries[0].id, "app-editors/vim");
|
|
}
|
|
|
|
#[test]
|
|
fn package_info_reports_installed_portage_metadata() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response("emerge", ok(""));
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
let dir = root.join("var/db/pkg/www-client/firefox-128.0");
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
std::fs::write(dir.join("SIZE"), "1048576").unwrap();
|
|
std::fs::write(dir.join("repository"), "gentoo").unwrap();
|
|
std::fs::write(dir.join("RDEPEND"), ">=dev-libs/glib-2.0").unwrap();
|
|
|
|
let report = package_info(&exec, root, "firefox", Some(Backend::PortageSource));
|
|
let m = report
|
|
.matches
|
|
.iter()
|
|
.find(|m| m.id == "www-client/firefox")
|
|
.expect("the installed VDB atom is reported");
|
|
assert!(m.installed);
|
|
assert_eq!(m.version.as_deref(), Some("128.0"));
|
|
assert_eq!(m.provenance, "gentoo");
|
|
assert_eq!(m.size.as_deref(), Some("1048576 bytes installed"));
|
|
assert!(m.dependencies.iter().any(|d| d.contains("glib")));
|
|
assert!(!report.ambiguous(), "the bare name and atom must be merged");
|
|
}
|
|
|
|
#[test]
|
|
fn package_info_disambiguates_multiple_real_matches() {
|
|
let runner = RecordingRunner::new();
|
|
// Portage resolves one candidate; a managed AppImage supplies another.
|
|
// Both are real, so the report is ambiguous rather than guessing.
|
|
runner.set_response(
|
|
"emerge",
|
|
ok("These are the packages that would be merged:\n[ebuild N ] www-client/firefox-128.0\n"),
|
|
);
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
let dir = root.join("opt/phoebus/appimages");
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
std::fs::write(
|
|
dir.join("firefox.toml"),
|
|
"name = \"firefox\"\nversion = \"128.0\"\nsha256 = \"\"\nprovenance = \"local:/tmp/firefox.AppImage\"\narch = \"x86_64\"\nsize_bytes = 1\ninstalled_unix = 1\n",
|
|
)
|
|
.unwrap();
|
|
let report = package_info(&exec, root, "firefox", None);
|
|
assert!(
|
|
report.matches.len() >= 2,
|
|
"expected real matches, got {:?}",
|
|
report.matches
|
|
);
|
|
assert!(report.ambiguous());
|
|
assert!(report.render().contains("ambiguous"));
|
|
}
|
|
|
|
#[test]
|
|
fn depclean_previews_then_removes_and_skips_when_empty() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response(
|
|
"emerge",
|
|
ok(">>> These are the packages that would be unmerged:\n\n\
|
|
>>> No packages selected\n\n0 packages selected\n"),
|
|
);
|
|
let exec = make_exec(runner.clone());
|
|
let out = depclean(&exec, Path::new("/")).unwrap();
|
|
assert!(out.contains("nothing to remove"));
|
|
// Only the preview ran.
|
|
assert_eq!(runner.recorded().len(), 1);
|
|
|
|
let runner2 = RecordingRunner::new();
|
|
runner2.set_response("emerge", ok("...\n>>> 3 packages selected\n"));
|
|
let exec2 = make_exec(runner2.clone());
|
|
let out2 = depclean(&exec2, Path::new("/")).unwrap();
|
|
assert!(out2.contains("removed unused packages"));
|
|
assert_eq!(runner2.recorded().len(), 2);
|
|
}
|
|
|
|
fn install_fake_tool(root: &Path, name: &str) {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let bin = root.join("usr/bin");
|
|
std::fs::create_dir_all(&bin).unwrap();
|
|
let tool = bin.join(name);
|
|
std::fs::write(&tool, "#!/bin/sh\n").unwrap();
|
|
std::fs::set_permissions(&tool, std::fs::Permissions::from_mode(0o755)).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn clean_cache_without_a_cleaner_is_a_failure_not_a_silent_success() {
|
|
// A temp dir with neither eclean-dist nor eclean-pkg in the target.
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let err = clean_cache(
|
|
&exec,
|
|
Path::new(&exec.root),
|
|
Some(Backend::PortageSource),
|
|
None,
|
|
)
|
|
.unwrap_err();
|
|
let text = err.to_string();
|
|
assert!(text.contains("no cleaner ran"), "{text}");
|
|
// The unavailable tool is named distinctly from a failed tool.
|
|
assert!(text.contains("unavailable"), "{text}");
|
|
}
|
|
|
|
#[test]
|
|
fn clean_cache_propagates_a_failed_cleaner_and_preserves_partial_success() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner.clone());
|
|
let root = Path::new(&exec.root);
|
|
install_fake_tool(root, "eclean-dist");
|
|
install_fake_tool(root, "eclean-pkg");
|
|
// The first cleaner runs; the second fails. Execution is rooted in the
|
|
// target (chroot), so both are the `chroot` wrapper; fail the second.
|
|
let chroot_calls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
|
|
struct FailSecond(std::sync::Arc<std::sync::atomic::AtomicUsize>);
|
|
impl crate::command::ProcessRunner for FailSecond {
|
|
fn execute(&self, _spec: &crate::command::CommandSpec) -> Result<CommandOutput> {
|
|
let n = self.0.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
|
if n == 0 {
|
|
Ok(CommandOutput {
|
|
status: 0,
|
|
success: true,
|
|
stdout: Vec::new(),
|
|
stderr: Vec::new(),
|
|
duration: std::time::Duration::from_millis(1),
|
|
})
|
|
} else {
|
|
Ok(CommandOutput {
|
|
status: 1,
|
|
success: false,
|
|
stdout: Vec::new(),
|
|
stderr: b"eclean boom".to_vec(),
|
|
duration: std::time::Duration::from_millis(1),
|
|
})
|
|
}
|
|
}
|
|
}
|
|
let logger_path = tempfile::tempdir().unwrap().keep();
|
|
let logger = crate::log::Logger::open(
|
|
logger_path.join("l.log"),
|
|
phoebus_core::Redactor::new(),
|
|
false,
|
|
);
|
|
let exec2 = Exec::new(
|
|
Box::new(FailSecond(chroot_calls)),
|
|
logger,
|
|
false,
|
|
root,
|
|
logger_path,
|
|
);
|
|
let err = clean_cache(&exec2, root, Some(Backend::PortageSource), None).unwrap_err();
|
|
let text = err.to_string();
|
|
assert!(text.contains("eclean-dist completed"), "{text}");
|
|
assert!(text.contains("eclean-pkg failed"), "{text}");
|
|
// The runner was consulted, and no host command was issued.
|
|
assert!(runner.recorded().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn apply_updates_refuses_a_lane_without_a_safe_transaction() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let err =
|
|
apply_updates(&exec, Path::new(&exec.root), Some(Backend::AppImage), None).unwrap_err();
|
|
let text = err.to_string();
|
|
assert!(text.contains("cannot be applied safely"), "{text}");
|
|
assert!(text.contains("pinned URL"), "{text}");
|
|
}
|
|
|
|
#[test]
|
|
fn apply_updates_fails_the_action_when_an_attempted_source_fails() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response("chroot", fail("!!! emerge failed"));
|
|
let exec = make_exec(runner);
|
|
let err = apply_updates(
|
|
&exec,
|
|
Path::new(&exec.root),
|
|
Some(Backend::PortageSource),
|
|
None,
|
|
)
|
|
.unwrap_err();
|
|
assert!(err.to_string().contains("[portage] failed"));
|
|
}
|
|
|
|
#[test]
|
|
fn flatpak_update_plan_is_refused_when_the_target_has_no_client() {
|
|
let runner = RecordingRunner::new();
|
|
runner.fail("chroot", "flatpak: not found");
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
let plan = crate::actions::resolve_effects(
|
|
&exec,
|
|
&phoebus_core::action::SystemAction::ApplyUpdates {
|
|
backend: Some(Backend::Flatpak),
|
|
},
|
|
root,
|
|
);
|
|
// No flatpak in the target, so the plan is refused rather than silently
|
|
// reporting success.
|
|
assert!(plan.is_err());
|
|
}
|
|
|
|
// --- Exact Flatpak/Snap update transactions ---------------------------
|
|
|
|
fn ok_out(s: &str) -> crate::command::CommandOutput {
|
|
crate::command::CommandOutput {
|
|
status: 0,
|
|
success: true,
|
|
stdout: s.as_bytes().to_vec(),
|
|
stderr: Vec::new(),
|
|
duration: std::time::Duration::from_millis(1),
|
|
}
|
|
}
|
|
|
|
/// One fake Flatpak ref update (normalized ref, latest version, target commit).
|
|
#[derive(Clone)]
|
|
struct FpUpdate {
|
|
reference: String,
|
|
version: String,
|
|
commit: String,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct FpState {
|
|
/// ref -> (version, commit)
|
|
installed: std::collections::BTreeMap<String, (String, String)>,
|
|
updates: Vec<FpUpdate>,
|
|
/// Apply the update to `installed` on `flatpak update`.
|
|
apply: bool,
|
|
/// A ref whose update command fails.
|
|
fail_ref: Option<String>,
|
|
update_calls: Vec<Vec<String>>,
|
|
}
|
|
|
|
struct FpRunner {
|
|
state: std::sync::Mutex<FpState>,
|
|
}
|
|
|
|
impl FpRunner {
|
|
fn new(state: FpState) -> Self {
|
|
Self {
|
|
state: std::sync::Mutex::new(state),
|
|
}
|
|
}
|
|
fn set_updates(&self, updates: Vec<FpUpdate>) {
|
|
self.state.lock().unwrap().updates = updates;
|
|
}
|
|
fn update_calls(&self) -> Vec<Vec<String>> {
|
|
self.state.lock().unwrap().update_calls.clone()
|
|
}
|
|
}
|
|
|
|
impl crate::command::ProcessRunner for FpRunner {
|
|
fn execute(&self, spec: &crate::command::CommandSpec) -> Result<CommandOutput> {
|
|
let is_flatpak = spec.args.iter().any(|a| a == "flatpak");
|
|
if !is_flatpak {
|
|
return Ok(ok_out(""));
|
|
}
|
|
if spec.args.iter().any(|a| a == "--version") {
|
|
return Ok(ok_out("Flatpak 1.18\n"));
|
|
}
|
|
if spec.args.iter().any(|a| a == "remote-ls") {
|
|
let state = self.state.lock().unwrap();
|
|
let mut text = String::new();
|
|
// remote-ls columns: ref, version (the remote ref form is
|
|
// normalized by the caller, so use the local form here).
|
|
for u in &state.updates {
|
|
text.push_str(&format!("{}\t{}\n", u.reference, u.version));
|
|
}
|
|
return Ok(ok_out(&text));
|
|
}
|
|
// The user installation is empty in these fixtures.
|
|
if spec.args.iter().any(|a| a == "--user") {
|
|
return Ok(ok_out(""));
|
|
}
|
|
// Verification: bare ref -> active commit.
|
|
if spec.args.iter().any(|a| a == "list") {
|
|
let state = self.state.lock().unwrap();
|
|
let mut text = String::new();
|
|
for (r, (_, commit)) in &state.installed {
|
|
let bare = r
|
|
.strip_prefix("app/")
|
|
.or_else(|| r.strip_prefix("runtime/"))
|
|
.unwrap_or(r);
|
|
text.push_str(&format!("{bare}\t{commit}\n"));
|
|
}
|
|
return Ok(ok_out(&text));
|
|
}
|
|
if spec.args.iter().any(|a| a == "info") {
|
|
let state = self.state.lock().unwrap();
|
|
let identity = spec.args.last().cloned().unwrap_or_default();
|
|
let (version, active) = state
|
|
.installed
|
|
.get(&identity)
|
|
.cloned()
|
|
.unwrap_or(("?".into(), "?".into()));
|
|
let latest = state
|
|
.updates
|
|
.iter()
|
|
.find(|u| u.reference == identity)
|
|
.map(|u| u.commit.clone())
|
|
.unwrap_or_else(|| active.clone());
|
|
return Ok(ok_out(&format!(
|
|
"Version: {version}\nActive commit: {active}\nLatest commit: {latest}\n"
|
|
)));
|
|
}
|
|
if spec.args.iter().any(|a| a == "update") {
|
|
let mut state = self.state.lock().unwrap();
|
|
let target = spec.args.last().cloned().unwrap_or_default();
|
|
state.update_calls.push(spec.args.clone());
|
|
if state.fail_ref.as_deref() == Some(target.as_str()) {
|
|
return Ok(crate::command::CommandOutput {
|
|
status: 1,
|
|
success: false,
|
|
stdout: Vec::new(),
|
|
stderr: b"update failed".to_vec(),
|
|
duration: std::time::Duration::from_millis(1),
|
|
});
|
|
}
|
|
if state.apply {
|
|
let applied = state
|
|
.updates
|
|
.iter()
|
|
.find(|u| u.reference == target)
|
|
.map(|u| (u.version.clone(), u.commit.clone()));
|
|
if let Some((version, commit)) = applied {
|
|
state.installed.insert(target.clone(), (version, commit));
|
|
}
|
|
}
|
|
return Ok(ok_out("updated\n"));
|
|
}
|
|
Ok(ok_out(""))
|
|
}
|
|
}
|
|
|
|
fn fp_exec(state: FpState) -> (Exec, std::sync::Arc<FpRunner>) {
|
|
let path = tempfile::tempdir().unwrap().keep();
|
|
let logger =
|
|
crate::log::Logger::open(path.join("l.log"), phoebus_core::Redactor::new(), false);
|
|
let runner = std::sync::Arc::new(FpRunner::new(state));
|
|
// The runner must be shared; Exec owns a Box, so wrap an Arc-backed clone.
|
|
struct Shared(std::sync::Arc<FpRunner>);
|
|
impl crate::command::ProcessRunner for Shared {
|
|
fn execute(&self, spec: &crate::command::CommandSpec) -> Result<CommandOutput> {
|
|
self.0.execute(spec)
|
|
}
|
|
}
|
|
let exec = Exec::new(
|
|
Box::new(Shared(runner.clone())),
|
|
logger,
|
|
false,
|
|
path.join("root"),
|
|
path,
|
|
);
|
|
// `tool_in_target` needs a real flatpak binary in the target.
|
|
install_fake_tool(&exec.root, "flatpak");
|
|
(exec, runner)
|
|
}
|
|
|
|
fn fp_update(reference: &str, version: &str, commit: &str) -> FpUpdate {
|
|
FpUpdate {
|
|
reference: reference.into(),
|
|
version: version.into(),
|
|
commit: commit.into(),
|
|
}
|
|
}
|
|
|
|
fn resolve_flatpak_plan(exec: &Exec) -> ResolvedPlan {
|
|
crate::actions::resolve_effects(
|
|
exec,
|
|
&phoebus_core::action::SystemAction::ApplyUpdates {
|
|
backend: Some(Backend::Flatpak),
|
|
},
|
|
&exec.root,
|
|
)
|
|
.unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn flatpak_update_transactions_bind_full_refs_and_immutable_commits() {
|
|
let ref_firefox = "app/org.mozilla.firefox/x86_64/stable";
|
|
// updates: ref, application, version, branch, commit, origin, arch
|
|
// `flatpak info` is the full-commit source; the ref keeps its
|
|
// `app/`/`runtime/` type prefix, which `info` and `update` require.
|
|
let info = "Version: 51.0\nActive commit: OLDCOMMIT\nLatest commit: NEWCOMMIT\n";
|
|
let (version, active, latest) = crate::actions::parse_flatpak_info(info);
|
|
assert_eq!(version.as_deref(), Some("51.0"));
|
|
assert_eq!(active.as_deref(), Some("OLDCOMMIT"));
|
|
assert_eq!(latest.as_deref(), Some("NEWCOMMIT"));
|
|
assert!(ref_firefox.starts_with("app/"));
|
|
}
|
|
|
|
#[test]
|
|
fn snap_update_transactions_bind_revisions_and_scope() {
|
|
let refresh = "Name Version Rev Tracking Publisher Notes\n\
|
|
hello 2.11 32 latest/stable canonical✓ -\n";
|
|
let installed = "Name Version Rev Tracking Publisher Notes\n\
|
|
hello 2.10 29 latest/stable canonical✓ -\n";
|
|
let txns = crate::actions::parse_snap_transactions(refresh, installed);
|
|
assert_eq!(txns.len(), 1);
|
|
let t = &txns[0];
|
|
assert_eq!(t.identity, "hello");
|
|
assert_eq!(t.previous_version.as_deref(), Some("2.10"));
|
|
assert_eq!(t.next_version, "2.11");
|
|
assert_eq!(t.previous_revision.as_deref(), Some("29"));
|
|
assert_eq!(t.next_revision.as_deref(), Some("32"));
|
|
assert_eq!(t.scope.as_deref(), Some("latest/stable"));
|
|
assert!(t.exact);
|
|
}
|
|
|
|
#[test]
|
|
fn flatpak_update_execution_carries_the_reviewed_transaction() {
|
|
let ref_a = "app/org.mozilla.firefox/x86_64/stable";
|
|
let ref_b = "runtime/org.gnome.Platform/x86_64/45";
|
|
let mut state = FpState {
|
|
apply: true,
|
|
..Default::default()
|
|
};
|
|
state
|
|
.installed
|
|
.insert(ref_a.into(), ("128".into(), "OLD_A".into()));
|
|
state
|
|
.installed
|
|
.insert(ref_b.into(), ("45.1".into(), "OLD_B".into()));
|
|
let (exec, runner) = fp_exec(state);
|
|
runner.set_updates(vec![
|
|
fp_update(ref_a, "129", "NEW_A"),
|
|
fp_update(ref_b, "45.2", "NEW_B"),
|
|
]);
|
|
let plan = resolve_flatpak_plan(&exec);
|
|
// The reviewed plan binds full refs, commits and the runtime.
|
|
assert_eq!(plan.updates.len(), 2);
|
|
assert!(plan.updates.iter().all(|t| t.exact));
|
|
assert!(plan.updates.iter().any(|t| t.identity == ref_b));
|
|
|
|
let out = apply_updates(
|
|
&exec,
|
|
Path::new(&exec.root),
|
|
Some(Backend::Flatpak),
|
|
Some(&plan),
|
|
)
|
|
.unwrap();
|
|
assert!(out.contains("updated 2 reviewed ref"), "{out}");
|
|
let calls = runner.update_calls();
|
|
assert_eq!(calls.len(), 2);
|
|
for call in &calls {
|
|
assert!(call.iter().any(|a| a == "-y"));
|
|
assert!(call.iter().any(|a| a == "--system"));
|
|
assert!(call.iter().any(|a| a == "--noninteractive"));
|
|
assert!(call.iter().any(|a| a.starts_with("--commit=")));
|
|
}
|
|
assert!(calls.iter().any(|c| c.last().unwrap() == ref_a));
|
|
assert!(calls.iter().any(|c| c.last().unwrap() == ref_b));
|
|
}
|
|
|
|
#[test]
|
|
fn flatpak_update_refuses_a_changed_commit_with_unchanged_version() {
|
|
let reference = "app/org.mozilla.firefox/x86_64/stable";
|
|
let mut state = FpState {
|
|
apply: true,
|
|
..Default::default()
|
|
};
|
|
state
|
|
.installed
|
|
.insert(reference.into(), ("128".into(), "OLD".into()));
|
|
let (exec, runner) = fp_exec(state);
|
|
runner.set_updates(vec![fp_update(reference, "129", "REVIEWED")]);
|
|
let plan = resolve_flatpak_plan(&exec);
|
|
// The remote silently republishes a different commit with the same
|
|
// human-readable version.
|
|
runner.set_updates(vec![fp_update(reference, "129", "DIFFERENT")]);
|
|
let err = apply_updates(
|
|
&exec,
|
|
Path::new(&exec.root),
|
|
Some(Backend::Flatpak),
|
|
Some(&plan),
|
|
)
|
|
.unwrap_err();
|
|
assert!(
|
|
err.to_string().contains("changed before execution"),
|
|
"{err}"
|
|
);
|
|
// No update command may have run for an unreviewed commit.
|
|
assert!(runner.update_calls().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn flatpak_update_refuses_a_newly_appeared_update() {
|
|
let reference = "app/org.mozilla.firefox/x86_64/stable";
|
|
let mut state = FpState {
|
|
apply: true,
|
|
..Default::default()
|
|
};
|
|
state
|
|
.installed
|
|
.insert(reference.into(), ("128".into(), "OLD".into()));
|
|
let (exec, runner) = fp_exec(state);
|
|
runner.set_updates(vec![fp_update(reference, "129", "NEW")]);
|
|
let plan = resolve_flatpak_plan(&exec);
|
|
// A second update appears after review.
|
|
runner.set_updates(vec![
|
|
fp_update(reference, "129", "NEW"),
|
|
fp_update("app/org.gnome.Calc/x86_64/stable", "46", "CALC"),
|
|
]);
|
|
let err = apply_updates(
|
|
&exec,
|
|
Path::new(&exec.root),
|
|
Some(Backend::Flatpak),
|
|
Some(&plan),
|
|
)
|
|
.unwrap_err();
|
|
assert!(
|
|
err.to_string().contains("changed before execution"),
|
|
"{err}"
|
|
);
|
|
assert!(runner.update_calls().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn flatpak_update_verifies_the_resulting_state() {
|
|
let reference = "app/org.mozilla.firefox/x86_64/stable";
|
|
let mut state = FpState {
|
|
// Do NOT apply: the installed commit never reaches the reviewed one.
|
|
apply: false,
|
|
..Default::default()
|
|
};
|
|
state
|
|
.installed
|
|
.insert(reference.into(), ("128".into(), "OLD".into()));
|
|
let (exec, runner) = fp_exec(state);
|
|
runner.set_updates(vec![fp_update(reference, "129", "NEW")]);
|
|
let plan = resolve_flatpak_plan(&exec);
|
|
let err = apply_updates(
|
|
&exec,
|
|
Path::new(&exec.root),
|
|
Some(Backend::Flatpak),
|
|
Some(&plan),
|
|
)
|
|
.unwrap_err();
|
|
let text = err.to_string();
|
|
assert!(text.contains("did not reach the reviewed commit"), "{text}");
|
|
}
|
|
|
|
#[test]
|
|
fn flatpak_execution_requires_a_reviewed_transaction() {
|
|
let (exec, runner) = fp_exec(FpState {
|
|
apply: true,
|
|
..Default::default()
|
|
});
|
|
// No approved plan is supplied: the source must refuse rather than
|
|
// discover and execute.
|
|
let err =
|
|
apply_updates(&exec, Path::new(&exec.root), Some(Backend::Flatpak), None).unwrap_err();
|
|
assert!(err.to_string().contains("no reviewed transaction"), "{err}");
|
|
assert!(runner.update_calls().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn a_source_that_failed_resolution_is_not_re_discovered_at_execution() {
|
|
let (exec, runner) = fp_exec(FpState {
|
|
apply: true,
|
|
..Default::default()
|
|
});
|
|
runner.set_updates(vec![fp_update(
|
|
"org.mozilla.firefox/x86_64/stable",
|
|
"129",
|
|
"NEW",
|
|
)]);
|
|
// The reviewed plan recorded that Flatpak could not be resolved and so
|
|
// carries no transaction. Even though updates are now available, they
|
|
// must not be executed.
|
|
let mut approved = ResolvedPlan {
|
|
established: true,
|
|
..Default::default()
|
|
};
|
|
approved
|
|
.consequences
|
|
.push("[flatpak] updates could not be resolved: offline".into());
|
|
approved.recompute_digest();
|
|
let err = apply_updates(
|
|
&exec,
|
|
Path::new(&exec.root),
|
|
Some(Backend::Flatpak),
|
|
Some(&approved),
|
|
)
|
|
.unwrap_err();
|
|
let text = err.to_string();
|
|
assert!(text.contains("not re-discovered"), "{text}");
|
|
// Most importantly, no update and no re-discovery happened: the runner
|
|
// recorded no update call.
|
|
assert!(runner.update_calls().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn alternate_root_flatpak_search_is_chrooted_and_never_host() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response("chroot", ok("org.mozilla.firefox\t128\tFirefox\n"));
|
|
let exec = make_exec(runner.clone());
|
|
let root = Path::new(&exec.root);
|
|
install_fake_tool(root, "flatpak");
|
|
let report = search(&exec, root, "firefox", Some(Backend::Flatpak));
|
|
assert!(report.sources[0].supported, "{:?}", report.sources[0]);
|
|
// No host flatpak/snap process may be invoked for an alternate root.
|
|
assert!(
|
|
!runner
|
|
.recorded()
|
|
.iter()
|
|
.any(|s| s.program == "flatpak" || s.program == "snap"),
|
|
"{:?}",
|
|
runner.programs()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn flatpak_no_matches_message_is_not_a_catalog_entry() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response("chroot", ok("No matches found\n"));
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
install_fake_tool(root, "flatpak");
|
|
let report = search(&exec, root, "missing-app", Some(Backend::Flatpak));
|
|
assert!(report.sources[0].ok);
|
|
assert!(report.sources[0].entries.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn multiword_search_broadens_an_empty_lane_and_labels_the_fallback() {
|
|
struct SearchFallbackRunner;
|
|
impl crate::command::ProcessRunner for SearchFallbackRunner {
|
|
fn execute(&self, spec: &CommandSpec) -> Result<CommandOutput> {
|
|
let output = if spec.args.last().map(String::as_str) == Some("chatgpt desktop") {
|
|
"No matches found\n"
|
|
} else if spec.args.last().map(String::as_str) == Some("chatgpt") {
|
|
"com.example.ChatGPT\t1.0\tChatGPT Desktop\n"
|
|
} else {
|
|
""
|
|
};
|
|
Ok(ok(output))
|
|
}
|
|
}
|
|
let path = tempfile::tempdir().unwrap().keep();
|
|
let root = path.join("root");
|
|
install_fake_tool(&root, "flatpak");
|
|
let logger = Logger::open(path.join("l.log"), Redactor::new(), false);
|
|
let exec = Exec::new(
|
|
Box::new(SearchFallbackRunner),
|
|
logger,
|
|
false,
|
|
root.clone(),
|
|
path,
|
|
);
|
|
let report = search(&exec, &root, "chatgpt desktop", Some(Backend::Flatpak));
|
|
assert_eq!(report.sources[0].entries[0].id, "com.example.ChatGPT");
|
|
assert!(report.sources[0]
|
|
.note
|
|
.contains("broadened search to `chatgpt`"));
|
|
}
|
|
|
|
#[test]
|
|
fn apply_updates_never_runs_host_snap_for_an_alternate_root() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner.clone());
|
|
let err =
|
|
apply_updates(&exec, Path::new(&exec.root), Some(Backend::Snap), None).unwrap_err();
|
|
assert!(err.to_string().contains("alternate root"), "{err}");
|
|
// Crucially, no host `snap` command was attempted.
|
|
assert!(
|
|
!runner.recorded().iter().any(|s| s.program == "snap"),
|
|
"alternate-root snap must not touch the host: {:?}",
|
|
runner.programs()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parse_flatpak_lines_handles_tabs_and_spaces() {
|
|
let rows =
|
|
parse_flatpak_lines("org.mozilla.firefox\t128.0\tFirefox\norg.gnome.Calc 45 Calc\n");
|
|
assert_eq!(rows.len(), 2);
|
|
assert_eq!(rows[0], vec!["org.mozilla.firefox", "128.0", "Firefox"]);
|
|
assert_eq!(rows[1], vec!["org.gnome.Calc", "45", "Calc"]);
|
|
}
|
|
|
|
#[test]
|
|
fn split_depend_keeps_real_atoms() {
|
|
let deps = split_depend(">=dev-libs/glib-2.0 !dev-libs/foo app-misc/hello");
|
|
assert_eq!(
|
|
deps,
|
|
vec![">=dev-libs/glib-2.0", "dev-libs/foo", "app-misc/hello"]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn package_dependencies_uses_installed_metadata_not_an_install_plan() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
// `vim` depends on an already-installed runtime library, a conditional
|
|
// dependency and a blocker; `vim-core` is already installed.
|
|
for (atom, version) in [
|
|
("app-editors/vim", "9.1.0"),
|
|
("app-editors/vim-core", "9.1.0"),
|
|
] {
|
|
let dir = root.join(format!("var/db/pkg/{atom}-{version}"));
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
}
|
|
std::fs::write(
|
|
root.join("var/db/pkg/app-editors/vim-9.1.0/RDEPEND"),
|
|
"app-editors/vim-core python? ( dev-lang/python ) !app-editors/vim-minimal",
|
|
)
|
|
.unwrap();
|
|
|
|
let out = package_dependencies(&exec, root, "app-editors/vim", false).unwrap();
|
|
assert!(out.contains("app-editors/vim-core"), "{out}");
|
|
assert!(
|
|
out.contains("(installed)"),
|
|
"satisfied deps included: {out}"
|
|
);
|
|
assert!(out.contains("dev-lang/python"), "{out}");
|
|
assert!(
|
|
out.contains("python?"),
|
|
"conditional context preserved: {out}"
|
|
);
|
|
assert!(out.contains("blocker"), "{out}");
|
|
// The requested package is never reported as its own dependency.
|
|
assert!(
|
|
!out.contains("app-editors/vim (") && !out.contains("app-editors/vim-9.1.0"),
|
|
"{out}"
|
|
);
|
|
}
|
|
|
|
fn install_vdb(root: &Path, atom: &str, version: &str, fields: &[(&str, &str)]) {
|
|
let dir = root.join(format!("var/db/pkg/{atom}-{version}"));
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
for (name, value) in fields {
|
|
std::fs::write(dir.join(name), value).unwrap();
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn package_dependencies_reverse_finds_installed_dependants() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
let dir = root.join("var/db/pkg/app-misc/tool-1.0");
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
std::fs::write(dir.join("RDEPEND"), ">=dev-libs/glib-2.0").unwrap();
|
|
|
|
let out = package_dependencies(&exec, root, "dev-libs/glib", true).unwrap();
|
|
assert!(out.contains("app-misc/tool"), "{out}");
|
|
|
|
// A genuinely empty reverse set is distinct from a failed query.
|
|
let empty = package_dependencies(&exec, root, "dev-libs/nothing", true).unwrap();
|
|
assert!(empty.contains("no installed package depends on"), "{empty}");
|
|
}
|
|
|
|
#[test]
|
|
fn reverse_dependencies_include_an_installed_target() {
|
|
// Regression: the queried package is installed, and a *different*
|
|
// installed package depends on it. The old self-reference check compared
|
|
// the dependency target with the queried package and wrongly dropped
|
|
// exactly this valid match.
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
install_vdb(root, "dev-libs/libfoo", "1.2.3", &[]);
|
|
install_vdb(
|
|
root,
|
|
"app-misc/consumer",
|
|
"2.0",
|
|
&[("RDEPEND", ">=dev-libs/libfoo-1.2")],
|
|
);
|
|
|
|
// Full and bare names both find the real dependent.
|
|
for query in ["dev-libs/libfoo", "libfoo"] {
|
|
let out = package_dependencies(&exec, root, query, true).unwrap();
|
|
assert!(out.contains("app-misc/consumer"), "{query} -> {out}");
|
|
assert!(out.contains("dev-libs/libfoo"), "{query} -> {out}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn reverse_dependencies_handle_conditionals_and_exclude_self_references() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
install_vdb(root, "dev-libs/libfoo", "1.2.3", &[]);
|
|
install_vdb(
|
|
root,
|
|
"app-misc/consumer",
|
|
"2.0",
|
|
&[(
|
|
"RDEPEND",
|
|
"ssl? ( >=dev-libs/libfoo-1.2 ) !dev-libs/libfoo[old]",
|
|
)],
|
|
);
|
|
// A genuine self-reference: libfoo declares a dependency on itself.
|
|
install_vdb(
|
|
root,
|
|
"dev-libs/libfoo",
|
|
"1.2.3",
|
|
&[("RDEPEND", ">=dev-libs/libfoo-1.2")],
|
|
);
|
|
|
|
let out = package_dependencies(&exec, root, "dev-libs/libfoo", true).unwrap();
|
|
assert!(out.contains("from app-misc/consumer"), "{out}");
|
|
assert!(out.contains("ssl?"), "condition preserved: {out}");
|
|
assert!(
|
|
!out.contains("from dev-libs/libfoo"),
|
|
"a package declaring a dependency on itself is not a dependent: {out}"
|
|
);
|
|
|
|
// A negative: nothing depends on an unrelated installed package.
|
|
let none = package_dependencies(&exec, root, "app-misc/lonely", true).unwrap();
|
|
assert!(none.contains("no installed package depends on"), "{none}");
|
|
}
|
|
|
|
#[test]
|
|
fn check_updates_can_be_restricted_to_one_source() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let overview = check_updates(&exec, Path::new("/"), Some(Backend::AppImage));
|
|
assert_eq!(overview.sources.len(), 1);
|
|
assert_eq!(overview.sources[0].backend, Backend::AppImage);
|
|
assert!(!overview.sources[0].supported);
|
|
assert!(overview.sources[0].note.contains("AppImage"));
|
|
}
|
|
|
|
#[test]
|
|
fn system_status_report_renders_all_sections() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner);
|
|
let root = Path::new(&exec.root);
|
|
|
|
// Populate a sample BLS entry with boot counting
|
|
let bls_dir = root.join("efi/loader/entries");
|
|
std::fs::create_dir_all(&bls_dir).unwrap();
|
|
std::fs::write(bls_dir.join("phoebus+3.conf"), "title Phoebus OS\n").unwrap();
|
|
std::fs::write(bls_dir.join("phoebus-recovery.conf"), "title Recovery\n").unwrap();
|
|
|
|
let report = system_status_report(&exec, root).unwrap();
|
|
assert!(report.contains("=== Phoebus System Status ==="));
|
|
assert!(report.contains("[Boot & Kernel]"));
|
|
assert!(report.contains("phoebus+3.conf [assessment in progress (3 tries remaining)]"));
|
|
assert!(report.contains("phoebus-recovery.conf [recovery fallback]"));
|
|
assert!(report.contains("[Reboot & Recovery State]"));
|
|
assert!(report.contains("[Storage & Safety Gates]"));
|
|
assert!(report.contains("[Btrfs Recovery Snapshots]"));
|
|
assert!(report.contains("[Package Lanes Readiness]"));
|
|
assert!(report.contains("Portage (Source)"));
|
|
}
|
|
}
|