fix(sys): close host/target, revalidation, update-effect and inspection defects in the package catalogue
This commit is contained in:
parent
05d7075341
commit
58e0f70879
12 changed files with 2346 additions and 530 deletions
|
|
@ -600,9 +600,19 @@ impl SystemAction {
|
||||||
| SystemAction::DiscoverCandidates { backend, .. } => *backend,
|
| SystemAction::DiscoverCandidates { backend, .. } => *backend,
|
||||||
SystemAction::InspectCandidate { backend, .. } => Some(*backend),
|
SystemAction::InspectCandidate { backend, .. } => Some(*backend),
|
||||||
SystemAction::CheckBackend { backend } => Some(*backend),
|
SystemAction::CheckBackend { backend } => Some(*backend),
|
||||||
SystemAction::InstallPackage { .. } | SystemAction::InspectPackage { .. } => {
|
// Portage-only actions. These must be classified so a request
|
||||||
Some(Backend::PortageSource)
|
// constrained to another lane can never reach them through the
|
||||||
}
|
// `backend() == None` loophole (UpdateSystem, RemovePackage,
|
||||||
|
// Depclean, PrepareUpdates, ownership and dependency inspection).
|
||||||
|
SystemAction::InstallPackage { .. }
|
||||||
|
| SystemAction::InspectPackage { .. }
|
||||||
|
| SystemAction::RemovePackage { .. }
|
||||||
|
| SystemAction::UpdateSystem
|
||||||
|
| SystemAction::PrepareUpdates
|
||||||
|
| SystemAction::InspectUpdates
|
||||||
|
| SystemAction::PackageOwners { .. }
|
||||||
|
| SystemAction::PackageDependencies { .. }
|
||||||
|
| SystemAction::Depclean => Some(Backend::PortageSource),
|
||||||
SystemAction::FlatpakInstall { .. }
|
SystemAction::FlatpakInstall { .. }
|
||||||
| SystemAction::FlatpakRemove { .. }
|
| SystemAction::FlatpakRemove { .. }
|
||||||
| SystemAction::FlatpakList => Some(Backend::Flatpak),
|
| SystemAction::FlatpakList => Some(Backend::Flatpak),
|
||||||
|
|
|
||||||
|
|
@ -47,11 +47,29 @@ pub struct PackageEffect {
|
||||||
pub source: EffectSource,
|
pub source: EffectSource,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// One destructive cache-cleanup intent, bound to approval.
|
||||||
|
///
|
||||||
|
/// A cleaner is only ever run after its exact dry-run item list has been
|
||||||
|
/// reviewed. `unavailable` distinguishes a missing tool from a tool that ran
|
||||||
|
/// and reported nothing to remove, so an unavailable cleaner is never presented
|
||||||
|
/// as a completed cleanup.
|
||||||
|
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
pub struct CleanupEffect {
|
||||||
|
/// The cleaner (e.g. `eclean-dist`, `eclean-pkg`, `nix-store --gc`).
|
||||||
|
pub cleaner: String,
|
||||||
|
/// The exact items/paths the non-destructive dry run reported.
|
||||||
|
pub items: Vec<String>,
|
||||||
|
/// The tool is not present in the target.
|
||||||
|
pub unavailable: bool,
|
||||||
|
}
|
||||||
|
|
||||||
/// A fully resolved, human-reviewable plan.
|
/// A fully resolved, human-reviewable plan.
|
||||||
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
|
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
#[serde(default)]
|
#[serde(default)]
|
||||||
pub struct ResolvedPlan {
|
pub struct ResolvedPlan {
|
||||||
pub effects: Vec<PackageEffect>,
|
pub effects: Vec<PackageEffect>,
|
||||||
|
/// Destructive cache-cleanup intents, each bound to its reviewed dry run.
|
||||||
|
pub cleanup: Vec<CleanupEffect>,
|
||||||
pub download_bytes: Option<u64>,
|
pub download_bytes: Option<u64>,
|
||||||
/// A recovery point that will exist before the change (snapshot id).
|
/// A recovery point that will exist before the change (snapshot id).
|
||||||
pub recovery_point: Option<String>,
|
pub recovery_point: Option<String>,
|
||||||
|
|
@ -126,6 +144,20 @@ impl ResolvedPlan {
|
||||||
}
|
}
|
||||||
hasher.update(b"\n");
|
hasher.update(b"\n");
|
||||||
}
|
}
|
||||||
|
// Cleanup intents are part of the approved material change: a cleaner
|
||||||
|
// that would now delete a different item set must invalidate approval.
|
||||||
|
for cleanup in &self.cleanup {
|
||||||
|
hasher.update(b"cleanup\0");
|
||||||
|
hasher.update(cleanup.cleaner.as_bytes());
|
||||||
|
hasher.update(b"\0");
|
||||||
|
hasher.update([cleanup.unavailable as u8]);
|
||||||
|
hasher.update(b"\0");
|
||||||
|
for item in &cleanup.items {
|
||||||
|
hasher.update(item.as_bytes());
|
||||||
|
hasher.update(b"\n");
|
||||||
|
}
|
||||||
|
hasher.update(b"\0");
|
||||||
|
}
|
||||||
self.digest = format!("{:x}", hasher.finalize());
|
self.digest = format!("{:x}", hasher.finalize());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -165,6 +197,23 @@ impl ResolvedPlan {
|
||||||
self.source_builds(),
|
self.source_builds(),
|
||||||
self.binary_packages()
|
self.binary_packages()
|
||||||
));
|
));
|
||||||
|
for cleanup in &self.cleanup {
|
||||||
|
if cleanup.unavailable {
|
||||||
|
out.push_str(&format!(
|
||||||
|
" [cleanup] {} is not available in the target\n",
|
||||||
|
cleanup.cleaner
|
||||||
|
));
|
||||||
|
} else {
|
||||||
|
out.push_str(&format!(
|
||||||
|
" [cleanup] {} would remove {} item(s)\n",
|
||||||
|
cleanup.cleaner,
|
||||||
|
cleanup.items.len()
|
||||||
|
));
|
||||||
|
for item in &cleanup.items {
|
||||||
|
out.push_str(&format!(" - {item}\n"));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
if let Some(bytes) = self.download_bytes {
|
if let Some(bytes) = self.download_bytes {
|
||||||
out.push_str(&format!(" download: {} MiB\n", bytes / (1024 * 1024)));
|
out.push_str(&format!(" download: {} MiB\n", bytes / (1024 * 1024)));
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -6,8 +6,11 @@
|
||||||
use std::path::Path;
|
use std::path::Path;
|
||||||
|
|
||||||
use phoebus_core::action::SystemAction;
|
use phoebus_core::action::SystemAction;
|
||||||
use phoebus_core::effects::{changed_materially, parse_emerge_pretend, ResolvedPlan};
|
use phoebus_core::effects::{
|
||||||
use phoebus_core::selection::Need;
|
changed_materially, parse_emerge_pretend, CleanupEffect, EffectKind, EffectSource,
|
||||||
|
PackageEffect, ResolvedPlan,
|
||||||
|
};
|
||||||
|
use phoebus_core::selection::{Backend, Need};
|
||||||
use phoebus_core::transaction::TransactionOutcome;
|
use phoebus_core::transaction::TransactionOutcome;
|
||||||
|
|
||||||
use crate::auth::DestructiveAuthorization;
|
use crate::auth::DestructiveAuthorization;
|
||||||
|
|
@ -68,7 +71,7 @@ pub(crate) fn is_host_root(root: &Path) -> bool {
|
||||||
/// root, or inside the target chroot for an alternate root. This is the single
|
/// root, or inside the target chroot for an alternate root. This is the single
|
||||||
/// place package, service and Flatpak commands are rooted, so preview and
|
/// place package, service and Flatpak commands are rooted, so preview and
|
||||||
/// execution always target the same system.
|
/// execution always target the same system.
|
||||||
fn target_spec(
|
pub(crate) fn target_spec(
|
||||||
root: &Path,
|
root: &Path,
|
||||||
stage: &str,
|
stage: &str,
|
||||||
operation: &str,
|
operation: &str,
|
||||||
|
|
@ -176,81 +179,37 @@ fn pretend_args(action: &SystemAction) -> Option<Vec<String>> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Whether [`resolve_effects`] produces a real, comparable package plan for an
|
/// Whether [`resolve_effects`] produces a real, comparable plan for an action.
|
||||||
/// action. Only Portage transactions have `emerge --pretend` effects; other
|
///
|
||||||
/// lanes' effects are resolved by the install layer. Callers that compare a
|
/// Portage transactions resolve from `emerge --pretend`; the maintenance
|
||||||
/// re-resolution against a reviewed plan must use this to avoid treating a
|
/// actions (depclean, per-source updates, cache cleanup) resolve a structured,
|
||||||
/// "no comparable package plan" result as a material change.
|
/// digest-bound plan too. Callers that compare a re-resolution against a
|
||||||
|
/// reviewed plan must use this to avoid treating a "no comparable plan" result
|
||||||
|
/// as material drift.
|
||||||
pub fn resolves_effects(action: &SystemAction) -> bool {
|
pub fn resolves_effects(action: &SystemAction) -> bool {
|
||||||
pretend_args(action).is_some()
|
pretend_args(action).is_some()
|
||||||
|
|| matches!(
|
||||||
|
action,
|
||||||
|
SystemAction::Depclean
|
||||||
|
| SystemAction::ApplyUpdates { .. }
|
||||||
|
| SystemAction::CleanCache { .. }
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Resolve exactly what a package action will do. Non-Portage actions yield an
|
/// Resolve exactly what a package or maintenance action will do. A plan's
|
||||||
/// empty plan. A plan's digest can be bound to an approval.
|
/// digest is bound to the approval and re-checked immediately before execution.
|
||||||
pub fn resolve_effects(exec: &Exec, action: &SystemAction, root: &Path) -> Result<ResolvedPlan> {
|
pub fn resolve_effects(exec: &Exec, action: &SystemAction, root: &Path) -> Result<ResolvedPlan> {
|
||||||
action
|
action
|
||||||
.validate()
|
.validate()
|
||||||
.map_err(|e| ExecError::operation("sys", "validate action", e))?;
|
.map_err(|e| ExecError::operation("sys", "validate action", e))?;
|
||||||
|
|
||||||
// Destructive maintenance and Portage updates are previewed from a real
|
|
||||||
// `--pretend`, so approval binds to exactly what will happen. Other lanes
|
|
||||||
// resolve their effects in the install layer.
|
|
||||||
match action {
|
match action {
|
||||||
SystemAction::Depclean => {
|
SystemAction::Depclean => return resolve_depclean_effects(exec, root),
|
||||||
let spec = target_spec(
|
SystemAction::ApplyUpdates { backend } => {
|
||||||
root,
|
return resolve_update_effects(exec, root, *backend);
|
||||||
"sys",
|
|
||||||
"resolve depclean",
|
|
||||||
"emerge",
|
|
||||||
&["--pretend".into(), "--depclean".into(), "--color=n".into()],
|
|
||||||
);
|
|
||||||
let out = exec.run_capture(spec)?;
|
|
||||||
let mut plan = ResolvedPlan::default();
|
|
||||||
plan.established = true;
|
|
||||||
plan.consequences.push(format!(
|
|
||||||
"depclean would remove:\n{}",
|
|
||||||
out.stdout_lossy().trim()
|
|
||||||
));
|
|
||||||
plan.recompute_digest();
|
|
||||||
return Ok(plan);
|
|
||||||
}
|
}
|
||||||
SystemAction::ApplyUpdates { backend }
|
SystemAction::CleanCache { backend } => {
|
||||||
if backend.map(|b| b.is_portage()).unwrap_or(true) =>
|
return resolve_cleanup_effects(exec, root, *backend);
|
||||||
{
|
|
||||||
let spec = target_spec(
|
|
||||||
root,
|
|
||||||
"sys",
|
|
||||||
"resolve updates",
|
|
||||||
"emerge",
|
|
||||||
&[
|
|
||||||
"--pretend".into(),
|
|
||||||
"--update".into(),
|
|
||||||
"--deep".into(),
|
|
||||||
"--newuse".into(),
|
|
||||||
"--color=n".into(),
|
|
||||||
"--".into(),
|
|
||||||
"@world".into(),
|
|
||||||
],
|
|
||||||
);
|
|
||||||
let out = exec.run_capture(spec)?;
|
|
||||||
let mut plan = parse_emerge_pretend(&out.stdout_lossy());
|
|
||||||
if !plan.established {
|
|
||||||
return Err(ExecError::operation(
|
|
||||||
"sys",
|
|
||||||
"resolve updates",
|
|
||||||
"could not establish the update plan from emerge --pretend; \
|
|
||||||
refusing to proceed unreviewed",
|
|
||||||
));
|
|
||||||
}
|
|
||||||
if backend.is_none() {
|
|
||||||
plan.consequences.push(
|
|
||||||
"Flatpak/Snap/AppImage/Nix updates are applied per source and are not \
|
|
||||||
predicted in this Portage preview"
|
|
||||||
.into(),
|
|
||||||
);
|
|
||||||
}
|
|
||||||
plan.recompute_digest();
|
|
||||||
return Ok(plan);
|
|
||||||
}
|
}
|
||||||
_ => {}
|
_ => {}
|
||||||
}
|
}
|
||||||
|
|
@ -279,7 +238,7 @@ pub fn resolve_effects(exec: &Exec, action: &SystemAction, root: &Path) -> Resul
|
||||||
if plan
|
if plan
|
||||||
.effects
|
.effects
|
||||||
.iter()
|
.iter()
|
||||||
.any(|e| e.source == phoebus_core::effects::EffectSource::Source)
|
.any(|e| e.source == EffectSource::Source)
|
||||||
{
|
{
|
||||||
return Err(ExecError::operation(
|
return Err(ExecError::operation(
|
||||||
"sys",
|
"sys",
|
||||||
|
|
@ -296,6 +255,419 @@ pub fn resolve_effects(exec: &Exec, action: &SystemAction, root: &Path) -> Resul
|
||||||
Ok(plan)
|
Ok(plan)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Depclean removals are parsed into structured effects, not only prose, so a
|
||||||
|
/// changed removal set changes the approved digest and is caught before
|
||||||
|
/// execution.
|
||||||
|
fn resolve_depclean_effects(exec: &Exec, root: &Path) -> Result<ResolvedPlan> {
|
||||||
|
let spec = target_spec(
|
||||||
|
root,
|
||||||
|
"sys",
|
||||||
|
"resolve depclean",
|
||||||
|
"emerge",
|
||||||
|
&["--pretend".into(), "--depclean".into(), "--color=n".into()],
|
||||||
|
);
|
||||||
|
let out = exec.run_capture(spec)?;
|
||||||
|
let mut plan = parse_emerge_pretend(&out.stdout_lossy());
|
||||||
|
if !plan.established {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve depclean",
|
||||||
|
"could not establish the depclean selection from emerge --pretend; \
|
||||||
|
refusing to proceed unreviewed",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
if root.join(snapshot::SNAPSHOT_DIR).is_dir() {
|
||||||
|
plan.recovery_point = Some("a protective snapshot before the change".into());
|
||||||
|
}
|
||||||
|
plan.recompute_digest();
|
||||||
|
Ok(plan)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn update_limitation(backend: Backend) -> &'static str {
|
||||||
|
match backend {
|
||||||
|
Backend::Nix => {
|
||||||
|
"Nix packages are declarative/pinned; update them in their project or profile"
|
||||||
|
}
|
||||||
|
Backend::AppImage => {
|
||||||
|
"managed AppImages have no update repository; re-acquire with a pinned URL + SHA-256"
|
||||||
|
}
|
||||||
|
Backend::CustomEbuild => "rebuild the staged ebuild through Portage explicitly",
|
||||||
|
_ => "this source has no system-level update transaction",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The flatpak client must answer in the intended target.
|
||||||
|
fn flatpak_available(exec: &Exec, root: &Path) -> bool {
|
||||||
|
crate::query::flatpak_available(exec, root)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Exact per-application Flatpak update effects. Each affected application is
|
||||||
|
/// an identity plus its planned new version, so approval cannot authorize an
|
||||||
|
/// unrestricted update-all.
|
||||||
|
fn flatpak_update_effects(exec: &Exec, root: &Path) -> Result<Vec<PackageEffect>> {
|
||||||
|
if !flatpak_available(exec, root) {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve flatpak updates",
|
||||||
|
"the Flatpak client is not available in the target",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let updates = exec
|
||||||
|
.runner
|
||||||
|
.execute(&target_spec(
|
||||||
|
root,
|
||||||
|
"sys",
|
||||||
|
"resolve flatpak updates",
|
||||||
|
"flatpak",
|
||||||
|
&[
|
||||||
|
"remote-ls".into(),
|
||||||
|
"--updates".into(),
|
||||||
|
"--columns=application,version,branch".into(),
|
||||||
|
],
|
||||||
|
))
|
||||||
|
.map_err(|e| {
|
||||||
|
ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve flatpak updates",
|
||||||
|
format!("flatpak remote-ls could not run: {e}"),
|
||||||
|
)
|
||||||
|
})?;
|
||||||
|
if !updates.success {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve flatpak updates",
|
||||||
|
format!(
|
||||||
|
"flatpak remote-ls failed: {}",
|
||||||
|
updates.stderr_lossy().trim()
|
||||||
|
),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let mut current = std::collections::BTreeMap::new();
|
||||||
|
if let Ok(list) = exec.runner.execute(&target_spec(
|
||||||
|
root,
|
||||||
|
"sys",
|
||||||
|
"resolve flatpak updates",
|
||||||
|
"flatpak",
|
||||||
|
&[
|
||||||
|
"list".into(),
|
||||||
|
"--app".into(),
|
||||||
|
"--columns=application,version".into(),
|
||||||
|
],
|
||||||
|
)) {
|
||||||
|
if list.success {
|
||||||
|
for line in list.stdout_lossy().lines() {
|
||||||
|
let mut parts = line.split_whitespace();
|
||||||
|
if let (Some(id), Some(version)) = (parts.next(), parts.next()) {
|
||||||
|
current.insert(id.to_string(), version.to_string());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let mut effects = Vec::new();
|
||||||
|
for line in updates.stdout_lossy().lines() {
|
||||||
|
let mut parts = line.split_whitespace();
|
||||||
|
let (Some(id), Some(new_version)) = (parts.next(), parts.next()) else {
|
||||||
|
continue;
|
||||||
|
};
|
||||||
|
if id.is_empty() || new_version.is_empty() {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
effects.push(PackageEffect {
|
||||||
|
target: format!("{id}-{new_version}"),
|
||||||
|
previous: current.get(id).cloned(),
|
||||||
|
kind: EffectKind::Upgrade,
|
||||||
|
source: EffectSource::Binary,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
Ok(effects)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Exact per-snap update effects. Snaps act on the running daemon, so an
|
||||||
|
/// alternate root is refused before any command is issued.
|
||||||
|
fn snap_update_effects(exec: &Exec, root: &Path) -> Result<Vec<PackageEffect>> {
|
||||||
|
if !is_host_root(root) {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve snap updates",
|
||||||
|
"Snap acts on the running daemon and cannot be redirected to an alternate root; \
|
||||||
|
refusing to touch the host",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let status = snap::status(exec)?;
|
||||||
|
if !status.usable() {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve snap updates",
|
||||||
|
"snapd is not installed or active",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let updates = exec.runner.execute(
|
||||||
|
&CommandSpec::new("sys", "resolve snap updates", "snap").args(["refresh", "--list"]),
|
||||||
|
)?;
|
||||||
|
if !updates.success {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve snap updates",
|
||||||
|
format!(
|
||||||
|
"snap refresh --list failed: {}",
|
||||||
|
updates.stderr_lossy().trim()
|
||||||
|
),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let mut current = std::collections::BTreeMap::new();
|
||||||
|
if let Ok(entries) = snap::list(exec) {
|
||||||
|
for entry in entries {
|
||||||
|
current.insert(entry.name, entry.version);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let mut effects = Vec::new();
|
||||||
|
for line in updates.stdout_lossy().lines().skip(1) {
|
||||||
|
let mut parts = line.split_whitespace();
|
||||||
|
let (Some(name), Some(new_version)) = (parts.next(), parts.next()) else {
|
||||||
|
continue;
|
||||||
|
};
|
||||||
|
if name.is_empty() || new_version.is_empty() {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
effects.push(PackageEffect {
|
||||||
|
target: format!("{name}-{new_version}"),
|
||||||
|
previous: current.get(name).cloned(),
|
||||||
|
kind: EffectKind::Upgrade,
|
||||||
|
source: EffectSource::Binary,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
Ok(effects)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Resolve a reviewable, per-source update plan. Each lane contributes exact
|
||||||
|
/// affected identities (and versions where the backend reports them). A lane
|
||||||
|
/// that cannot be updated deterministically is refused when explicitly
|
||||||
|
/// requested, never silently skipped.
|
||||||
|
fn resolve_update_effects(
|
||||||
|
exec: &Exec,
|
||||||
|
root: &Path,
|
||||||
|
backend: Option<Backend>,
|
||||||
|
) -> Result<ResolvedPlan> {
|
||||||
|
let lanes: Vec<Backend> = match backend {
|
||||||
|
Some(backend) => vec![backend],
|
||||||
|
None => vec![Backend::PortageSource, Backend::Flatpak, Backend::Snap],
|
||||||
|
};
|
||||||
|
let mut plan = ResolvedPlan {
|
||||||
|
established: true,
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
for lane in lanes {
|
||||||
|
if lane.is_portage() {
|
||||||
|
let spec = target_spec(
|
||||||
|
root,
|
||||||
|
"sys",
|
||||||
|
"resolve updates",
|
||||||
|
"emerge",
|
||||||
|
&[
|
||||||
|
"--pretend".into(),
|
||||||
|
"--update".into(),
|
||||||
|
"--deep".into(),
|
||||||
|
"--newuse".into(),
|
||||||
|
"--color=n".into(),
|
||||||
|
"--".into(),
|
||||||
|
"@world".into(),
|
||||||
|
],
|
||||||
|
);
|
||||||
|
let out = exec.run_capture(spec)?;
|
||||||
|
let parsed = parse_emerge_pretend(&out.stdout_lossy());
|
||||||
|
if !parsed.established {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve updates",
|
||||||
|
"could not establish the update plan from emerge --pretend; \
|
||||||
|
refusing to proceed unreviewed",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
plan.effects.extend(parsed.effects);
|
||||||
|
if let Some(bytes) = parsed.download_bytes {
|
||||||
|
*plan.download_bytes.get_or_insert(0) += bytes;
|
||||||
|
}
|
||||||
|
plan.consequences.extend(parsed.consequences);
|
||||||
|
} else if lane == Backend::Flatpak {
|
||||||
|
match flatpak_update_effects(exec, root) {
|
||||||
|
Ok(effects) => plan.effects.extend(effects),
|
||||||
|
Err(e) if backend.is_none() => plan
|
||||||
|
.consequences
|
||||||
|
.push(format!("[flatpak] updates could not be resolved: {e}")),
|
||||||
|
Err(e) => return Err(e),
|
||||||
|
}
|
||||||
|
} else if lane == Backend::Snap {
|
||||||
|
match snap_update_effects(exec, root) {
|
||||||
|
Ok(effects) => plan.effects.extend(effects),
|
||||||
|
Err(e) if backend.is_none() => plan
|
||||||
|
.consequences
|
||||||
|
.push(format!("[snap] updates could not be resolved: {e}")),
|
||||||
|
Err(e) => return Err(e),
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// Not in the default set; only reachable when explicitly requested.
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve updates",
|
||||||
|
format!(
|
||||||
|
"{} updates cannot be applied safely by `sys`: {}",
|
||||||
|
lane.as_str(),
|
||||||
|
update_limitation(lane)
|
||||||
|
),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if backend.is_none() {
|
||||||
|
plan.consequences.push(
|
||||||
|
"Nix, managed AppImages and custom ebuilds are project- or format-specific and are \
|
||||||
|
not part of this update transaction"
|
||||||
|
.into(),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
if plan.effects.is_empty() {
|
||||||
|
plan.consequences.push("no updates are available".into());
|
||||||
|
}
|
||||||
|
if root.join(snapshot::SNAPSHOT_DIR).is_dir() {
|
||||||
|
plan.recovery_point = Some("a protective snapshot before the change".into());
|
||||||
|
}
|
||||||
|
plan.recompute_digest();
|
||||||
|
Ok(plan)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The cache cleaners for a lane, as `(cleaner, dry-run args, destructive args)`.
|
||||||
|
pub(crate) fn portage_cleaners(root: &Path) -> Vec<(&'static str, Vec<String>, Vec<String>)> {
|
||||||
|
let mut cleaners = Vec::new();
|
||||||
|
if crate::exec::tool_in_target(root, "eclean-dist") {
|
||||||
|
cleaners.push(("eclean-dist", vec![], vec!["-d".to_string()]));
|
||||||
|
}
|
||||||
|
if crate::exec::tool_in_target(root, "eclean-pkg") {
|
||||||
|
cleaners.push(("eclean-pkg", vec![], vec!["-d".to_string()]));
|
||||||
|
}
|
||||||
|
cleaners
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Resolve a reviewable cache-cleanup plan from non-destructive dry runs. A
|
||||||
|
/// cleaner that cannot run is recorded as unavailable, distinct from one that
|
||||||
|
/// ran and found nothing.
|
||||||
|
fn resolve_cleanup_effects(
|
||||||
|
exec: &Exec,
|
||||||
|
root: &Path,
|
||||||
|
backend: Option<Backend>,
|
||||||
|
) -> Result<ResolvedPlan> {
|
||||||
|
let lanes: Vec<Backend> = match backend {
|
||||||
|
Some(backend) => vec![backend],
|
||||||
|
None => vec![Backend::PortageSource, Backend::Nix],
|
||||||
|
};
|
||||||
|
let mut plan = ResolvedPlan {
|
||||||
|
established: true,
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
for lane in lanes {
|
||||||
|
if lane.is_portage() {
|
||||||
|
for (cleaner, dry_args, _) in portage_cleaners(root) {
|
||||||
|
let out = exec.runner.execute(&target_spec(
|
||||||
|
root,
|
||||||
|
"sys",
|
||||||
|
"resolve cache cleanup",
|
||||||
|
cleaner,
|
||||||
|
&dry_args,
|
||||||
|
));
|
||||||
|
match out {
|
||||||
|
Ok(output) if output.success => {
|
||||||
|
let items = output
|
||||||
|
.stdout_lossy()
|
||||||
|
.lines()
|
||||||
|
.map(str::trim)
|
||||||
|
.filter(|l| !l.is_empty())
|
||||||
|
.map(str::to_string)
|
||||||
|
.collect();
|
||||||
|
plan.cleanup.push(CleanupEffect {
|
||||||
|
cleaner: cleaner.to_string(),
|
||||||
|
items,
|
||||||
|
unavailable: false,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
Ok(output) => {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve cache cleanup",
|
||||||
|
format!("{cleaner} dry run failed: {}", output.stderr_lossy().trim()),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
Err(e) => {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve cache cleanup",
|
||||||
|
format!("{cleaner} dry run could not run: {e}"),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else if lane == Backend::Nix {
|
||||||
|
if !crate::nix::installed(root) {
|
||||||
|
plan.cleanup.push(CleanupEffect {
|
||||||
|
cleaner: "nix-store --gc".into(),
|
||||||
|
items: Vec::new(),
|
||||||
|
unavailable: true,
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
let out = exec.runner.execute(&target_spec(
|
||||||
|
root,
|
||||||
|
"sys",
|
||||||
|
"resolve cache cleanup",
|
||||||
|
"/nix/var/nix/profiles/default/bin/nix-store",
|
||||||
|
&["--gc".into(), "--dry-run".into()],
|
||||||
|
));
|
||||||
|
match out {
|
||||||
|
Ok(output) if output.success => {
|
||||||
|
let items = output
|
||||||
|
.stdout_lossy()
|
||||||
|
.lines()
|
||||||
|
.map(str::trim)
|
||||||
|
.filter(|l| !l.is_empty())
|
||||||
|
.map(str::to_string)
|
||||||
|
.collect();
|
||||||
|
plan.cleanup.push(CleanupEffect {
|
||||||
|
cleaner: "nix-store --gc".into(),
|
||||||
|
items,
|
||||||
|
unavailable: false,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
Ok(output) => {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve cache cleanup",
|
||||||
|
format!("nix-store --gc failed: {}", output.stderr_lossy().trim()),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
Err(e) => {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve cache cleanup",
|
||||||
|
format!("nix-store --gc could not run: {e}"),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"resolve cache cleanup",
|
||||||
|
format!(
|
||||||
|
"the {} lane has no package cache to clean; refusing",
|
||||||
|
lane.as_str()
|
||||||
|
),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if plan.cleanup.is_empty() {
|
||||||
|
plan.consequences
|
||||||
|
.push("no cache cleaner is available in the target".into());
|
||||||
|
}
|
||||||
|
plan.recompute_digest();
|
||||||
|
Ok(plan)
|
||||||
|
}
|
||||||
|
|
||||||
/// Execute an action after re-resolving it against the approved digest. If the
|
/// Execute an action after re-resolving it against the approved digest. If the
|
||||||
/// plan changed materially since review, execution is refused.
|
/// plan changed materially since review, execution is refused.
|
||||||
pub fn execute_checked(
|
pub fn execute_checked(
|
||||||
|
|
@ -1475,15 +1847,17 @@ Total: 1 package (1 new), Size of downloads: 512 KiB
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn depclean_is_previewed_from_pretend_at_review() {
|
fn depclean_is_previewed_as_structured_removals_at_review() {
|
||||||
let runner = RecordingRunner::new();
|
let runner = RecordingRunner::new();
|
||||||
runner.set_response(
|
runner.set_response(
|
||||||
"emerge",
|
"emerge",
|
||||||
CommandOutput {
|
CommandOutput {
|
||||||
status: 0,
|
status: 0,
|
||||||
success: true,
|
success: true,
|
||||||
stdout: b">>> These are the packages that would be unmerged:\n\
|
stdout: b">>> These are the packages that would be unmerged:\n\n \
|
||||||
app-misc/unused-1.0\n\n0 packages selected\n"
|
app-misc/unused\n selected: 1.0\n\n\
|
||||||
|
All selected packages: app-misc/unused-1.0\n\n\
|
||||||
|
>>> 'Selected' packages are slated for removal.\n"
|
||||||
.to_vec(),
|
.to_vec(),
|
||||||
stderr: Vec::new(),
|
stderr: Vec::new(),
|
||||||
duration: std::time::Duration::from_millis(1),
|
duration: std::time::Duration::from_millis(1),
|
||||||
|
|
@ -1492,11 +1866,98 @@ Total: 1 package (1 new), Size of downloads: 512 KiB
|
||||||
let exec = make_exec(runner);
|
let exec = make_exec(runner);
|
||||||
let plan = resolve_effects(&exec, &SystemAction::Depclean, Path::new("/")).unwrap();
|
let plan = resolve_effects(&exec, &SystemAction::Depclean, Path::new("/")).unwrap();
|
||||||
assert!(plan.established);
|
assert!(plan.established);
|
||||||
|
// Removals are structured effects, so changing them changes the digest
|
||||||
|
// and is caught before execution.
|
||||||
|
assert_eq!(plan.removals(), 1);
|
||||||
|
assert_eq!(plan.effects[0].target, "app-misc/unused-1.0");
|
||||||
assert!(plan
|
assert!(plan
|
||||||
.consequences
|
.consequences
|
||||||
.iter()
|
.iter()
|
||||||
.any(|c| c.contains("depclean would remove")));
|
.any(|c| c.contains("will be removed")));
|
||||||
assert!(plan.render().contains("depclean would remove"));
|
assert!(plan.render().contains("app-misc/unused-1.0"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn depclean_effect_digest_detects_a_changed_removal_set() {
|
||||||
|
let runner = RecordingRunner::new();
|
||||||
|
runner.set_response(
|
||||||
|
"emerge",
|
||||||
|
CommandOutput {
|
||||||
|
status: 0,
|
||||||
|
success: true,
|
||||||
|
stdout: b"All selected packages: app-misc/unused-1.0\n".to_vec(),
|
||||||
|
stderr: Vec::new(),
|
||||||
|
duration: std::time::Duration::from_millis(1),
|
||||||
|
},
|
||||||
|
);
|
||||||
|
let exec = make_exec(runner.clone());
|
||||||
|
let approved = resolve_effects(&exec, &SystemAction::Depclean, Path::new("/")).unwrap();
|
||||||
|
// The next preview selects a different package entirely.
|
||||||
|
runner.set_response(
|
||||||
|
"emerge",
|
||||||
|
CommandOutput {
|
||||||
|
status: 0,
|
||||||
|
success: true,
|
||||||
|
stdout: b"All selected packages: app-misc/other-2.0\n".to_vec(),
|
||||||
|
stderr: Vec::new(),
|
||||||
|
duration: std::time::Duration::from_millis(1),
|
||||||
|
},
|
||||||
|
);
|
||||||
|
let current = resolve_effects(&exec, &SystemAction::Depclean, Path::new("/")).unwrap();
|
||||||
|
assert_ne!(approved.digest, current.digest);
|
||||||
|
assert!(phoebus_core::effects::changed_materially(
|
||||||
|
&approved, ¤t
|
||||||
|
));
|
||||||
|
assert!(!phoebus_core::effects::approval_holds(
|
||||||
|
&approved,
|
||||||
|
¤t,
|
||||||
|
&[]
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn maintenance_actions_have_comparable_effects() {
|
||||||
|
assert!(resolves_effects(&SystemAction::Depclean));
|
||||||
|
assert!(resolves_effects(&SystemAction::ApplyUpdates {
|
||||||
|
backend: None
|
||||||
|
}));
|
||||||
|
assert!(resolves_effects(&SystemAction::ApplyUpdates {
|
||||||
|
backend: Some(phoebus_core::selection::Backend::Flatpak),
|
||||||
|
}));
|
||||||
|
assert!(resolves_effects(&SystemAction::CleanCache {
|
||||||
|
backend: None
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn execute_checked_refuses_depclean_drift_before_any_mutation() {
|
||||||
|
let approved_runner = RecordingRunner::new();
|
||||||
|
approved_runner.set_response(
|
||||||
|
"emerge",
|
||||||
|
response("All selected packages: app-misc/old-1.0\n"),
|
||||||
|
);
|
||||||
|
let approved_exec = make_exec(approved_runner);
|
||||||
|
let approved =
|
||||||
|
resolve_effects(&approved_exec, &SystemAction::Depclean, Path::new("/")).unwrap();
|
||||||
|
|
||||||
|
let runner = RecordingRunner::new();
|
||||||
|
runner.set_response(
|
||||||
|
"emerge",
|
||||||
|
response("All selected packages: app-misc/new-2.0\n"),
|
||||||
|
);
|
||||||
|
let exec = make_exec(runner.clone());
|
||||||
|
let auth = auth();
|
||||||
|
let err = execute_checked(
|
||||||
|
&exec,
|
||||||
|
&SystemAction::Depclean,
|
||||||
|
Some(&auth),
|
||||||
|
Path::new("/"),
|
||||||
|
Some(&approved),
|
||||||
|
)
|
||||||
|
.unwrap_err();
|
||||||
|
assert!(err.to_string().contains("plan changed"), "{err}");
|
||||||
|
// Only the re-resolution preview ran; the destructive depclean did not.
|
||||||
|
assert_eq!(runner.recorded().len(), 1, "{:?}", runner.recorded());
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
|
|
||||||
|
|
@ -109,6 +109,18 @@ pub fn save_preferences(exec: &Exec, root: &Path, prefs: &Preferences) -> Result
|
||||||
save_system_preferences(exec, root, prefs)
|
save_system_preferences(exec, root, prefs)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Build a command rooted at the intended target: directly for the running
|
||||||
|
/// root, or inside the target chroot for an alternate root.
|
||||||
|
fn rooted(root: &Path, stage: &str, operation: &str, program: &str, args: &[&str]) -> CommandSpec {
|
||||||
|
let owned: Vec<String> = args.iter().map(|s| s.to_string()).collect();
|
||||||
|
crate::actions::target_spec(root, stage, operation, program, &owned)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Snap acts on the running daemon and cannot be redirected to a target.
|
||||||
|
fn snap_on_host(root: &Path) -> bool {
|
||||||
|
root == Path::new("/")
|
||||||
|
}
|
||||||
|
|
||||||
/// Read free storage for the filesystem containing `root` using `df -Pk`.
|
/// Read free storage for the filesystem containing `root` using `df -Pk`.
|
||||||
fn free_mib(exec: &Exec, root: &Path) -> u64 {
|
fn free_mib(exec: &Exec, root: &Path) -> u64 {
|
||||||
let path = if root.exists() {
|
let path = if root.exists() {
|
||||||
|
|
@ -166,13 +178,10 @@ pub fn hardware_facts(exec: &Exec, root: &Path) -> HardwareFacts {
|
||||||
if crate::nix::installed(root) {
|
if crate::nix::installed(root) {
|
||||||
available_backends.insert(Backend::Nix);
|
available_backends.insert(Backend::Nix);
|
||||||
}
|
}
|
||||||
if crate::exec::find_in_path("flatpak").is_some() {
|
if crate::exec::tool_in_target(root, "flatpak") {
|
||||||
available_backends.insert(Backend::Flatpak);
|
available_backends.insert(Backend::Flatpak);
|
||||||
}
|
}
|
||||||
if matches!(
|
if snap_on_host(root) && matches!(crate::snap::status(exec), Ok(status) if status.usable()) {
|
||||||
crate::snap::status(exec),
|
|
||||||
Ok(status) if status.usable()
|
|
||||||
) {
|
|
||||||
available_backends.insert(Backend::Snap);
|
available_backends.insert(Backend::Snap);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -283,11 +292,13 @@ pub fn resolve_candidates(exec: &Exec, root: &Path, need: &Need) -> Vec<Candidat
|
||||||
let name = &need.name;
|
let name = &need.name;
|
||||||
|
|
||||||
// --- Portage ------------------------------------------------------
|
// --- Portage ------------------------------------------------------
|
||||||
let pretend = exec.runner.execute(
|
let pretend = exec.runner.execute(&rooted(
|
||||||
&CommandSpec::new("sys", "resolve Portage candidate", "emerge")
|
root,
|
||||||
.args(["--pretend", "--quiet", "--color=n", "--"])
|
"sys",
|
||||||
.arg(name),
|
"resolve Portage candidate",
|
||||||
);
|
"emerge",
|
||||||
|
&["--pretend", "--quiet", "--color=n", "--", name.as_str()],
|
||||||
|
));
|
||||||
match pretend {
|
match pretend {
|
||||||
Ok(resolved) if resolved.success => {
|
Ok(resolved) if resolved.success => {
|
||||||
let text = resolved.stdout_lossy();
|
let text = resolved.stdout_lossy();
|
||||||
|
|
@ -296,11 +307,20 @@ pub fn resolve_candidates(exec: &Exec, root: &Path, need: &Need) -> Vec<Candidat
|
||||||
.unwrap_or_else(|| (name.clone(), None));
|
.unwrap_or_else(|| (name.clone(), None));
|
||||||
out.push(portage_candidate(&atom, false, version.as_deref(), &facts));
|
out.push(portage_candidate(&atom, false, version.as_deref(), &facts));
|
||||||
if facts.binhost_available {
|
if facts.binhost_available {
|
||||||
let bin_check = exec.runner.execute(
|
let bin_check = exec.runner.execute(&rooted(
|
||||||
&CommandSpec::new("sys", "check Portage binpkg", "emerge")
|
root,
|
||||||
.args(["--pretend", "--quiet", "--color=n", "--usepkgonly", "--"])
|
"sys",
|
||||||
.arg(name),
|
"check Portage binpkg",
|
||||||
);
|
"emerge",
|
||||||
|
&[
|
||||||
|
"--pretend",
|
||||||
|
"--quiet",
|
||||||
|
"--color=n",
|
||||||
|
"--usepkgonly",
|
||||||
|
"--",
|
||||||
|
name.as_str(),
|
||||||
|
],
|
||||||
|
));
|
||||||
let bin_available = match bin_check {
|
let bin_available = match bin_check {
|
||||||
Ok(res) if res.success => {
|
Ok(res) if res.success => {
|
||||||
let out = res.stdout_lossy();
|
let out = res.stdout_lossy();
|
||||||
|
|
@ -351,7 +371,7 @@ pub fn resolve_candidates(exec: &Exec, root: &Path, need: &Need) -> Vec<Candidat
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- Flatpak ------------------------------------------------------
|
// --- Flatpak ------------------------------------------------------
|
||||||
if crate::exec::find_in_path("flatpak").is_some() {
|
if crate::exec::tool_in_target(root, "flatpak") {
|
||||||
let mut c = Candidate::new(Backend::Flatpak, name, "flathub");
|
let mut c = Candidate::new(Backend::Flatpak, name, "flathub");
|
||||||
c.sandbox = SandboxLevel::Strong;
|
c.sandbox = SandboxLevel::Strong;
|
||||||
c.update_reliability = UpdateReliability::Automatic;
|
c.update_reliability = UpdateReliability::Automatic;
|
||||||
|
|
@ -363,14 +383,13 @@ pub fn resolve_candidates(exec: &Exec, root: &Path, need: &Need) -> Vec<Candidat
|
||||||
.push("not a reverse-DNS Flatpak application id".into());
|
.push("not a reverse-DNS Flatpak application id".into());
|
||||||
} else {
|
} else {
|
||||||
// Confirm the id actually exists in the configured remotes.
|
// Confirm the id actually exists in the configured remotes.
|
||||||
let found = exec.runner.execute(
|
let found = exec.runner.execute(&rooted(
|
||||||
&CommandSpec::new("sys", "resolve Flatpak candidate", "flatpak").args([
|
root,
|
||||||
"search",
|
"sys",
|
||||||
"--columns=application",
|
"resolve Flatpak candidate",
|
||||||
"--",
|
"flatpak",
|
||||||
name,
|
&["search", "--columns=application", "--", name.as_str()],
|
||||||
]),
|
));
|
||||||
);
|
|
||||||
match found {
|
match found {
|
||||||
Ok(o) if o.success && o.stdout_lossy().contains(name) => {
|
Ok(o) if o.success && o.stdout_lossy().contains(name) => {
|
||||||
c.verified = true;
|
c.verified = true;
|
||||||
|
|
@ -387,7 +406,7 @@ pub fn resolve_candidates(exec: &Exec, root: &Path, need: &Need) -> Vec<Candidat
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- Snap ---------------------------------------------------------
|
// --- Snap ---------------------------------------------------------
|
||||||
if matches!(crate::snap::status(exec), Ok(s) if s.usable()) {
|
if snap_on_host(root) && matches!(crate::snap::status(exec), Ok(s) if s.usable()) {
|
||||||
let mut c = Candidate::new(Backend::Snap, name, "Snap Store");
|
let mut c = Candidate::new(Backend::Snap, name, "Snap Store");
|
||||||
c.sandbox = SandboxLevel::Strong;
|
c.sandbox = SandboxLevel::Strong;
|
||||||
c.update_reliability = UpdateReliability::Automatic;
|
c.update_reliability = UpdateReliability::Automatic;
|
||||||
|
|
@ -463,26 +482,28 @@ pub fn installed_backend(exec: &Exec, root: &Path, name: &str) -> Option<Backend
|
||||||
if crate::appimage::info(root, name).is_ok() {
|
if crate::appimage::info(root, name).is_ok() {
|
||||||
return Some(Backend::AppImage);
|
return Some(Backend::AppImage);
|
||||||
}
|
}
|
||||||
// Flatpak: parse the installed list.
|
// Flatpak: parse the installed list in the intended target.
|
||||||
if crate::exec::find_in_path("flatpak").is_some() {
|
if crate::exec::tool_in_target(root, "flatpak") {
|
||||||
if let Ok(out) = exec.runner.execute(
|
if let Ok(out) = exec.runner.execute(&rooted(
|
||||||
&CommandSpec::new("sys", "detect installed flatpak", "flatpak").args([
|
root,
|
||||||
"list",
|
"sys",
|
||||||
"--app",
|
"detect installed flatpak",
|
||||||
"--columns=application",
|
"flatpak",
|
||||||
]),
|
&["list", "--app", "--columns=application"],
|
||||||
) {
|
)) {
|
||||||
if out.success && out.stdout_lossy().lines().any(|l| l.trim() == name) {
|
if out.success && out.stdout_lossy().lines().any(|l| l.trim() == name) {
|
||||||
return Some(Backend::Flatpak);
|
return Some(Backend::Flatpak);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// Snap: parse the installed list.
|
// Snap: parse the installed list (host only; snap has no target scope).
|
||||||
|
if snap_on_host(root) {
|
||||||
if let Ok(entries) = crate::snap::list(exec) {
|
if let Ok(entries) = crate::snap::list(exec) {
|
||||||
if entries.iter().any(|e| e.name == name) {
|
if entries.iter().any(|e| e.name == name) {
|
||||||
return Some(Backend::Snap);
|
return Some(Backend::Snap);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
// Portage: a VDB entry for the package (bare name or full atom).
|
// Portage: a VDB entry for the package (bare name or full atom).
|
||||||
if portage_installed(root, name) {
|
if portage_installed(root, name) {
|
||||||
return Some(Backend::PortageSource);
|
return Some(Backend::PortageSource);
|
||||||
|
|
@ -596,19 +617,47 @@ pub fn candidate_detail(exec: &Exec, root: &Path, backend: Backend, id: &str) ->
|
||||||
|
|
||||||
match backend {
|
match backend {
|
||||||
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => {
|
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => {
|
||||||
if let Ok(out) = exec.runner.execute(
|
// Declared dependencies come from authoritative metadata: the VDB
|
||||||
&CommandSpec::new("sys", "inspect candidate dependencies", "emerge")
|
// when installed, otherwise `qdepends` (portage-utils). An
|
||||||
.args(["--pretend", "--quiet", "--color=n", "--"])
|
// `emerge --pretend` merge plan is deliberately not used, because it
|
||||||
.arg(id),
|
// describes pending merges rather than the dependency graph.
|
||||||
) {
|
if let Some(record) = crate::portage::installed_packages(root)
|
||||||
|
.into_iter()
|
||||||
|
.find(|p| p.atom == id || p.atom.ends_with(&format!("/{id}")))
|
||||||
|
{
|
||||||
|
for text in [&record.depend, &record.rdepend, &record.bdepend]
|
||||||
|
.into_iter()
|
||||||
|
.flatten()
|
||||||
|
{
|
||||||
|
dependencies.extend(
|
||||||
|
crate::portage::parse_dependencies(text)
|
||||||
|
.into_iter()
|
||||||
|
.map(|d| d.raw),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
dependencies.sort();
|
||||||
|
dependencies.dedup();
|
||||||
|
} else if crate::exec::tool_in_target(root, "qdepends") {
|
||||||
|
if let Ok(out) = exec.runner.execute(&rooted(
|
||||||
|
root,
|
||||||
|
"sys",
|
||||||
|
"inspect candidate dependencies",
|
||||||
|
"qdepends",
|
||||||
|
&["-Q", "--", id],
|
||||||
|
)) {
|
||||||
if out.success {
|
if out.success {
|
||||||
let plan = phoebus_core::effects::parse_emerge_pretend(&out.stdout_lossy());
|
dependencies = crate::portage::parse_dependencies(&out.stdout_lossy())
|
||||||
dependencies = plan.effects.into_iter().map(|e| e.target).collect();
|
.into_iter()
|
||||||
|
.map(|d| d.raw)
|
||||||
|
.collect();
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Backend::Snap => {
|
Backend::Snap => {
|
||||||
if let Ok(out) = exec.runner.execute(
|
if !snap_on_host(root) {
|
||||||
|
// Snap has no alternate-root scope.
|
||||||
|
} else if let Ok(out) = exec.runner.execute(
|
||||||
&CommandSpec::new("sys", "inspect snap candidate", "snap").args([
|
&CommandSpec::new("sys", "inspect snap candidate", "snap").args([
|
||||||
"info",
|
"info",
|
||||||
id,
|
id,
|
||||||
|
|
@ -687,15 +736,14 @@ pub fn resolve_for_backend(
|
||||||
|
|
||||||
match backend {
|
match backend {
|
||||||
Backend::Flatpak => {
|
Backend::Flatpak => {
|
||||||
if crate::exec::find_in_path("flatpak").is_some() {
|
if crate::exec::tool_in_target(root, "flatpak") {
|
||||||
if let Ok(out) = exec.runner.execute(
|
if let Ok(out) = exec.runner.execute(&rooted(
|
||||||
&CommandSpec::new("sys", "resolve flatpak name", "flatpak").args([
|
root,
|
||||||
"search",
|
"sys",
|
||||||
"--columns=application,version",
|
"resolve flatpak name",
|
||||||
"--",
|
"flatpak",
|
||||||
application,
|
&["search", "--columns=application,version", "--", application],
|
||||||
]),
|
)) {
|
||||||
) {
|
|
||||||
if out.success {
|
if out.success {
|
||||||
let mut matches: Vec<(String, String)> = Vec::new();
|
let mut matches: Vec<(String, String)> = Vec::new();
|
||||||
for line in out.stdout_lossy().lines() {
|
for line in out.stdout_lossy().lines() {
|
||||||
|
|
@ -738,7 +786,7 @@ pub fn resolve_for_backend(
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Backend::Snap => {
|
Backend::Snap => {
|
||||||
if matches!(crate::snap::status(exec), Ok(s) if s.usable()) {
|
if snap_on_host(root) && matches!(crate::snap::status(exec), Ok(s) if s.usable()) {
|
||||||
if let Ok(out) = exec.runner.execute(
|
if let Ok(out) = exec.runner.execute(
|
||||||
&CommandSpec::new("sys", "resolve snap name", "snap").args([
|
&CommandSpec::new("sys", "resolve snap name", "snap").args([
|
||||||
"find",
|
"find",
|
||||||
|
|
@ -771,21 +819,32 @@ pub fn resolve_for_backend(
|
||||||
}
|
}
|
||||||
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => {
|
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => {
|
||||||
// Portage resolves bare names itself; confirm the atom is real.
|
// Portage resolves bare names itself; confirm the atom is real.
|
||||||
if let Ok(out) = exec.runner.execute(
|
if let Ok(out) = exec.runner.execute(&rooted(
|
||||||
&CommandSpec::new("sys", "resolve portage name", "emerge")
|
root,
|
||||||
.args(["--pretend", "--quiet", "--color=n", "--"])
|
"sys",
|
||||||
.arg(application),
|
"resolve portage name",
|
||||||
) {
|
"emerge",
|
||||||
|
&["--pretend", "--quiet", "--color=n", "--", application],
|
||||||
|
)) {
|
||||||
if out.success {
|
if out.success {
|
||||||
let (atom, version) = parse_pretend_version(&out.stdout_lossy())
|
let (atom, version) = parse_pretend_version(&out.stdout_lossy())
|
||||||
.map(|v| split_atom_version(&v))
|
.map(|v| split_atom_version(&v))
|
||||||
.unwrap_or_else(|| (application.to_string(), None));
|
.unwrap_or_else(|| (application.to_string(), None));
|
||||||
if backend == Backend::PortageBinary {
|
if backend == Backend::PortageBinary {
|
||||||
let bin_check = exec.runner.execute(
|
let bin_check = exec.runner.execute(&rooted(
|
||||||
&CommandSpec::new("sys", "check Portage binpkg", "emerge")
|
root,
|
||||||
.args(["--pretend", "--quiet", "--color=n", "--usepkgonly", "--"])
|
"sys",
|
||||||
.arg(application),
|
"check Portage binpkg",
|
||||||
);
|
"emerge",
|
||||||
|
&[
|
||||||
|
"--pretend",
|
||||||
|
"--quiet",
|
||||||
|
"--color=n",
|
||||||
|
"--usepkgonly",
|
||||||
|
"--",
|
||||||
|
application,
|
||||||
|
],
|
||||||
|
));
|
||||||
let bin_available = match bin_check {
|
let bin_available = match bin_check {
|
||||||
Ok(res) if res.success => {
|
Ok(res) if res.success => {
|
||||||
let out = res.stdout_lossy();
|
let out = res.stdout_lossy();
|
||||||
|
|
@ -887,10 +946,10 @@ pub fn backend_status(exec: &Exec, root: &Path, backend: Backend) -> BackendStat
|
||||||
let available = facts.backend_available(backend);
|
let available = facts.backend_available(backend);
|
||||||
let detail = match backend {
|
let detail = match backend {
|
||||||
Backend::PortageSource | Backend::PortageVendor => {
|
Backend::PortageSource | Backend::PortageVendor => {
|
||||||
if crate::exec::find_in_path("emerge").is_some() {
|
if crate::exec::tool_in_target(root, "emerge") {
|
||||||
"Portage (emerge) is present".into()
|
"Portage (emerge) is present".into()
|
||||||
} else {
|
} else {
|
||||||
"emerge is not in PATH".into()
|
"emerge is not available in the target".into()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Backend::PortageBinary => {
|
Backend::PortageBinary => {
|
||||||
|
|
@ -908,13 +967,17 @@ pub fn backend_status(exec: &Exec, root: &Path, backend: Backend) -> BackendStat
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Backend::Flatpak => {
|
Backend::Flatpak => {
|
||||||
if crate::exec::find_in_path("flatpak").is_some() {
|
if crate::exec::tool_in_target(root, "flatpak") {
|
||||||
"the flatpak client is present".into()
|
"the flatpak client is present in the target".into()
|
||||||
} else {
|
} else {
|
||||||
"flatpak is not installed".into()
|
"flatpak is not available in the target".into()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Backend::Snap => match crate::snap::status(exec) {
|
Backend::Snap => {
|
||||||
|
if !snap_on_host(root) {
|
||||||
|
"Snap cannot be inspected for an alternate root".into()
|
||||||
|
} else {
|
||||||
|
match crate::snap::status(exec) {
|
||||||
Ok(s) => format!(
|
Ok(s) => format!(
|
||||||
"snap client present: {}, daemon active: {}, confinement: {}",
|
"snap client present: {}, daemon active: {}, confinement: {}",
|
||||||
s.client_present,
|
s.client_present,
|
||||||
|
|
@ -922,7 +985,9 @@ pub fn backend_status(exec: &Exec, root: &Path, backend: Backend) -> BackendStat
|
||||||
s.confinement.as_str()
|
s.confinement.as_str()
|
||||||
),
|
),
|
||||||
Err(_) => "snapd state could not be determined".into(),
|
Err(_) => "snapd state could not be determined".into(),
|
||||||
},
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Backend::AppImage => "AppImages can be imported or downloaded locally".into(),
|
Backend::AppImage => "AppImages can be imported or downloaded locally".into(),
|
||||||
Backend::CustomEbuild => {
|
Backend::CustomEbuild => {
|
||||||
if crate::ebuild::list(root).is_empty() {
|
if crate::ebuild::list(root).is_empty() {
|
||||||
|
|
@ -939,20 +1004,39 @@ pub fn backend_status(exec: &Exec, root: &Path, backend: Backend) -> BackendStat
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Whether a lane is covered by an optional source filter.
|
||||||
|
fn lane_selected(filter: Option<Backend>, lane: Backend) -> bool {
|
||||||
|
match filter {
|
||||||
|
Some(f) => f == lane || (f.is_portage() && lane.is_portage()),
|
||||||
|
None => true,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// Inspect what is already installed for an application across lanes. Never
|
/// Inspect what is already installed for an application across lanes. Never
|
||||||
/// invents a copy; every entry comes from a real backend inventory.
|
/// invents a copy; every entry comes from a real backend inventory.
|
||||||
pub fn installed_copies(exec: &Exec, root: &Path, application: &str) -> InstallationInspection {
|
pub fn installed_copies(exec: &Exec, root: &Path, application: &str) -> InstallationInspection {
|
||||||
|
installed_copies_filtered(exec, root, application, None)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Like [`installed_copies`], but an explicit lane filter skips querying every
|
||||||
|
/// other backend, so a source-constrained request never probes a foreign lane.
|
||||||
|
pub fn installed_copies_filtered(
|
||||||
|
exec: &Exec,
|
||||||
|
root: &Path,
|
||||||
|
application: &str,
|
||||||
|
filter: Option<Backend>,
|
||||||
|
) -> InstallationInspection {
|
||||||
let mut copies = Vec::new();
|
let mut copies = Vec::new();
|
||||||
|
|
||||||
// Flatpak.
|
// Flatpak (in the intended target).
|
||||||
if crate::exec::find_in_path("flatpak").is_some() {
|
if lane_selected(filter, Backend::Flatpak) && crate::exec::tool_in_target(root, "flatpak") {
|
||||||
if let Ok(out) = exec.runner.execute(
|
if let Ok(out) = exec.runner.execute(&rooted(
|
||||||
&CommandSpec::new("sys", "inspect installed flatpaks", "flatpak").args([
|
root,
|
||||||
"list",
|
"sys",
|
||||||
"--app",
|
"inspect installed flatpaks",
|
||||||
"--columns=application,name,version",
|
"flatpak",
|
||||||
]),
|
&["list", "--app", "--columns=application,name,version"],
|
||||||
) {
|
)) {
|
||||||
if out.success {
|
if out.success {
|
||||||
let app_lower = application.to_ascii_lowercase();
|
let app_lower = application.to_ascii_lowercase();
|
||||||
for line in out.stdout_lossy().lines() {
|
for line in out.stdout_lossy().lines() {
|
||||||
|
|
@ -992,7 +1076,8 @@ pub fn installed_copies(exec: &Exec, root: &Path, application: &str) -> Installa
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Snap.
|
// Snap (host only).
|
||||||
|
if lane_selected(filter, Backend::Snap) && snap_on_host(root) {
|
||||||
if let Ok(entries) = crate::snap::list(exec) {
|
if let Ok(entries) = crate::snap::list(exec) {
|
||||||
for entry in entries {
|
for entry in entries {
|
||||||
if entry.name.eq_ignore_ascii_case(application) {
|
if entry.name.eq_ignore_ascii_case(application) {
|
||||||
|
|
@ -1004,8 +1089,10 @@ pub fn installed_copies(exec: &Exec, root: &Path, application: &str) -> Installa
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// AppImage (managed record).
|
// AppImage (managed record).
|
||||||
|
if lane_selected(filter, Backend::AppImage) {
|
||||||
if let Ok(records) = crate::appimage::list(root) {
|
if let Ok(records) = crate::appimage::list(root) {
|
||||||
for record in records {
|
for record in records {
|
||||||
if record.name.eq_ignore_ascii_case(application) {
|
if record.name.eq_ignore_ascii_case(application) {
|
||||||
|
|
@ -1023,8 +1110,10 @@ pub fn installed_copies(exec: &Exec, root: &Path, application: &str) -> Installa
|
||||||
version: record.version,
|
version: record.version,
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Portage (VDB).
|
// Portage (VDB).
|
||||||
|
if lane_selected(filter, Backend::PortageSource) {
|
||||||
if let Some((atom, version)) = portage_installed_atom_and_version(root, application) {
|
if let Some((atom, version)) = portage_installed_atom_and_version(root, application) {
|
||||||
copies.push(InstalledCopy {
|
copies.push(InstalledCopy {
|
||||||
backend: Backend::PortageSource.as_str().into(),
|
backend: Backend::PortageSource.as_str().into(),
|
||||||
|
|
@ -1032,6 +1121,7 @@ pub fn installed_copies(exec: &Exec, root: &Path, application: &str) -> Installa
|
||||||
version,
|
version,
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// De-duplicate any multiple matches within the same backend
|
// De-duplicate any multiple matches within the same backend
|
||||||
copies.dedup_by(|a, b| a.backend == b.backend && a.id == b.id);
|
copies.dedup_by(|a, b| a.backend == b.backend && a.id == b.id);
|
||||||
|
|
@ -1161,11 +1251,13 @@ mod tests {
|
||||||
#[test]
|
#[test]
|
||||||
fn portage_candidate_keeps_a_valid_install_atom() {
|
fn portage_candidate_keeps_a_valid_install_atom() {
|
||||||
let runner = RecordingRunner::new();
|
let runner = RecordingRunner::new();
|
||||||
|
// An alternate root runs Portage inside the target chroot; the mock
|
||||||
|
// runner therefore answers the `chroot` wrapper.
|
||||||
runner.set_response(
|
runner.set_response(
|
||||||
"emerge",
|
"chroot",
|
||||||
ok("Calculating dependencies... done!\n[ebuild N ] app-misc/hello-2.12.3 USE=\"nls\"\n"),
|
ok("Calculating dependencies... done!\n[ebuild N ] app-misc/hello-2.12.3 USE=\"nls\"\n"),
|
||||||
);
|
);
|
||||||
let exec = make_exec(runner);
|
let exec = make_exec(runner.clone());
|
||||||
let root = tempfile::tempdir().unwrap();
|
let root = tempfile::tempdir().unwrap();
|
||||||
let need = Need::new("app-misc/hello");
|
let need = Need::new("app-misc/hello");
|
||||||
let candidates = resolve_candidates(&exec, root.path(), &need);
|
let candidates = resolve_candidates(&exec, root.path(), &need);
|
||||||
|
|
@ -1177,6 +1269,13 @@ mod tests {
|
||||||
assert_eq!(portage.version.as_deref(), Some("2.12.3"));
|
assert_eq!(portage.version.as_deref(), Some("2.12.3"));
|
||||||
// And the id is a valid package spec that emerge accepts.
|
// And the id is a valid package spec that emerge accepts.
|
||||||
assert!(phoebus_core::action::valid_package_spec(&portage.id));
|
assert!(phoebus_core::action::valid_package_spec(&portage.id));
|
||||||
|
// The query must have been rooted in the target, never the host.
|
||||||
|
let recorded = runner.recorded();
|
||||||
|
let emerge = recorded
|
||||||
|
.iter()
|
||||||
|
.find(|s| s.program == "chroot" && s.args.iter().any(|a| a == "emerge"))
|
||||||
|
.expect("a chrooted emerge");
|
||||||
|
assert_eq!(emerge.args[0], root.path().to_string_lossy());
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
|
@ -1255,7 +1354,7 @@ mod tests {
|
||||||
fn resolve_includes_a_portage_candidate_from_real_metadata() {
|
fn resolve_includes_a_portage_candidate_from_real_metadata() {
|
||||||
let runner = RecordingRunner::new();
|
let runner = RecordingRunner::new();
|
||||||
runner.set_response(
|
runner.set_response(
|
||||||
"emerge",
|
"chroot",
|
||||||
ok("Calculating dependencies... done!\n[ebuild N ] app-editors/vim-9.1.0\n"),
|
ok("Calculating dependencies... done!\n[ebuild N ] app-editors/vim-9.1.0\n"),
|
||||||
);
|
);
|
||||||
let exec = make_exec(runner);
|
let exec = make_exec(runner);
|
||||||
|
|
@ -1270,7 +1369,7 @@ mod tests {
|
||||||
#[test]
|
#[test]
|
||||||
fn unresolved_portage_candidate_is_marked_unavailable() {
|
fn unresolved_portage_candidate_is_marked_unavailable() {
|
||||||
let runner = RecordingRunner::new();
|
let runner = RecordingRunner::new();
|
||||||
runner.fail("emerge", "no such package");
|
runner.fail("chroot", "no such package");
|
||||||
let exec = make_exec(runner);
|
let exec = make_exec(runner);
|
||||||
let root = tempfile::tempdir().unwrap();
|
let root = tempfile::tempdir().unwrap();
|
||||||
let need = Need::new("not-a-real-package");
|
let need = Need::new("not-a-real-package");
|
||||||
|
|
@ -1313,13 +1412,22 @@ mod tests {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn installed_copies_reports_duplication_and_versions() {
|
fn installed_copies_reports_duplication_and_versions() {
|
||||||
|
use std::os::unix::fs::PermissionsExt;
|
||||||
let runner = RecordingRunner::new();
|
let runner = RecordingRunner::new();
|
||||||
runner.set_response("flatpak", ok("org.mozilla.firefox 128\n"));
|
runner.set_response("chroot", ok("org.mozilla.firefox\tFirefox\t128\n"));
|
||||||
let exec = make_exec(runner);
|
let exec = make_exec(runner.clone());
|
||||||
let root = tempfile::tempdir().unwrap();
|
let root = tempfile::tempdir().unwrap();
|
||||||
|
// A Flatpak present only in the target must be discovered there.
|
||||||
|
let bin = root.path().join("usr/bin");
|
||||||
|
std::fs::create_dir_all(&bin).unwrap();
|
||||||
|
let flatpak = bin.join("flatpak");
|
||||||
|
std::fs::write(&flatpak, "#!/bin/sh\n").unwrap();
|
||||||
|
std::fs::set_permissions(&flatpak, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||||
let inspection = installed_copies(&exec, root.path(), "org.mozilla.firefox");
|
let inspection = installed_copies(&exec, root.path(), "org.mozilla.firefox");
|
||||||
assert_eq!(inspection.copies.len(), 1);
|
assert_eq!(inspection.copies.len(), 1);
|
||||||
assert_eq!(inspection.copies[0].version, "128");
|
assert_eq!(inspection.copies[0].version, "128");
|
||||||
assert!(!inspection.duplicate);
|
assert!(!inspection.duplicate);
|
||||||
|
// The target Flatpak, not the host's, was queried.
|
||||||
|
assert_eq!(runner.recorded()[0].program, "chroot");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -181,6 +181,28 @@ impl Exec {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Whether a tool is present in the intended target.
|
||||||
|
///
|
||||||
|
/// For the running root this is the host `PATH`. For an alternate root a query
|
||||||
|
/// runs inside the target chroot, so availability must be resolved from the
|
||||||
|
/// target's own binary directories rather than the host's, where a host tool
|
||||||
|
/// would otherwise leak into (or bypass) target operations.
|
||||||
|
pub fn tool_in_target(root: &Path, program: &str) -> bool {
|
||||||
|
if program.contains('/') {
|
||||||
|
let candidate = root.join(program.trim_start_matches('/'));
|
||||||
|
return is_executable(&candidate);
|
||||||
|
}
|
||||||
|
if root == Path::new("/") {
|
||||||
|
return find_in_path(program).is_some();
|
||||||
|
}
|
||||||
|
for dir in ["usr/bin", "usr/sbin", "usr/local/bin", "bin", "sbin"] {
|
||||||
|
if is_executable(&root.join(dir).join(program)) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
false
|
||||||
|
}
|
||||||
|
|
||||||
pub fn find_in_path(program: &str) -> Option<PathBuf> {
|
pub fn find_in_path(program: &str) -> Option<PathBuf> {
|
||||||
if program.contains('/') {
|
if program.contains('/') {
|
||||||
let p = PathBuf::from(program);
|
let p = PathBuf::from(program);
|
||||||
|
|
|
||||||
|
|
@ -903,13 +903,19 @@ mod tests {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn validation_detects_an_ambiguous_friendly_name() {
|
fn validation_detects_an_ambiguous_friendly_name() {
|
||||||
|
use std::os::unix::fs::PermissionsExt;
|
||||||
let runner = RecordingRunner::new();
|
let runner = RecordingRunner::new();
|
||||||
runner.set_response(
|
runner.set_response(
|
||||||
"flatpak",
|
"chroot",
|
||||||
ok("org.mozilla.firefox 128 stable\norg.mozilla.firefoxpwa 1.0 stable\n"),
|
ok("org.mozilla.firefox 128 stable\norg.mozilla.firefoxpwa 1.0 stable\n"),
|
||||||
);
|
);
|
||||||
let exec = make_exec(runner);
|
let exec = make_exec(runner);
|
||||||
let root = tempfile::tempdir().unwrap();
|
let root = tempfile::tempdir().unwrap();
|
||||||
|
let bin = root.path().join("usr/bin");
|
||||||
|
std::fs::create_dir_all(&bin).unwrap();
|
||||||
|
let flatpak = bin.join("flatpak");
|
||||||
|
std::fs::write(&flatpak, "#!/bin/sh\n").unwrap();
|
||||||
|
std::fs::set_permissions(&flatpak, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||||
let request = InstallRequest::new("firefox");
|
let request = InstallRequest::new("firefox");
|
||||||
let proposal = InstallProposal {
|
let proposal = InstallProposal {
|
||||||
application: "firefox".into(),
|
application: "firefox".into(),
|
||||||
|
|
@ -972,23 +978,33 @@ mod tests {
|
||||||
duration: Duration::from_millis(1),
|
duration: Duration::from_millis(1),
|
||||||
};
|
};
|
||||||
let version = self.version.load(std::sync::atomic::Ordering::SeqCst);
|
let version = self.version.load(std::sync::atomic::Ordering::SeqCst);
|
||||||
match spec.program.as_str() {
|
let is_flatpak = spec.program == "flatpak" || spec.args.iter().any(|a| a == "flatpak");
|
||||||
"flatpak" if spec.args.iter().any(|a| a == "search") => {
|
let is_emerge = spec.program == "emerge" || spec.args.iter().any(|a| a == "emerge");
|
||||||
|
if is_flatpak && spec.args.iter().any(|a| a == "search") {
|
||||||
Ok(ok(format!("org.mozilla.firefox {version}\n")))
|
Ok(ok(format!("org.mozilla.firefox {version}\n")))
|
||||||
}
|
} else if is_flatpak && spec.args.iter().any(|a| a == "list") {
|
||||||
"flatpak" if spec.args.iter().any(|a| a == "list") => Ok(ok(if self.installed {
|
Ok(ok(if self.installed {
|
||||||
format!("org.mozilla.firefox {version}\n")
|
format!("org.mozilla.firefox {version}\n")
|
||||||
} else {
|
} else {
|
||||||
String::new()
|
String::new()
|
||||||
})),
|
}))
|
||||||
"emerge" => Ok(fail()),
|
} else if is_emerge {
|
||||||
_ => Ok(ok(String::new())),
|
Ok(fail())
|
||||||
|
} else {
|
||||||
|
Ok(ok(String::new()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn arg_exec(version: std::sync::Arc<std::sync::atomic::AtomicU32>, installed: bool) -> Exec {
|
fn arg_exec(version: std::sync::Arc<std::sync::atomic::AtomicU32>, installed: bool) -> Exec {
|
||||||
|
use std::os::unix::fs::PermissionsExt;
|
||||||
let path = tempfile::tempdir().unwrap().keep();
|
let path = tempfile::tempdir().unwrap().keep();
|
||||||
|
// A Flatpak must be present in the *target* for the lane to resolve.
|
||||||
|
let bin = path.join("root/usr/bin");
|
||||||
|
std::fs::create_dir_all(&bin).unwrap();
|
||||||
|
let flatpak = bin.join("flatpak");
|
||||||
|
std::fs::write(&flatpak, "#!/bin/sh\n").unwrap();
|
||||||
|
std::fs::set_permissions(&flatpak, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||||
let logger = Logger::open(path.join("l.log"), Redactor::new(), false);
|
let logger = Logger::open(path.join("l.log"), Redactor::new(), false);
|
||||||
Exec::new(
|
Exec::new(
|
||||||
Box::new(ArgRunner::new(version, installed)),
|
Box::new(ArgRunner::new(version, installed)),
|
||||||
|
|
@ -1044,19 +1060,12 @@ mod tests {
|
||||||
fn ai_unqualified_install_is_confirmed_by_the_resolver() {
|
fn ai_unqualified_install_is_confirmed_by_the_resolver() {
|
||||||
let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128));
|
let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128));
|
||||||
let exec = arg_exec(version, false);
|
let exec = arg_exec(version, false);
|
||||||
let root = tempfile::tempdir().unwrap();
|
let root = Path::new(&exec.root);
|
||||||
let request = InstallRequest::new("firefox");
|
let request = InstallRequest::new("firefox");
|
||||||
let transport =
|
let transport =
|
||||||
phoebus_ai::provider::ScriptedTransport::new(vec![proposal("org.mozilla.firefox")]);
|
phoebus_ai::provider::ScriptedTransport::new(vec![proposal("org.mozilla.firefox")]);
|
||||||
let resolved = resolve_with_ai(
|
let resolved =
|
||||||
&exec,
|
resolve_with_ai(&exec, root, &request, &NoAsk, &ai(&transport), &facts()).unwrap();
|
||||||
root.path(),
|
|
||||||
&request,
|
|
||||||
&NoAsk,
|
|
||||||
&ai(&transport),
|
|
||||||
&facts(),
|
|
||||||
)
|
|
||||||
.unwrap();
|
|
||||||
assert_eq!(resolved.candidate.id, "org.mozilla.firefox");
|
assert_eq!(resolved.candidate.id, "org.mozilla.firefox");
|
||||||
assert_eq!(resolved.source, InstallSource::AiRecommendation);
|
assert_eq!(resolved.source, InstallSource::AiRecommendation);
|
||||||
assert!(matches!(
|
assert!(matches!(
|
||||||
|
|
@ -1069,21 +1078,14 @@ mod tests {
|
||||||
fn a_fabricated_candidate_is_rejected_and_the_model_revises() {
|
fn a_fabricated_candidate_is_rejected_and_the_model_revises() {
|
||||||
let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128));
|
let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128));
|
||||||
let exec = arg_exec(version, false);
|
let exec = arg_exec(version, false);
|
||||||
let root = tempfile::tempdir().unwrap();
|
let root = Path::new(&exec.root);
|
||||||
let request = InstallRequest::new("firefox");
|
let request = InstallRequest::new("firefox");
|
||||||
let transport = phoebus_ai::provider::ScriptedTransport::new(vec![
|
let transport = phoebus_ai::provider::ScriptedTransport::new(vec![
|
||||||
proposal("org.evil.Firefox"),
|
proposal("org.evil.Firefox"),
|
||||||
proposal("org.mozilla.firefox"),
|
proposal("org.mozilla.firefox"),
|
||||||
]);
|
]);
|
||||||
let resolved = resolve_with_ai(
|
let resolved =
|
||||||
&exec,
|
resolve_with_ai(&exec, root, &request, &NoAsk, &ai(&transport), &facts()).unwrap();
|
||||||
root.path(),
|
|
||||||
&request,
|
|
||||||
&NoAsk,
|
|
||||||
&ai(&transport),
|
|
||||||
&facts(),
|
|
||||||
)
|
|
||||||
.unwrap();
|
|
||||||
assert_eq!(resolved.candidate.id, "org.mozilla.firefox");
|
assert_eq!(resolved.candidate.id, "org.mozilla.firefox");
|
||||||
// The second request carries the resolver's finding.
|
// The second request carries the resolver's finding.
|
||||||
assert!(transport.requests()[1].contains("no available"));
|
assert!(transport.requests()[1].contains("no available"));
|
||||||
|
|
@ -1093,19 +1095,19 @@ mod tests {
|
||||||
fn a_changed_candidate_version_invalidates_the_review() {
|
fn a_changed_candidate_version_invalidates_the_review() {
|
||||||
let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128));
|
let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128));
|
||||||
let exec = arg_exec(version.clone(), false);
|
let exec = arg_exec(version.clone(), false);
|
||||||
let root = tempfile::tempdir().unwrap();
|
let root = Path::new(&exec.root);
|
||||||
let mut request = InstallRequest::new("firefox");
|
let mut request = InstallRequest::new("firefox");
|
||||||
request.backend = Some(Backend::Flatpak);
|
request.backend = Some(Backend::Flatpak);
|
||||||
let resolved = resolve_explicit(&exec, root.path(), &request).unwrap();
|
let resolved = resolve_explicit(&exec, root, &request).unwrap();
|
||||||
assert_eq!(resolved.candidate.version.as_deref(), Some("128"));
|
assert_eq!(resolved.candidate.version.as_deref(), Some("128"));
|
||||||
// Same metadata -> the reviewed digest revalidates.
|
// Same metadata -> the reviewed digest revalidates.
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
revalidate(&exec, root.path(), &resolved).unwrap(),
|
revalidate(&exec, root, &resolved).unwrap(),
|
||||||
resolved.approval_digest()
|
resolved.approval_digest()
|
||||||
);
|
);
|
||||||
// The remote publishes a new version: the approval is invalidated.
|
// The remote publishes a new version: the approval is invalidated.
|
||||||
version.store(129, std::sync::atomic::Ordering::SeqCst);
|
version.store(129, std::sync::atomic::Ordering::SeqCst);
|
||||||
let err = revalidate(&exec, root.path(), &resolved).unwrap_err();
|
let err = revalidate(&exec, root, &resolved).unwrap_err();
|
||||||
assert!(err.to_string().contains("version changed"), "{err}");
|
assert!(err.to_string().contains("version changed"), "{err}");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -1113,10 +1115,10 @@ mod tests {
|
||||||
fn an_already_installed_app_in_the_same_lane_is_not_reinstalled() {
|
fn an_already_installed_app_in_the_same_lane_is_not_reinstalled() {
|
||||||
let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128));
|
let version = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(128));
|
||||||
let exec = arg_exec(version, true);
|
let exec = arg_exec(version, true);
|
||||||
let root = tempfile::tempdir().unwrap();
|
let root = Path::new(&exec.root);
|
||||||
let mut request = InstallRequest::new("org.mozilla.firefox");
|
let mut request = InstallRequest::new("org.mozilla.firefox");
|
||||||
request.backend = Some(Backend::Flatpak);
|
request.backend = Some(Backend::Flatpak);
|
||||||
let err = resolve_explicit(&exec, root.path(), &request).unwrap_err();
|
let err = resolve_explicit(&exec, root, &request).unwrap_err();
|
||||||
assert!(err.to_string().contains("already installed"), "{err}");
|
assert!(err.to_string().contains("already installed"), "{err}");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -304,6 +304,242 @@ pub fn profiles(root: &Path) -> Vec<NixProfile> {
|
||||||
out
|
out
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// One package installed in an active Nix profile.
|
||||||
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||||
|
pub struct NixInstalledPackage {
|
||||||
|
/// The nixpkgs attribute path when the manifest records one (e.g.
|
||||||
|
/// `legacyPackages.x86_64-linux.nodejs`), otherwise the store name.
|
||||||
|
pub path: String,
|
||||||
|
/// The package identity (the last attribute component, or the store name).
|
||||||
|
pub name: String,
|
||||||
|
pub version: Option<String>,
|
||||||
|
pub store_path: String,
|
||||||
|
/// Human label for the profile: `default`, `profile`, or `per-user:<user>`.
|
||||||
|
pub profile: String,
|
||||||
|
pub user: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The result of reading active Nix profiles. `notes` records unsupported
|
||||||
|
/// profile formats and base profiles so an incomplete enumeration is never
|
||||||
|
/// presented as complete.
|
||||||
|
#[derive(Debug, Clone, Default, PartialEq, Eq)]
|
||||||
|
pub struct NixProfileInventory {
|
||||||
|
pub packages: Vec<NixInstalledPackage>,
|
||||||
|
pub notes: Vec<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The active (current-generation) profile links in the target.
|
||||||
|
///
|
||||||
|
/// Only the `default` and `profile` links are current: the historical
|
||||||
|
/// `profile-N-link` generations are deliberately not counted as installed
|
||||||
|
/// packages.
|
||||||
|
fn active_profile_links(root: &Path) -> Vec<(String, Option<String>, PathBuf)> {
|
||||||
|
let base = target_path(root, "nix/var/nix/profiles");
|
||||||
|
let mut out = Vec::new();
|
||||||
|
for name in ["default", "profile"] {
|
||||||
|
let path = base.join(name);
|
||||||
|
if path.symlink_metadata().is_ok() {
|
||||||
|
out.push((name.to_string(), None, path));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let per_user = base.join("per-user");
|
||||||
|
if let Ok(users) = std::fs::read_dir(&per_user) {
|
||||||
|
for user in users.flatten() {
|
||||||
|
if !user.file_type().map(|t| t.is_dir()).unwrap_or(false) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
let user_name = user.file_name().to_string_lossy().to_string();
|
||||||
|
let path = user.path().join("profile");
|
||||||
|
if path.symlink_metadata().is_ok() {
|
||||||
|
out.push((format!("per-user:{user_name}"), Some(user_name), path));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out.sort_by(|a, b| a.0.cmp(&b.0));
|
||||||
|
out
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Extract `(name, version)` from a store basename like
|
||||||
|
/// `abc123-nodejs-22.11.0` or `abc123-nodejs`.
|
||||||
|
fn store_name_parts(basename: &str) -> (String, Option<String>) {
|
||||||
|
let rest = basename
|
||||||
|
.split_once('-')
|
||||||
|
.map(|(_, rest)| rest)
|
||||||
|
.unwrap_or(basename)
|
||||||
|
.to_string();
|
||||||
|
let Some(idx) = rest
|
||||||
|
.char_indices()
|
||||||
|
.filter(|(i, c)| *c == '-' && rest[i + 1..].starts_with(|d: char| d.is_ascii_digit()))
|
||||||
|
.map(|(i, _)| i)
|
||||||
|
.next_back()
|
||||||
|
else {
|
||||||
|
return (rest, None);
|
||||||
|
};
|
||||||
|
let (name, version) = rest.split_at(idx);
|
||||||
|
(
|
||||||
|
name.to_string(),
|
||||||
|
Some(version.trim_start_matches('-').to_string()),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parse a `nix profile` `manifest.json`. Returns an error string for an
|
||||||
|
/// unsupported/undecodable format so the caller can say so explicitly.
|
||||||
|
pub fn parse_manifest(
|
||||||
|
profile: &str,
|
||||||
|
user: Option<&str>,
|
||||||
|
text: &str,
|
||||||
|
) -> std::result::Result<Vec<NixInstalledPackage>, String> {
|
||||||
|
let value: serde_json::Value =
|
||||||
|
serde_json::from_str(text).map_err(|e| format!("manifest is not JSON: {e}"))?;
|
||||||
|
let version = value.get("version").and_then(|v| v.as_u64());
|
||||||
|
let Some(elements) = value.get("elements") else {
|
||||||
|
return Err("manifest has no `elements`".to_string());
|
||||||
|
};
|
||||||
|
let mut out = Vec::new();
|
||||||
|
let mut push = |element: &serde_json::Value| {
|
||||||
|
if element.get("active").and_then(|v| v.as_bool()) == Some(false) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let attr = element
|
||||||
|
.get("attrPath")
|
||||||
|
.and_then(|v| v.as_str())
|
||||||
|
.map(str::to_string);
|
||||||
|
let store_paths: Vec<String> = element
|
||||||
|
.get("storePaths")
|
||||||
|
.and_then(|v| v.as_array())
|
||||||
|
.map(|a| {
|
||||||
|
a.iter()
|
||||||
|
.filter_map(|v| v.as_str())
|
||||||
|
.map(str::to_string)
|
||||||
|
.collect()
|
||||||
|
})
|
||||||
|
.or_else(|| {
|
||||||
|
element
|
||||||
|
.get("storePath")
|
||||||
|
.and_then(|v| v.as_str())
|
||||||
|
.map(|s| vec![s.to_string()])
|
||||||
|
})
|
||||||
|
.unwrap_or_default();
|
||||||
|
let store_path = store_paths.first().cloned().unwrap_or_default();
|
||||||
|
let basename = store_path.rsplit('/').next().unwrap_or("").to_string();
|
||||||
|
let (store_name, version) = store_name_parts(&basename);
|
||||||
|
let name = attr
|
||||||
|
.as_deref()
|
||||||
|
.and_then(|a| a.rsplit('.').next())
|
||||||
|
.map(str::to_string)
|
||||||
|
.filter(|n| !n.is_empty())
|
||||||
|
.unwrap_or_else(|| store_name.clone());
|
||||||
|
let path = attr.unwrap_or_else(|| name.clone());
|
||||||
|
out.push(NixInstalledPackage {
|
||||||
|
path,
|
||||||
|
name,
|
||||||
|
version,
|
||||||
|
store_path,
|
||||||
|
profile: profile.to_string(),
|
||||||
|
user: user.map(str::to_string),
|
||||||
|
});
|
||||||
|
};
|
||||||
|
match elements {
|
||||||
|
serde_json::Value::Array(items) => {
|
||||||
|
for element in items {
|
||||||
|
push(element);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
serde_json::Value::Object(map) => {
|
||||||
|
for element in map.values() {
|
||||||
|
push(element);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
return Err(format!(
|
||||||
|
"unsupported manifest element container (version {})",
|
||||||
|
version.map(|v| v.to_string()).unwrap_or_else(|| "?".into())
|
||||||
|
))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if out.is_empty() && version.is_some_and(|v| v > 3) {
|
||||||
|
return Err(format!(
|
||||||
|
"manifest version {} is newer than supported",
|
||||||
|
version.unwrap()
|
||||||
|
));
|
||||||
|
}
|
||||||
|
Ok(out)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Enumerate the packages installed in the active Nix profiles of the target.
|
||||||
|
///
|
||||||
|
/// Historical generations and bare store paths are not packages: generations
|
||||||
|
/// are noted, and `store_path_count` reports realised store contents
|
||||||
|
/// separately. A profile whose manifest is missing or an unsupported format is
|
||||||
|
/// reported in `notes` rather than silently omitted.
|
||||||
|
pub fn installed_packages(root: &Path) -> NixProfileInventory {
|
||||||
|
let mut inventory = NixProfileInventory::default();
|
||||||
|
for (label, user, link) in active_profile_links(root) {
|
||||||
|
let Ok(resolved) = std::fs::canonicalize(&link) else {
|
||||||
|
inventory.notes.push(format!(
|
||||||
|
"profile `{label}` is a dangling link; not enumerated"
|
||||||
|
));
|
||||||
|
continue;
|
||||||
|
};
|
||||||
|
let resolved = resolved.to_string_lossy().to_string();
|
||||||
|
// Never follow a profile outside the target.
|
||||||
|
if !resolved.starts_with(&root.to_string_lossy().to_string()) {
|
||||||
|
inventory.notes.push(format!(
|
||||||
|
"profile `{label}` resolves outside the target; not enumerated"
|
||||||
|
));
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
let manifest = Path::new(&resolved).join("manifest.json");
|
||||||
|
match std::fs::read_to_string(&manifest) {
|
||||||
|
Ok(text) => match parse_manifest(&label, user.as_deref(), &text) {
|
||||||
|
Ok(mut packages) => inventory.packages.append(&mut packages),
|
||||||
|
Err(e) => inventory.notes.push(format!(
|
||||||
|
"profile `{label}` uses an unsupported manifest format ({e}); not enumerated"
|
||||||
|
)),
|
||||||
|
},
|
||||||
|
Err(_) => inventory.notes.push(format!(
|
||||||
|
"profile `{label}` has no package manifest (base/system profile); \
|
||||||
|
its packages are not listed"
|
||||||
|
)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Historical generations are explicitly not current packages.
|
||||||
|
let generations = historical_generation_count(root);
|
||||||
|
if generations > 0 {
|
||||||
|
inventory.notes.push(format!(
|
||||||
|
"{generations} historical profile generation(s) exist and are not counted as \
|
||||||
|
installed packages"
|
||||||
|
));
|
||||||
|
}
|
||||||
|
inventory
|
||||||
|
.packages
|
||||||
|
.sort_by(|a, b| a.name.cmp(&b.name).then(a.profile.cmp(&b.profile)));
|
||||||
|
inventory
|
||||||
|
}
|
||||||
|
|
||||||
|
fn historical_generation_count(root: &Path) -> usize {
|
||||||
|
let base = target_path(root, "nix/var/nix/profiles");
|
||||||
|
let mut count = 0;
|
||||||
|
let mut visit = |dir: &Path| {
|
||||||
|
if let Ok(entries) = std::fs::read_dir(dir) {
|
||||||
|
for entry in entries.flatten() {
|
||||||
|
let name = entry.file_name().to_string_lossy().to_string();
|
||||||
|
if name.starts_with("profile-") && name.ends_with("-link") {
|
||||||
|
count += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
visit(&base);
|
||||||
|
let per_user = base.join("per-user");
|
||||||
|
if let Ok(users) = std::fs::read_dir(&per_user) {
|
||||||
|
for user in users.flatten() {
|
||||||
|
visit(&user.path());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
count
|
||||||
|
}
|
||||||
|
|
||||||
/// Number of realised store paths, if the store exists. `None` means the store
|
/// Number of realised store paths, if the store exists. `None` means the store
|
||||||
/// is absent (Nix is not installed).
|
/// is absent (Nix is not installed).
|
||||||
pub fn store_path_count(root: &Path) -> Option<usize> {
|
pub fn store_path_count(root: &Path) -> Option<usize> {
|
||||||
|
|
@ -467,6 +703,105 @@ mod tests {
|
||||||
assert!(!valid_nix_attribute("a b"));
|
assert!(!valid_nix_attribute("a b"));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn profile_manifest_v3() -> &'static str {
|
||||||
|
r#"{
|
||||||
|
"version": 3,
|
||||||
|
"elements": [
|
||||||
|
{
|
||||||
|
"active": true,
|
||||||
|
"attrPath": "legacyPackages.x86_64-linux.nodejs",
|
||||||
|
"storePaths": ["/nix/store/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-nodejs-22.11.0"],
|
||||||
|
"originalUrl": "flake:nixpkgs"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"active": false,
|
||||||
|
"attrPath": "legacyPackages.x86_64-linux.gcc",
|
||||||
|
"storePaths": ["/nix/store/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb-gcc-13.2.0"]
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}"#
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn installed_packages_enumerates_supported_profiles_and_skips_inactive() {
|
||||||
|
let runner = RecordingRunner::new();
|
||||||
|
let exec = make_exec(runner, false);
|
||||||
|
let root = Path::new(&exec.root);
|
||||||
|
let store = root.join("nix/store/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-nodejs-22.11.0");
|
||||||
|
std::fs::create_dir_all(&store).unwrap();
|
||||||
|
std::fs::write(store.join("manifest.json"), profile_manifest_v3()).unwrap();
|
||||||
|
let profiles = root.join("nix/var/nix/profiles");
|
||||||
|
std::fs::create_dir_all(&profiles).unwrap();
|
||||||
|
std::os::unix::fs::symlink(&store, profiles.join("default")).unwrap();
|
||||||
|
// A historical generation must not be counted as current.
|
||||||
|
std::os::unix::fs::symlink(&store, profiles.join("profile-1-link")).unwrap();
|
||||||
|
|
||||||
|
let inventory = installed_packages(root);
|
||||||
|
assert_eq!(inventory.packages.len(), 1, "{:?}", inventory);
|
||||||
|
let pkg = &inventory.packages[0];
|
||||||
|
assert_eq!(pkg.name, "nodejs");
|
||||||
|
assert_eq!(pkg.version.as_deref(), Some("22.11.0"));
|
||||||
|
assert_eq!(pkg.profile, "default");
|
||||||
|
assert!(pkg.path.contains("nodejs"));
|
||||||
|
assert!(inventory
|
||||||
|
.notes
|
||||||
|
.iter()
|
||||||
|
.any(|n| n.contains("historical profile generation")));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn installed_packages_reports_unsupported_manifest_formats_explicitly() {
|
||||||
|
let runner = RecordingRunner::new();
|
||||||
|
let exec = make_exec(runner, false);
|
||||||
|
let root = Path::new(&exec.root);
|
||||||
|
let store = root.join("nix/store/cccccccccccccccccccccccccccccccc-future-1.0");
|
||||||
|
std::fs::create_dir_all(&store).unwrap();
|
||||||
|
std::fs::write(
|
||||||
|
store.join("manifest.json"),
|
||||||
|
r#"{"version": 99, "elements": []}"#,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let profiles = root.join("nix/var/nix/profiles");
|
||||||
|
std::fs::create_dir_all(&profiles).unwrap();
|
||||||
|
std::os::unix::fs::symlink(&store, profiles.join("profile")).unwrap();
|
||||||
|
|
||||||
|
let inventory = installed_packages(root);
|
||||||
|
assert!(inventory.packages.is_empty());
|
||||||
|
assert!(
|
||||||
|
inventory
|
||||||
|
.notes
|
||||||
|
.iter()
|
||||||
|
.any(|n| n.contains("newer than supported")),
|
||||||
|
"{:?}",
|
||||||
|
inventory.notes
|
||||||
|
);
|
||||||
|
// A profile with no manifest is a base profile, reported distinctly.
|
||||||
|
std::fs::create_dir_all(root.join("nix/var/nix/profiles")).unwrap();
|
||||||
|
std::os::unix::fs::symlink(root.join("nix/store"), profiles.join("default")).unwrap();
|
||||||
|
let second = installed_packages(root);
|
||||||
|
assert!(
|
||||||
|
second
|
||||||
|
.notes
|
||||||
|
.iter()
|
||||||
|
.any(|n| n.contains("no package manifest")),
|
||||||
|
"{:?}",
|
||||||
|
second.notes
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn parse_manifest_v1_store_path_is_supported() {
|
||||||
|
let text = r#"{
|
||||||
|
"version": 1,
|
||||||
|
"elements": [
|
||||||
|
{"active": true, "uri": "nixpkgs", "storePath": "/nix/store/dddd-vim-9.1.0"}
|
||||||
|
]
|
||||||
|
}"#;
|
||||||
|
let parsed = parse_manifest("default", None, text).unwrap();
|
||||||
|
assert_eq!(parsed.len(), 1);
|
||||||
|
assert_eq!(parsed[0].name, "vim");
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn remove_unlinks_units_and_optionally_purges() {
|
fn remove_unlinks_units_and_optionally_purges() {
|
||||||
let runner = RecordingRunner::new();
|
let runner = RecordingRunner::new();
|
||||||
|
|
|
||||||
|
|
@ -466,6 +466,7 @@ pub struct InstalledPortage {
|
||||||
pub repository: Option<String>,
|
pub repository: Option<String>,
|
||||||
pub depend: Option<String>,
|
pub depend: Option<String>,
|
||||||
pub rdepend: Option<String>,
|
pub rdepend: Option<String>,
|
||||||
|
pub bdepend: Option<String>,
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Split `category/pkgname-1.2.3-r1` into `(category/pkgname, "1.2.3-r1")`.
|
/// Split `category/pkgname-1.2.3-r1` into `(category/pkgname, "1.2.3-r1")`.
|
||||||
|
|
@ -532,6 +533,7 @@ pub fn installed_packages(root: &Path) -> Vec<InstalledPortage> {
|
||||||
repository: read_vdb_field(&dir, "repository"),
|
repository: read_vdb_field(&dir, "repository"),
|
||||||
depend: read_vdb_field(&dir, "DEPEND"),
|
depend: read_vdb_field(&dir, "DEPEND"),
|
||||||
rdepend: read_vdb_field(&dir, "RDEPEND"),
|
rdepend: read_vdb_field(&dir, "RDEPEND"),
|
||||||
|
bdepend: read_vdb_field(&dir, "BDEPEND"),
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -602,6 +604,108 @@ fn nonempty(value: &str) -> Option<String> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// One declared dependency, preserving its version/conditional context.
|
||||||
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||||
|
pub struct DeclaredDependency {
|
||||||
|
/// The raw token, e.g. `>=dev-libs/glib-2.0` or `cat/pkg:1`.
|
||||||
|
pub raw: String,
|
||||||
|
/// The package atom with operators, version, slot and USE stripped.
|
||||||
|
pub atom: String,
|
||||||
|
/// The USE flag/group this dependency is conditional on, if any.
|
||||||
|
pub condition: Option<String>,
|
||||||
|
/// A blocker (`!cat/pkg`).
|
||||||
|
pub negative: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Tokenize a dependency string, keeping parentheses as separate tokens.
|
||||||
|
fn tokenize_depends(text: &str) -> Vec<String> {
|
||||||
|
let mut tokens = Vec::new();
|
||||||
|
let mut current = String::new();
|
||||||
|
for c in text.chars() {
|
||||||
|
match c {
|
||||||
|
'(' | ')' => {
|
||||||
|
if !current.is_empty() {
|
||||||
|
tokens.push(std::mem::take(&mut current));
|
||||||
|
}
|
||||||
|
tokens.push(c.to_string());
|
||||||
|
}
|
||||||
|
c if c.is_whitespace() => {
|
||||||
|
if !current.is_empty() {
|
||||||
|
tokens.push(std::mem::take(&mut current));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
c => current.push(c),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !current.is_empty() {
|
||||||
|
tokens.push(current);
|
||||||
|
}
|
||||||
|
tokens
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Normalize a dependency token to a bare `category/name` atom.
|
||||||
|
pub fn normalize_dep_atom(token: &str) -> String {
|
||||||
|
let mut t = token.trim_start_matches(['!', '?']).to_string();
|
||||||
|
// USE dependency / slot / version: keep only `category/name`.
|
||||||
|
if let Some(idx) = t.find('[') {
|
||||||
|
t.truncate(idx);
|
||||||
|
}
|
||||||
|
if let Some(idx) = t.find(':') {
|
||||||
|
t.truncate(idx);
|
||||||
|
}
|
||||||
|
for op in ["~", ">=", "<=", "=", ">", "<"] {
|
||||||
|
t = t.trim_start_matches(op).to_string();
|
||||||
|
}
|
||||||
|
if let Some((atom, _)) = split_pkgver(&t) {
|
||||||
|
atom
|
||||||
|
} else {
|
||||||
|
t
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parse a declared dependency string into atoms, preserving conditionals and
|
||||||
|
/// version operators. Dependencies inside a USE-conditional or any-of group
|
||||||
|
/// keep that context so the report is honest about when they apply.
|
||||||
|
pub fn parse_dependencies(text: &str) -> Vec<DeclaredDependency> {
|
||||||
|
let mut out = Vec::new();
|
||||||
|
let mut conditions: Vec<String> = Vec::new();
|
||||||
|
let mut pending: Option<String> = None;
|
||||||
|
for token in tokenize_depends(text) {
|
||||||
|
match token.as_str() {
|
||||||
|
"(" => {
|
||||||
|
let context = pending.take().unwrap_or_else(|| "group".to_string());
|
||||||
|
conditions.push(context);
|
||||||
|
}
|
||||||
|
")" => {
|
||||||
|
conditions.pop();
|
||||||
|
}
|
||||||
|
"||" => {
|
||||||
|
pending = Some("any-of".to_string());
|
||||||
|
}
|
||||||
|
"??" => {
|
||||||
|
pending = Some("any-of".to_string());
|
||||||
|
}
|
||||||
|
t if t.ends_with('?') => {
|
||||||
|
pending = Some(format!("{}?", t.trim_end_matches('?')));
|
||||||
|
}
|
||||||
|
t if t.contains('/') => {
|
||||||
|
let negative = t.starts_with('!');
|
||||||
|
let atom = normalize_dep_atom(t);
|
||||||
|
if atom.contains('/') {
|
||||||
|
out.push(DeclaredDependency {
|
||||||
|
raw: t.to_string(),
|
||||||
|
atom,
|
||||||
|
condition: conditions.last().cloned(),
|
||||||
|
negative,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out
|
||||||
|
}
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
|
|
@ -799,6 +903,30 @@ mod tests {
|
||||||
assert!(installed_packages(Path::new(&exec.root)).is_empty());
|
assert!(installed_packages(Path::new(&exec.root)).is_empty());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn dependency_parser_preserves_conditions_versions_and_blockers() {
|
||||||
|
let deps = parse_dependencies(
|
||||||
|
">=dev-libs/glib-2.0 python? ( dev-lang/python ) !app-misc/old || ( a/b c/d )",
|
||||||
|
);
|
||||||
|
let by_atom = |atom: &str| {
|
||||||
|
deps.iter()
|
||||||
|
.find(|d| d.atom == atom)
|
||||||
|
.unwrap_or_else(|| panic!("missing {atom} in {deps:?}"))
|
||||||
|
};
|
||||||
|
assert_eq!(by_atom("dev-libs/glib").raw, ">=dev-libs/glib-2.0");
|
||||||
|
assert_eq!(
|
||||||
|
by_atom("dev-lang/python").condition.as_deref(),
|
||||||
|
Some("python?")
|
||||||
|
);
|
||||||
|
assert!(by_atom("app-misc/old").negative);
|
||||||
|
assert_eq!(by_atom("a/b").condition.as_deref(), Some("any-of"));
|
||||||
|
// self-atom normalization strips operators, slot and USE.
|
||||||
|
assert_eq!(
|
||||||
|
normalize_dep_atom(">=dev-lang/python-3.12:3.12[ssl]"),
|
||||||
|
"dev-lang/python"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn normalize_config_permissions_makes_read_only_queries_possible() {
|
fn normalize_config_permissions_makes_read_only_queries_possible() {
|
||||||
use std::os::unix::fs::PermissionsExt;
|
use std::os::unix::fs::PermissionsExt;
|
||||||
|
|
|
||||||
|
|
@ -89,11 +89,19 @@ fn stderr_tail(text: &str) -> String {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Whether the Flatpak client answers in the target.
|
/// Whether the Flatpak client answers in the intended target. For an alternate
|
||||||
fn flatpak_available(exec: &Exec, root: &Path) -> bool {
|
/// 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)
|
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
|
// Search
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
|
|
@ -244,8 +252,13 @@ fn search_flatpak(exec: &Exec, root: &Path, query: &str, backend: Backend) -> So
|
||||||
}
|
}
|
||||||
|
|
||||||
fn search_snap(exec: &Exec, root: &Path, query: &str, backend: Backend) -> SourceReport {
|
fn search_snap(exec: &Exec, root: &Path, query: &str, backend: Backend) -> SourceReport {
|
||||||
let usable = matches!(snap::status(exec), Ok(s) if s.usable());
|
if !crate::actions::is_host_root(root) {
|
||||||
if !usable {
|
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");
|
return SourceReport::unsupported(backend, "snapd is not installed or active");
|
||||||
}
|
}
|
||||||
let out = match capture(exec, root, "snap", &["find", query, "--color=never"]) {
|
let out = match capture(exec, root, "snap", &["find", query, "--color=never"]) {
|
||||||
|
|
@ -454,9 +467,14 @@ fn inventory_flatpak(exec: &Exec, root: &Path, backend: Backend) -> SourceReport
|
||||||
SourceReport::ok(backend, "installed Flatpak applications", entries)
|
SourceReport::ok(backend, "installed Flatpak applications", entries)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn inventory_snap(exec: &Exec, _root: &Path, backend: Backend) -> SourceReport {
|
fn inventory_snap(exec: &Exec, root: &Path, backend: Backend) -> SourceReport {
|
||||||
let usable = matches!(snap::status(exec), Ok(s) if s.usable());
|
if !crate::actions::is_host_root(root) {
|
||||||
if !usable {
|
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");
|
return SourceReport::unsupported(backend, "snapd is not installed or active");
|
||||||
}
|
}
|
||||||
match snap::list(exec) {
|
match snap::list(exec) {
|
||||||
|
|
@ -498,23 +516,29 @@ fn inventory_nix(root: &Path, backend: Backend) -> SourceReport {
|
||||||
let Some(store_paths) = nix::store_path_count(root) else {
|
let Some(store_paths) = nix::store_path_count(root) else {
|
||||||
return SourceReport::unsupported(backend, "Nix is not installed");
|
return SourceReport::unsupported(backend, "Nix is not installed");
|
||||||
};
|
};
|
||||||
let profiles = nix::profiles(root);
|
let inventory = nix::installed_packages(root);
|
||||||
let entries = profiles
|
let entries = inventory
|
||||||
|
.packages
|
||||||
.into_iter()
|
.into_iter()
|
||||||
.map(|p| {
|
.map(|p| {
|
||||||
let mut entry = CatalogEntry::new(backend, p.name)
|
let mut entry = CatalogEntry::new(backend, p.path)
|
||||||
.scope("profile")
|
.scope(p.profile)
|
||||||
.installed(true);
|
.installed(true);
|
||||||
if !p.target.is_empty() {
|
if let Some(version) = p.version {
|
||||||
entry = entry.description(p.target);
|
entry = entry.version(version);
|
||||||
}
|
}
|
||||||
|
entry = entry.description(format!("Nix package `{}` ({})", p.name, p.store_path));
|
||||||
entry
|
entry
|
||||||
})
|
})
|
||||||
.collect();
|
.collect();
|
||||||
let note = format!(
|
let mut note = format!(
|
||||||
"{store_paths} store path(s) realised but not installed profiles; \
|
"active Nix profiles; {store_paths} additional store path(s) are realised \
|
||||||
Nix is a per-project/developer lane, so store contents are not listed as packages"
|
dependencies, not installed packages"
|
||||||
);
|
);
|
||||||
|
for additional in inventory.notes {
|
||||||
|
note.push_str("; ");
|
||||||
|
note.push_str(&additional);
|
||||||
|
}
|
||||||
SourceReport::ok(backend, note, entries)
|
SourceReport::ok(backend, note, entries)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -531,8 +555,14 @@ pub fn package_info(
|
||||||
filter: Option<Backend>,
|
filter: Option<Backend>,
|
||||||
) -> PackageInfoReport {
|
) -> PackageInfoReport {
|
||||||
let lanes = selected_lanes(filter);
|
let lanes = selected_lanes(filter);
|
||||||
let installed = chooser::installed_copies(exec, root, package);
|
// The filter is applied before any backend is queried, so a
|
||||||
let installed_portage = portage::installed_packages(root);
|
// 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 matches: Vec<PackageInfoMatch> = Vec::new();
|
||||||
let mut notes: Vec<String> = Vec::new();
|
let mut notes: Vec<String> = Vec::new();
|
||||||
|
|
||||||
|
|
@ -705,8 +735,9 @@ fn split_depend(value: &str) -> Vec<String> {
|
||||||
|
|
||||||
/// Which installed package owns a file path (Portage).
|
/// Which installed package owns a file path (Portage).
|
||||||
pub fn package_owners(exec: &Exec, root: &Path, path: &str) -> Result<String> {
|
pub fn package_owners(exec: &Exec, root: &Path, path: &str) -> Result<String> {
|
||||||
// Prefer `qfile` (portage-utils), then `equery belongs` (gentoolkit).
|
// Prefer `qfile` (portage-utils), then `equery belongs` (gentoolkit). The
|
||||||
if crate::exec::find_in_path("qfile").is_some() {
|
// 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])?;
|
let out = capture(exec, root, "qfile", &[path])?;
|
||||||
if !out.success {
|
if !out.success {
|
||||||
return Ok(format!("no installed package owns {path}"));
|
return Ok(format!("no installed package owns {path}"));
|
||||||
|
|
@ -716,7 +747,7 @@ pub fn package_owners(exec: &Exec, root: &Path, path: &str) -> Result<String> {
|
||||||
out.stdout_lossy().trim()
|
out.stdout_lossy().trim()
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
if crate::exec::find_in_path("equery").is_some() {
|
if crate::exec::tool_in_target(root, "equery") {
|
||||||
let out = capture(exec, root, "equery", &["belongs", path])?;
|
let out = capture(exec, root, "equery", &["belongs", path])?;
|
||||||
if !out.success {
|
if !out.success {
|
||||||
return Ok(format!("no installed package owns {path}"));
|
return Ok(format!("no installed package owns {path}"));
|
||||||
|
|
@ -734,53 +765,142 @@ pub fn package_owners(exec: &Exec, root: &Path, path: &str) -> Result<String> {
|
||||||
))
|
))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// 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.
|
/// 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(
|
pub fn package_dependencies(
|
||||||
exec: &Exec,
|
exec: &Exec,
|
||||||
root: &Path,
|
root: &Path,
|
||||||
package: &str,
|
package: &str,
|
||||||
reverse: bool,
|
reverse: bool,
|
||||||
) -> Result<String> {
|
) -> 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 {
|
if reverse {
|
||||||
if crate::exec::find_in_path("equery").is_none() {
|
for record in &installed {
|
||||||
return Err(ExecError::operation(
|
for dep in declared_dependencies(record) {
|
||||||
"sys",
|
if atom_matches(&dep.atom, package) && Some(&dep.atom) != self_atom.as_ref() {
|
||||||
"reverse dependencies",
|
let conditional = dep
|
||||||
"reverse-dependency inspection requires app-portage/gentoolkit (equery depends)",
|
.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)"
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
let out = capture(exec, root, "equery", &["depends", package])?;
|
return Ok(format!(
|
||||||
if !out.success {
|
"installed packages depending on {package}:\n {}",
|
||||||
return Ok(format!("no installed package depends on {package}"));
|
lines.join("\n ")
|
||||||
}
|
));
|
||||||
return Ok(out.stdout_lossy().trim().to_string());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
match capture(
|
// Forward: prefer the installed metadata; fall back to the tree via
|
||||||
exec,
|
// qdepends only when the package is not installed.
|
||||||
root,
|
let deps: Vec<(String, Option<String>, bool)> =
|
||||||
"emerge",
|
if let Some(record) = installed.iter().find(|p| atom_matches(&p.atom, package)) {
|
||||||
&["--pretend", "--quiet", "--color=n", "--", package],
|
declared_dependencies(record)
|
||||||
) {
|
.into_iter()
|
||||||
Ok(out) if out.success => {
|
.filter(|d| Some(&d.atom) != self_atom.as_ref())
|
||||||
let plan = phoebus_core::effects::parse_emerge_pretend(&out.stdout_lossy());
|
.map(|d| (d.raw, d.condition, d.negative))
|
||||||
let deps: Vec<String> = plan.effects.iter().map(|e| e.target.clone()).collect();
|
.collect()
|
||||||
if deps.is_empty() {
|
} else if crate::exec::tool_in_target(root, "qdepends") {
|
||||||
Ok(format!("{package} has no resolved dependencies"))
|
let out = capture(exec, root, "qdepends", &["-Q", "--", package])?;
|
||||||
} else {
|
if !out.success {
|
||||||
Ok(format!("{package} depends on:\n {}", deps.join("\n ")))
|
return Err(ExecError::operation(
|
||||||
}
|
|
||||||
}
|
|
||||||
Ok(out) => Ok(format!(
|
|
||||||
"could not resolve dependencies for {package}: {}",
|
|
||||||
stderr_tail(&out.stderr_lossy())
|
|
||||||
)),
|
|
||||||
Err(e) => Err(ExecError::operation(
|
|
||||||
"sys",
|
"sys",
|
||||||
"dependencies",
|
"dependencies",
|
||||||
format!("could not resolve dependencies for {package}: {e}"),
|
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).
|
/// Remove packages no longer required by any installed package (Portage).
|
||||||
|
|
@ -825,6 +945,11 @@ pub fn depclean(exec: &Exec, root: &Path) -> Result<String> {
|
||||||
|
|
||||||
/// Remove unreferenced package caches / store paths. Never removes an
|
/// Remove unreferenced package caches / store paths. Never removes an
|
||||||
/// installed package.
|
/// installed package.
|
||||||
|
///
|
||||||
|
/// Every cleaner's outcome is preserved: a cleaner that ran and failed makes
|
||||||
|
/// the whole action fail (with the 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>) -> Result<String> {
|
pub fn clean_cache(exec: &Exec, root: &Path, filter: Option<Backend>) -> Result<String> {
|
||||||
let lanes: Vec<Backend> = match filter {
|
let lanes: Vec<Backend> = match filter {
|
||||||
Some(backend) => vec![backend],
|
Some(backend) => vec![backend],
|
||||||
|
|
@ -832,56 +957,79 @@ pub fn clean_cache(exec: &Exec, root: &Path, filter: Option<Backend>) -> Result<
|
||||||
};
|
};
|
||||||
let mut report = String::new();
|
let mut report = String::new();
|
||||||
report.push_str("cache cleanup (installed packages are never removed)\n");
|
report.push_str("cache cleanup (installed packages are never removed)\n");
|
||||||
|
let mut completed = 0usize;
|
||||||
|
let mut failed = false;
|
||||||
|
|
||||||
for lane in lanes {
|
for lane in lanes {
|
||||||
match lane {
|
if lane.is_portage() {
|
||||||
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => {
|
let mut attempted = false;
|
||||||
report.push_str(&clean_portage_cache(exec, root));
|
for (cleaner, _, destructive_args) in crate::actions::portage_cleaners(root) {
|
||||||
|
attempted = true;
|
||||||
|
match run_mut(
|
||||||
|
exec,
|
||||||
|
root,
|
||||||
|
cleaner,
|
||||||
|
&destructive_args
|
||||||
|
.iter()
|
||||||
|
.map(|s| s.as_str())
|
||||||
|
.collect::<Vec<_>>(),
|
||||||
|
) {
|
||||||
|
Ok(()) => {
|
||||||
|
completed += 1;
|
||||||
|
report.push_str(&format!(" [portage] {cleaner} completed\n"));
|
||||||
}
|
}
|
||||||
Backend::Nix => {
|
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 {
|
||||||
if !nix::installed(root) {
|
if !nix::installed(root) {
|
||||||
report.push_str(" [nix] unavailable: Nix is not installed\n");
|
report.push_str(" [nix] unavailable: Nix is not installed\n");
|
||||||
} else {
|
} else {
|
||||||
nix::gc(exec, root)?;
|
match nix::gc(exec, root) {
|
||||||
report
|
|
||||||
.push_str(" [nix] unreferenced store paths collected (nix-store --gc)\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
other => report.push_str(&format!(
|
|
||||||
" [{}] unsupported: this lane has no package cache to clean\n",
|
|
||||||
other.as_str()
|
|
||||||
)),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Ok(report)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn clean_portage_cache(exec: &Exec, root: &Path) -> String {
|
|
||||||
let mut out = String::new();
|
|
||||||
let mut cleaned = false;
|
|
||||||
if crate::exec::find_in_path("eclean-dist").is_some() {
|
|
||||||
match run_mut(exec, root, "eclean-dist", &["-d"]) {
|
|
||||||
Ok(()) => {
|
Ok(()) => {
|
||||||
out.push_str(" [portage] distfiles cleaned (eclean-dist -d)\n");
|
completed += 1;
|
||||||
cleaned = true;
|
report.push_str(
|
||||||
}
|
" [nix] unreferenced store paths collected (nix-store --gc)\n",
|
||||||
Err(e) => out.push_str(&format!(" [portage] distfile cleanup failed: {e}\n")),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if crate::exec::find_in_path("eclean-pkg").is_some() {
|
|
||||||
match run_mut(exec, root, "eclean-pkg", &["-d"]) {
|
|
||||||
Ok(()) => {
|
|
||||||
out.push_str(" [portage] binary package cache cleaned (eclean-pkg -d)\n");
|
|
||||||
cleaned = true;
|
|
||||||
}
|
|
||||||
Err(e) => out.push_str(&format!(" [portage] package cache cleanup failed: {e}\n")),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if !cleaned {
|
|
||||||
out.push_str(
|
|
||||||
" [portage] unsupported: install app-portage/gentoolkit (eclean-dist / eclean-pkg)\n",
|
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
out
|
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)
|
||||||
}
|
}
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
|
|
@ -890,81 +1038,226 @@ fn clean_portage_cache(exec: &Exec, root: &Path) -> String {
|
||||||
|
|
||||||
/// Check for updates across the supported lanes, optionally restricted to one.
|
/// Check for updates across the supported lanes, optionally restricted to one.
|
||||||
pub fn check_updates(exec: &Exec, root: &Path, filter: Option<Backend>) -> UnifiedUpdateOverview {
|
pub fn check_updates(exec: &Exec, root: &Path, filter: Option<Backend>) -> UnifiedUpdateOverview {
|
||||||
let mut overview = crate::update::check_unified_updates(exec, root);
|
// The filter is applied before any backend is queried, not merely to the
|
||||||
if let Some(filter) = filter {
|
// displayed results.
|
||||||
overview.sources.retain(|s| lane_matches(s.backend, filter));
|
crate::update::check_unified_updates_filtered(exec, root, filter)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The exact Flatpak applications with an available update. Each is updated by
|
||||||
|
/// ref so execution can never become an unrestricted update-all.
|
||||||
|
fn flatpak_update_ids(exec: &Exec, root: &Path) -> Result<Vec<String>> {
|
||||||
|
let out = capture(
|
||||||
|
exec,
|
||||||
|
root,
|
||||||
|
"flatpak",
|
||||||
|
&[
|
||||||
|
"remote-ls",
|
||||||
|
"--updates",
|
||||||
|
"--columns=application,version,branch",
|
||||||
|
],
|
||||||
|
)?;
|
||||||
|
if !out.success {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"apply flatpak updates",
|
||||||
|
format!(
|
||||||
|
"flatpak remote-ls failed: {}",
|
||||||
|
stderr_tail(&out.stderr_lossy())
|
||||||
|
),
|
||||||
|
));
|
||||||
}
|
}
|
||||||
overview
|
let mut ids = Vec::new();
|
||||||
|
for line in out.stdout_lossy().lines() {
|
||||||
|
if let Some(id) = line.split_whitespace().next() {
|
||||||
|
if !id.is_empty() {
|
||||||
|
ids.push(id.to_string());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ids.sort();
|
||||||
|
ids.dedup();
|
||||||
|
Ok(ids)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The exact snaps with an available update.
|
||||||
|
fn snap_update_names(exec: &Exec) -> Result<Vec<String>> {
|
||||||
|
let out = exec.runner.execute(
|
||||||
|
&CommandSpec::new("sys", "apply snap updates", "snap").args(["refresh", "--list"]),
|
||||||
|
)?;
|
||||||
|
if !out.success {
|
||||||
|
return Err(ExecError::operation(
|
||||||
|
"sys",
|
||||||
|
"apply snap updates",
|
||||||
|
format!(
|
||||||
|
"snap refresh --list failed: {}",
|
||||||
|
stderr_tail(&out.stderr_lossy())
|
||||||
|
),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
let mut names = Vec::new();
|
||||||
|
for line in out.stdout_lossy().lines().skip(1) {
|
||||||
|
if let Some(name) = line.split_whitespace().next() {
|
||||||
|
if !name.is_empty() {
|
||||||
|
names.push(name.to_string());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
names.sort();
|
||||||
|
names.dedup();
|
||||||
|
Ok(names)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Apply updates across the supported lanes and report a truthful per-source
|
/// Apply updates across the supported lanes and report a truthful per-source
|
||||||
/// outcome. Sources that require manual or project-specific updates are
|
/// outcome. Each per-source update is constrained to the exact identities
|
||||||
/// explained, never reported as updated. If any attempted source fails, the
|
/// resolved immediately before execution; a source that ran and failed is
|
||||||
/// whole action fails with the per-source report.
|
/// reported as failed (with partial success preserved), and the whole action
|
||||||
|
/// then fails. Sources with no safe system-level transaction are refused.
|
||||||
pub fn apply_updates(exec: &Exec, root: &Path, filter: Option<Backend>) -> Result<String> {
|
pub fn apply_updates(exec: &Exec, root: &Path, filter: Option<Backend>) -> Result<String> {
|
||||||
let lanes: Vec<Backend> = match filter {
|
let lanes: Vec<Backend> = match filter {
|
||||||
Some(backend) => vec![backend],
|
Some(backend) => vec![backend],
|
||||||
None => all_lanes(),
|
None => vec![Backend::PortageSource, Backend::Flatpak, Backend::Snap],
|
||||||
};
|
};
|
||||||
let mut report = String::new();
|
let mut report = String::new();
|
||||||
report.push_str("update application (per-source outcome)\n");
|
report.push_str("update application (per-source outcome)\n");
|
||||||
let mut failed = false;
|
let mut failed = false;
|
||||||
|
let mut completed = 0usize;
|
||||||
|
|
||||||
for lane in lanes {
|
for lane in lanes {
|
||||||
match lane {
|
if lane.is_portage() {
|
||||||
Backend::PortageSource | Backend::PortageBinary | Backend::PortageVendor => {
|
|
||||||
match crate::actions::portage_world_update(exec, root) {
|
match crate::actions::portage_world_update(exec, root) {
|
||||||
Ok(()) => report.push_str(" [portage] updated (emerge -uDN @world)\n"),
|
Ok(()) => {
|
||||||
|
completed += 1;
|
||||||
|
report.push_str(" [portage] updated (emerge -uDN @world)\n");
|
||||||
|
}
|
||||||
Err(e) => {
|
Err(e) => {
|
||||||
failed = true;
|
failed = true;
|
||||||
report.push_str(&format!(" [portage] failed: {e}\n"));
|
report.push_str(&format!(" [portage] failed: {e}\n"));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
} else if lane == Backend::Flatpak {
|
||||||
Backend::Flatpak => {
|
|
||||||
if !flatpak_available(exec, root) {
|
if !flatpak_available(exec, root) {
|
||||||
report.push_str(" [flatpak] unavailable: the Flatpak client is not present\n");
|
if filter.is_some() {
|
||||||
|
failed = true;
|
||||||
|
report.push_str(
|
||||||
|
" [flatpak] failed: the Flatpak client is not available in the target\n",
|
||||||
|
);
|
||||||
} else {
|
} else {
|
||||||
match run_mut(exec, root, "flatpak", &["update", "-y"]) {
|
report.push_str(" [flatpak] unavailable: the Flatpak client is not present\n");
|
||||||
Ok(()) => report.push_str(" [flatpak] updated (flatpak update -y)\n"),
|
}
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
match flatpak_update_ids(exec, root) {
|
||||||
|
Ok(ids) if ids.is_empty() => {
|
||||||
|
completed += 1;
|
||||||
|
report.push_str(" [flatpak] no updates available\n");
|
||||||
|
}
|
||||||
|
Ok(ids) => {
|
||||||
|
let mut lane_failed = false;
|
||||||
|
for id in &ids {
|
||||||
|
match run_mut(exec, root, "flatpak", &["update", "-y", "--", id]) {
|
||||||
|
Ok(()) => {}
|
||||||
|
Err(e) => {
|
||||||
|
lane_failed = true;
|
||||||
|
report.push_str(&format!(" [flatpak] {id} failed: {e}\n"));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if lane_failed {
|
||||||
|
failed = true;
|
||||||
|
} else {
|
||||||
|
completed += 1;
|
||||||
|
report.push_str(&format!(
|
||||||
|
" [flatpak] updated {} reviewed application(s): {}\n",
|
||||||
|
ids.len(),
|
||||||
|
ids.join(", ")
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
Err(e) => {
|
Err(e) => {
|
||||||
failed = true;
|
failed = true;
|
||||||
report.push_str(&format!(" [flatpak] failed: {e}\n"));
|
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;
|
||||||
}
|
}
|
||||||
}
|
|
||||||
Backend::Snap => {
|
|
||||||
let usable = matches!(snap::status(exec), Ok(s) if s.usable());
|
let usable = matches!(snap::status(exec), Ok(s) if s.usable());
|
||||||
if !usable {
|
if !usable {
|
||||||
report.push_str(" [snap] unavailable: snapd is not installed or active\n");
|
if filter.is_some() {
|
||||||
|
failed = true;
|
||||||
|
report.push_str(" [snap] failed: snapd is not installed or active\n");
|
||||||
} else {
|
} else {
|
||||||
match snap::refresh(exec, None) {
|
report.push_str(" [snap] unavailable: snapd is not installed or active\n");
|
||||||
Ok(_) => report.push_str(" [snap] refreshed (snap refresh)\n"),
|
}
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
match snap_update_names(exec) {
|
||||||
|
Ok(names) if names.is_empty() => {
|
||||||
|
completed += 1;
|
||||||
|
report.push_str(" [snap] no updates available\n");
|
||||||
|
}
|
||||||
|
Ok(names) => {
|
||||||
|
let mut lane_failed = false;
|
||||||
|
for name in &names {
|
||||||
|
match snap::refresh(exec, Some(name)) {
|
||||||
|
Ok(_) => {}
|
||||||
|
Err(e) => {
|
||||||
|
lane_failed = true;
|
||||||
|
report.push_str(&format!(" [snap] {name} failed: {e}\n"));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if lane_failed {
|
||||||
|
failed = true;
|
||||||
|
} else {
|
||||||
|
completed += 1;
|
||||||
|
report.push_str(&format!(
|
||||||
|
" [snap] refreshed {} reviewed snap(s): {}\n",
|
||||||
|
names.len(),
|
||||||
|
names.join(", ")
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
Err(e) => {
|
Err(e) => {
|
||||||
failed = true;
|
failed = true;
|
||||||
report.push_str(&format!(" [snap] failed: {e}\n"));
|
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
|
||||||
Backend::AppImage => report.push_str(
|
// transaction is refused, not silently reported as "updated".
|
||||||
" [appimage] manual: managed AppImages have no update repository; \
|
return Err(ExecError::operation(
|
||||||
re-acquire with a pinned URL + SHA-256 (appimage_update)\n",
|
"sys",
|
||||||
),
|
"apply updates",
|
||||||
Backend::Nix => report.push_str(
|
format!(
|
||||||
" [nix] project-specific: Nix packages are declarative/pinned; \
|
"{} updates cannot be applied safely by `sys` from the system; {}",
|
||||||
update them in their project or profile, not from the system\n",
|
lane.as_str(),
|
||||||
),
|
crate::actions::update_limitation(lane)
|
||||||
Backend::CustomEbuild => report.push_str(
|
|
||||||
" [custom-ebuild] project-specific: rebuild a staged ebuild through Portage\n",
|
|
||||||
),
|
),
|
||||||
|
));
|
||||||
|
} else {
|
||||||
|
report.push_str(&format!(
|
||||||
|
" [{}] not applied: {}\n",
|
||||||
|
lane.as_str(),
|
||||||
|
crate::actions::update_limitation(lane)
|
||||||
|
));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if failed {
|
if failed {
|
||||||
return Err(ExecError::operation("sys", "apply updates", report));
|
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)
|
Ok(report)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -1184,23 +1477,90 @@ mod tests {
|
||||||
assert_eq!(runner2.recorded().len(), 2);
|
assert_eq!(runner2.recorded().len(), 2);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
fn install_fake_tool(root: &Path, name: &str) {
|
||||||
fn clean_cache_reports_unsupported_without_a_cleaner() {
|
use std::os::unix::fs::PermissionsExt;
|
||||||
// A temp dir with neither eclean-dist nor eclean-pkg on PATH.
|
let bin = root.join("usr/bin");
|
||||||
let runner = RecordingRunner::new();
|
std::fs::create_dir_all(&bin).unwrap();
|
||||||
let exec = make_exec(runner);
|
let tool = bin.join(name);
|
||||||
let out = clean_cache(&exec, Path::new(&exec.root), Some(Backend::PortageSource)).unwrap();
|
std::fs::write(&tool, "#!/bin/sh\n").unwrap();
|
||||||
assert!(out.contains("installed packages are never removed"));
|
std::fs::set_permissions(&tool, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||||
assert!(out.contains("unsupported") || out.contains("cleaned"));
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn apply_updates_reports_manual_and_project_lanes_without_claiming_success() {
|
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 runner = RecordingRunner::new();
|
||||||
let exec = make_exec(runner);
|
let exec = make_exec(runner);
|
||||||
let out = apply_updates(&exec, Path::new(&exec.root), Some(Backend::AppImage)).unwrap();
|
let err =
|
||||||
assert!(out.contains("manual"));
|
clean_cache(&exec, Path::new(&exec.root), Some(Backend::PortageSource)).unwrap_err();
|
||||||
assert!(!out.contains("updated"));
|
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)).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)).unwrap_err();
|
||||||
|
let text = err.to_string();
|
||||||
|
assert!(text.contains("cannot be applied safely"), "{text}");
|
||||||
|
assert!(text.contains("pinned URL"), "{text}");
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
|
@ -1213,6 +1573,91 @@ mod tests {
|
||||||
assert!(err.to_string().contains("[portage] failed"));
|
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());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn flatpak_update_effects_bind_exact_identities_and_versions() {
|
||||||
|
use crate::command::{CommandOutput, CommandSpec, ProcessRunner};
|
||||||
|
struct Fp;
|
||||||
|
impl ProcessRunner for Fp {
|
||||||
|
fn execute(&self, spec: &CommandSpec) -> Result<CommandOutput> {
|
||||||
|
let ok = |s: &str| CommandOutput {
|
||||||
|
status: 0,
|
||||||
|
success: true,
|
||||||
|
stdout: s.as_bytes().to_vec(),
|
||||||
|
stderr: Vec::new(),
|
||||||
|
duration: std::time::Duration::from_millis(1),
|
||||||
|
};
|
||||||
|
let flatpak = spec.args.iter().any(|a| a == "flatpak");
|
||||||
|
if flatpak && spec.args.iter().any(|a| a == "--version") {
|
||||||
|
return Ok(ok("Flatpak 1.18\n"));
|
||||||
|
}
|
||||||
|
if flatpak && spec.args.iter().any(|a| a == "remote-ls") {
|
||||||
|
return Ok(ok(
|
||||||
|
"org.mozilla.firefox 129 stable\norg.gnome.Calc 46 stable\n",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
if flatpak && spec.args.iter().any(|a| a == "list") {
|
||||||
|
return Ok(ok("org.mozilla.firefox 128\norg.gnome.Calc 45\n"));
|
||||||
|
}
|
||||||
|
Ok(ok(""))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let path = tempfile::tempdir().unwrap().keep();
|
||||||
|
let logger =
|
||||||
|
crate::log::Logger::open(path.join("l.log"), phoebus_core::Redactor::new(), false);
|
||||||
|
let exec = Exec::new(Box::new(Fp), logger, false, path.join("root"), path);
|
||||||
|
let plan = crate::actions::resolve_effects(
|
||||||
|
&exec,
|
||||||
|
&phoebus_core::action::SystemAction::ApplyUpdates {
|
||||||
|
backend: Some(Backend::Flatpak),
|
||||||
|
},
|
||||||
|
&exec.root,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
assert!(plan.established);
|
||||||
|
assert!(
|
||||||
|
plan.effects
|
||||||
|
.iter()
|
||||||
|
.any(|e| e.target == "org.mozilla.firefox-129"
|
||||||
|
&& e.previous.as_deref() == Some("128"))
|
||||||
|
);
|
||||||
|
assert!(plan
|
||||||
|
.effects
|
||||||
|
.iter()
|
||||||
|
.any(|e| e.target == "org.gnome.Calc-46" && e.previous.as_deref() == Some("45")));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[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)).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]
|
#[test]
|
||||||
fn parse_flatpak_lines_handles_tabs_and_spaces() {
|
fn parse_flatpak_lines_handles_tabs_and_spaces() {
|
||||||
let rows =
|
let rows =
|
||||||
|
|
@ -1232,15 +1677,59 @@ mod tests {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn package_dependencies_reports_forward_deps() {
|
fn package_dependencies_uses_installed_metadata_not_an_install_plan() {
|
||||||
let runner = RecordingRunner::new();
|
let runner = RecordingRunner::new();
|
||||||
runner.set_response(
|
|
||||||
"emerge",
|
|
||||||
ok("Calculating dependencies... done!\n[ebuild N ] app-editors/vim-core-9.1.0\n\nTotal: 1 package\n"),
|
|
||||||
);
|
|
||||||
let exec = make_exec(runner);
|
let exec = make_exec(runner);
|
||||||
let out = package_dependencies(&exec, Path::new("/"), "vim", false).unwrap();
|
let root = Path::new(&exec.root);
|
||||||
assert!(out.contains("app-editors/vim-core-9.1.0"), "{out}");
|
// `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}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[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]
|
#[test]
|
||||||
|
|
|
||||||
|
|
@ -166,20 +166,48 @@ use phoebus_core::update::{PackageUpdateItem, SourceUpdateOverview, UnifiedUpdat
|
||||||
/// Check updates across all supported package sources (Portage, Flatpak, Snap, AppImage, Nix)
|
/// Check updates across all supported package sources (Portage, Flatpak, Snap, AppImage, Nix)
|
||||||
/// and report a unified, truthful overview.
|
/// and report a unified, truthful overview.
|
||||||
pub fn check_unified_updates(exec: &Exec, root: &Path) -> UnifiedUpdateOverview {
|
pub fn check_unified_updates(exec: &Exec, root: &Path) -> UnifiedUpdateOverview {
|
||||||
|
check_unified_updates_filtered(exec, root, None)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether a lane is covered by an optional source filter.
|
||||||
|
fn lane_selected(filter: Option<Backend>, lane: Backend) -> bool {
|
||||||
|
match filter {
|
||||||
|
Some(f) => f == lane || (f.is_portage() && lane.is_portage()),
|
||||||
|
None => true,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Like [`check_unified_updates`], but a lane filter prevents querying any
|
||||||
|
/// other backend at all, so a constrained check never probes a foreign lane.
|
||||||
|
pub fn check_unified_updates_filtered(
|
||||||
|
exec: &Exec,
|
||||||
|
root: &Path,
|
||||||
|
filter: Option<Backend>,
|
||||||
|
) -> UnifiedUpdateOverview {
|
||||||
let mut sources = Vec::new();
|
let mut sources = Vec::new();
|
||||||
|
|
||||||
// 1. Portage
|
// 1. Portage. The check runs against the intended target: directly for the
|
||||||
|
// running root, or inside the target chroot for an alternate root.
|
||||||
|
if lane_selected(filter, Backend::PortageSource) {
|
||||||
let mut portage_items = Vec::new();
|
let mut portage_items = Vec::new();
|
||||||
let portage_res = exec.runner.execute(
|
let portage_args: Vec<String> = [
|
||||||
&crate::command::CommandSpec::new("sys", "check portage updates", "emerge").args([
|
|
||||||
"--pretend",
|
"--pretend",
|
||||||
"--update",
|
"--update",
|
||||||
"--deep",
|
"--deep",
|
||||||
"--newuse",
|
"--newuse",
|
||||||
"--color=n",
|
"--color=n",
|
||||||
"@world",
|
"@world",
|
||||||
]),
|
]
|
||||||
);
|
.iter()
|
||||||
|
.map(|s| s.to_string())
|
||||||
|
.collect();
|
||||||
|
let portage_res = exec.runner.execute(&crate::actions::target_spec(
|
||||||
|
root,
|
||||||
|
"sys",
|
||||||
|
"check portage updates",
|
||||||
|
"emerge",
|
||||||
|
&portage_args,
|
||||||
|
));
|
||||||
let mut portage_note = "native OS packages".to_string();
|
let mut portage_note = "native OS packages".to_string();
|
||||||
if let Ok(res) = portage_res {
|
if let Ok(res) = portage_res {
|
||||||
if res.success {
|
if res.success {
|
||||||
|
|
@ -206,17 +234,30 @@ pub fn check_unified_updates(exec: &Exec, root: &Path) -> UnifiedUpdateOverview
|
||||||
supported: true,
|
supported: true,
|
||||||
note: portage_note,
|
note: portage_note,
|
||||||
});
|
});
|
||||||
|
}
|
||||||
|
|
||||||
// 2. Flatpak
|
// 2. Flatpak. Availability and the query refer to the target, so an
|
||||||
|
// alternate-root check never consults a host Flatpak installation.
|
||||||
|
if lane_selected(filter, Backend::Flatpak) {
|
||||||
let mut flatpak_items = Vec::new();
|
let mut flatpak_items = Vec::new();
|
||||||
let flatpak_supported = crate::exec::find_in_path("flatpak").is_some();
|
let flatpak_supported = crate::exec::tool_in_target(root, "flatpak");
|
||||||
let mut flatpak_note = "sandboxed desktop applications".to_string();
|
let mut flatpak_note = "sandboxed desktop applications".to_string();
|
||||||
if flatpak_supported {
|
if flatpak_supported {
|
||||||
let fp_res =
|
let fp_args: Vec<String> = [
|
||||||
exec.runner.execute(
|
"remote-ls",
|
||||||
&crate::command::CommandSpec::new("sys", "check flatpak updates", "flatpak")
|
"--updates",
|
||||||
.args(["remote-ls", "--updates", "--columns=application,version"]),
|
"--columns=application,version,branch",
|
||||||
);
|
]
|
||||||
|
.iter()
|
||||||
|
.map(|s| s.to_string())
|
||||||
|
.collect();
|
||||||
|
let fp_res = exec.runner.execute(&crate::actions::target_spec(
|
||||||
|
root,
|
||||||
|
"sys",
|
||||||
|
"check flatpak updates",
|
||||||
|
"flatpak",
|
||||||
|
&fp_args,
|
||||||
|
));
|
||||||
if let Ok(res) = fp_res {
|
if let Ok(res) = fp_res {
|
||||||
if res.success {
|
if res.success {
|
||||||
for line in res.stdout_lossy().lines() {
|
for line in res.stdout_lossy().lines() {
|
||||||
|
|
@ -245,10 +286,21 @@ pub fn check_unified_updates(exec: &Exec, root: &Path) -> UnifiedUpdateOverview
|
||||||
"flatpak is not installed".into()
|
"flatpak is not installed".into()
|
||||||
},
|
},
|
||||||
});
|
});
|
||||||
|
}
|
||||||
|
|
||||||
// 3. Snap
|
// 3. Snap. Snap acts on the running daemon; an alternate-root check must
|
||||||
|
// not consult (or claim) the host's snaps.
|
||||||
|
if lane_selected(filter, Backend::Snap) {
|
||||||
let mut snap_items = Vec::new();
|
let mut snap_items = Vec::new();
|
||||||
let snap_status = crate::snap::status(exec);
|
let snap_status = if root == Path::new("/") {
|
||||||
|
crate::snap::status(exec)
|
||||||
|
} else {
|
||||||
|
Ok(crate::snap::SnapdStatus {
|
||||||
|
client_present: false,
|
||||||
|
daemon_ready: false,
|
||||||
|
confinement: crate::snap::Confinement::None,
|
||||||
|
})
|
||||||
|
};
|
||||||
let snap_supported = matches!(snap_status, Ok(ref s) if s.usable());
|
let snap_supported = matches!(snap_status, Ok(ref s) if s.usable());
|
||||||
let snap_note = "snapd automatic refresh lane".to_string();
|
let snap_note = "snapd automatic refresh lane".to_string();
|
||||||
if snap_supported {
|
if snap_supported {
|
||||||
|
|
@ -282,8 +334,10 @@ pub fn check_unified_updates(exec: &Exec, root: &Path) -> UnifiedUpdateOverview
|
||||||
"snapd is not installed or active".into()
|
"snapd is not installed or active".into()
|
||||||
},
|
},
|
||||||
});
|
});
|
||||||
|
}
|
||||||
|
|
||||||
// 4. AppImage
|
// 4. AppImage
|
||||||
|
if lane_selected(filter, Backend::AppImage) {
|
||||||
let appimages = crate::appimage::list(root).unwrap_or_default();
|
let appimages = crate::appimage::list(root).unwrap_or_default();
|
||||||
sources.push(SourceUpdateOverview {
|
sources.push(SourceUpdateOverview {
|
||||||
backend: Backend::AppImage,
|
backend: Backend::AppImage,
|
||||||
|
|
@ -294,8 +348,10 @@ pub fn check_unified_updates(exec: &Exec, root: &Path) -> UnifiedUpdateOverview
|
||||||
appimages.len()
|
appimages.len()
|
||||||
),
|
),
|
||||||
});
|
});
|
||||||
|
}
|
||||||
|
|
||||||
// 5. Nix
|
// 5. Nix
|
||||||
|
if lane_selected(filter, Backend::Nix) {
|
||||||
let nix_installed = crate::nix::installed(root);
|
let nix_installed = crate::nix::installed(root);
|
||||||
sources.push(SourceUpdateOverview {
|
sources.push(SourceUpdateOverview {
|
||||||
backend: Backend::Nix,
|
backend: Backend::Nix,
|
||||||
|
|
@ -307,6 +363,7 @@ pub fn check_unified_updates(exec: &Exec, root: &Path) -> UnifiedUpdateOverview
|
||||||
"Nix is not installed".into()
|
"Nix is not installed".into()
|
||||||
},
|
},
|
||||||
});
|
});
|
||||||
|
}
|
||||||
|
|
||||||
// Reboot check: check /var/run/reboot-required
|
// Reboot check: check /var/run/reboot-required
|
||||||
let reboot_required = root.join("var/run/reboot-required").exists();
|
let reboot_required = root.join("var/run/reboot-required").exists();
|
||||||
|
|
|
||||||
|
|
@ -1152,6 +1152,45 @@ fn constrain_action(
|
||||||
SystemAction::CleanCache { .. } => SystemAction::CleanCache {
|
SystemAction::CleanCache { .. } => SystemAction::CleanCache {
|
||||||
backend: Some(constraint),
|
backend: Some(constraint),
|
||||||
},
|
},
|
||||||
|
// Optional-backend discovery and selection requests must be *rewritten*
|
||||||
|
// to the constraint, not merely filtered afterwards: otherwise the
|
||||||
|
// resolver would still query every lane before the results are
|
||||||
|
// discarded.
|
||||||
|
SystemAction::DiscoverCandidates {
|
||||||
|
query,
|
||||||
|
kind,
|
||||||
|
gui,
|
||||||
|
requires_sandbox,
|
||||||
|
..
|
||||||
|
} => SystemAction::DiscoverCandidates {
|
||||||
|
query,
|
||||||
|
kind,
|
||||||
|
backend: Some(constraint),
|
||||||
|
gui,
|
||||||
|
requires_sandbox,
|
||||||
|
},
|
||||||
|
SystemAction::ChoosePackage {
|
||||||
|
name,
|
||||||
|
kind,
|
||||||
|
gui,
|
||||||
|
requires_sandbox,
|
||||||
|
..
|
||||||
|
} => SystemAction::ChoosePackage {
|
||||||
|
name,
|
||||||
|
kind,
|
||||||
|
backend: Some(constraint),
|
||||||
|
gui,
|
||||||
|
requires_sandbox,
|
||||||
|
},
|
||||||
|
// `InspectInstallation` has no lane field but probes every lane; under
|
||||||
|
// an explicit constraint it is refused rather than leaking other lanes.
|
||||||
|
SystemAction::InspectInstallation { .. } => {
|
||||||
|
return Err(format!(
|
||||||
|
"inspect_installation spans every package lane, but this request was constrained \
|
||||||
|
to {}; use a lane-specific inventory instead",
|
||||||
|
constraint.as_str()
|
||||||
|
));
|
||||||
|
}
|
||||||
other => {
|
other => {
|
||||||
if let Some(own) = other.backend() {
|
if let Some(own) = other.backend() {
|
||||||
let matches = own == constraint || (own.is_portage() && constraint.is_portage());
|
let matches = own == constraint || (own.is_portage() && constraint.is_portage());
|
||||||
|
|
@ -2472,11 +2511,10 @@ mod tests {
|
||||||
return Ok(ok("installed\n".into()));
|
return Ok(ok("installed\n".into()));
|
||||||
}
|
}
|
||||||
let installed = self.installed.load(std::sync::atomic::Ordering::SeqCst);
|
let installed = self.installed.load(std::sync::atomic::Ordering::SeqCst);
|
||||||
match spec.program.as_str() {
|
let is_flatpak = spec.program == "flatpak" || spec.args.iter().any(|a| a == "flatpak");
|
||||||
"flatpak" if spec.args.iter().any(|a| a == "search") => {
|
if is_flatpak && spec.args.iter().any(|a| a == "search") {
|
||||||
Ok(ok("org.mozilla.firefox 128\n".into()))
|
Ok(ok("org.mozilla.firefox 128\n".into()))
|
||||||
}
|
} else if is_flatpak && spec.args.iter().any(|a| a == "list") {
|
||||||
"flatpak" if spec.args.iter().any(|a| a == "list") => {
|
|
||||||
if !installed {
|
if !installed {
|
||||||
return Ok(ok(String::new()));
|
return Ok(ok(String::new()));
|
||||||
}
|
}
|
||||||
|
|
@ -2487,8 +2525,8 @@ mod tests {
|
||||||
} else {
|
} else {
|
||||||
Ok(ok("org.mozilla.firefox Firefox 128\n".into()))
|
Ok(ok("org.mozilla.firefox Firefox 128\n".into()))
|
||||||
}
|
}
|
||||||
}
|
} else {
|
||||||
_ => Ok(ok(String::new())),
|
Ok(ok(String::new()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -2502,6 +2540,17 @@ mod tests {
|
||||||
Exec::new(runner, logger, false, root.to_path_buf(), temp)
|
Exec::new(runner, logger, false, root.to_path_buf(), temp)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// A target that actually has a Flatpak client, so lane availability
|
||||||
|
/// resolves from the target rather than the host.
|
||||||
|
fn install_fake_flatpak(root: &Path) {
|
||||||
|
use std::os::unix::fs::PermissionsExt;
|
||||||
|
let bin = root.join("usr/bin");
|
||||||
|
std::fs::create_dir_all(&bin).unwrap();
|
||||||
|
let flatpak = bin.join("flatpak");
|
||||||
|
std::fs::write(&flatpak, "#!/bin/sh\n").unwrap();
|
||||||
|
std::fs::set_permissions(&flatpak, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn install_verification_failure_finishes_the_transaction_as_failed() {
|
fn install_verification_failure_finishes_the_transaction_as_failed() {
|
||||||
let root = tempdir().unwrap();
|
let root = tempdir().unwrap();
|
||||||
|
|
@ -2515,6 +2564,7 @@ mod tests {
|
||||||
);
|
);
|
||||||
let store = PlanStore::with_dir(tempdir().unwrap().keep());
|
let store = PlanStore::with_dir(tempdir().unwrap().keep());
|
||||||
let approvals = ApprovalLedger::with_dir(tempdir().unwrap().keep());
|
let approvals = ApprovalLedger::with_dir(tempdir().unwrap().keep());
|
||||||
|
install_fake_flatpak(root.path());
|
||||||
|
|
||||||
let mut request = InstallRequest::new("firefox");
|
let mut request = InstallRequest::new("firefox");
|
||||||
request.backend = Some(Backend::Flatpak);
|
request.backend = Some(Backend::Flatpak);
|
||||||
|
|
@ -2573,6 +2623,7 @@ mod tests {
|
||||||
);
|
);
|
||||||
let store = PlanStore::with_dir(tempdir().unwrap().keep());
|
let store = PlanStore::with_dir(tempdir().unwrap().keep());
|
||||||
let approvals = ApprovalLedger::with_dir(tempdir().unwrap().keep());
|
let approvals = ApprovalLedger::with_dir(tempdir().unwrap().keep());
|
||||||
|
install_fake_flatpak(root.path());
|
||||||
let mut request = InstallRequest::new("firefox");
|
let mut request = InstallRequest::new("firefox");
|
||||||
request.backend = Some(Backend::Flatpak);
|
request.backend = Some(Backend::Flatpak);
|
||||||
let plan = plan_legacy_install(&store, &exec, root.path(), &request).unwrap();
|
let plan = plan_legacy_install(&store, &exec, root.path(), &request).unwrap();
|
||||||
|
|
@ -4005,4 +4056,89 @@ mod tests {
|
||||||
}]
|
}]
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn constrain_action_rewrites_optional_backend_discovery_before_querying() {
|
||||||
|
let discover = constrain_action(
|
||||||
|
SystemAction::DiscoverCandidates {
|
||||||
|
query: "chrome".into(),
|
||||||
|
kind: None,
|
||||||
|
backend: None,
|
||||||
|
gui: false,
|
||||||
|
requires_sandbox: false,
|
||||||
|
},
|
||||||
|
Backend::Flatpak,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
assert_eq!(discover.backend(), Some(Backend::Flatpak));
|
||||||
|
|
||||||
|
let choose = constrain_action(
|
||||||
|
SystemAction::ChoosePackage {
|
||||||
|
name: "chrome".into(),
|
||||||
|
kind: None,
|
||||||
|
backend: None,
|
||||||
|
gui: false,
|
||||||
|
requires_sandbox: false,
|
||||||
|
},
|
||||||
|
Backend::Flatpak,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
assert_eq!(choose.backend(), Some(Backend::Flatpak));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn constrain_action_refuses_portage_only_actions_under_another_lane() {
|
||||||
|
for action in [
|
||||||
|
SystemAction::RemovePackage {
|
||||||
|
atom: "www-client/firefox".into(),
|
||||||
|
},
|
||||||
|
SystemAction::UpdateSystem,
|
||||||
|
SystemAction::Depclean,
|
||||||
|
SystemAction::PackageOwners {
|
||||||
|
path: "/usr/bin/vim".into(),
|
||||||
|
},
|
||||||
|
SystemAction::PackageDependencies {
|
||||||
|
package: "vim".into(),
|
||||||
|
reverse: false,
|
||||||
|
},
|
||||||
|
SystemAction::InstallPackage {
|
||||||
|
atom: "vim".into(),
|
||||||
|
binary: None,
|
||||||
|
},
|
||||||
|
SystemAction::InspectPackage { atom: "vim".into() },
|
||||||
|
] {
|
||||||
|
let err = constrain_action(action.clone(), Backend::Flatpak).unwrap_err();
|
||||||
|
assert!(
|
||||||
|
err.contains("constrained") || err.contains("targets the"),
|
||||||
|
"{action:?} -> {err}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn constrain_action_refuses_cross_lane_installation_inspection() {
|
||||||
|
let err = constrain_action(
|
||||||
|
SystemAction::InspectInstallation {
|
||||||
|
application: "firefox".into(),
|
||||||
|
},
|
||||||
|
Backend::Flatpak,
|
||||||
|
)
|
||||||
|
.unwrap_err();
|
||||||
|
assert!(err.contains("spans every package lane"), "{err}");
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn constrain_action_allows_spanning_non_package_actions() {
|
||||||
|
for action in [
|
||||||
|
SystemAction::History,
|
||||||
|
SystemAction::RollbackStatus,
|
||||||
|
SystemAction::EnableService {
|
||||||
|
name: "sshd".into(),
|
||||||
|
},
|
||||||
|
] {
|
||||||
|
assert!(constrain_action(action, Backend::Flatpak).is_ok());
|
||||||
|
}
|
||||||
|
// A Portage-only action is allowed when the constraint is Portage.
|
||||||
|
assert!(constrain_action(SystemAction::UpdateSystem, Backend::PortageSource).is_ok());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -167,6 +167,25 @@ run_expect_zero_contains info-legacy "Package information" --legacy info bash
|
||||||
run_expect_zero_contains updates-legacy "Unified Update Overview" --legacy updates
|
run_expect_zero_contains updates-legacy "Unified Update Overview" --legacy updates
|
||||||
run_expect_zero_contains json-search-legacy "Package catalogue" --legacy --action '{"action":"search_packages","query":"firefox"}'
|
run_expect_zero_contains json-search-legacy "Package catalogue" --legacy --action '{"action":"search_packages","query":"firefox"}'
|
||||||
|
|
||||||
|
# Regression: an alternate root must never be answered by the host's Snap lane.
|
||||||
|
AltRoot="$WORK/altroot"
|
||||||
|
mkdir -p "$AltRoot"
|
||||||
|
run_expect_zero_contains snap-alternate-root "alternate root" \
|
||||||
|
--root "$AltRoot" --legacy search firefox --snap
|
||||||
|
# Regression: Nix inventory enumerates active profiles, never host commands.
|
||||||
|
run_expect_zero_contains list-nix-legacy "[nix]" --legacy list --nix
|
||||||
|
# Regression: dependency inspection uses declared metadata, not a merge plan.
|
||||||
|
"$SYS" --legacy --action \
|
||||||
|
'{"action":"package_dependencies","package":"bash","reverse":false}' \
|
||||||
|
>"$WORK/deps.out" 2>"$WORK/deps.err"
|
||||||
|
if grep -qE "declares|dependency token|has no declared dependencies" "$WORK/deps.out"; then
|
||||||
|
report deps-legacy PASS "$(head -c 160 "$WORK/deps.out" | tr '\n' ' ')"
|
||||||
|
elif grep -qi "app-portage/portage-utils\|qdepends\|not installed" "$WORK/deps.err" "$WORK/deps.out"; then
|
||||||
|
report deps-legacy PASS "honest limitation: $(head -c 120 "$WORK/deps.err" | tr '\n' ' ')"
|
||||||
|
else
|
||||||
|
report deps-legacy FAIL "rc=$? $(head -c 200 "$WORK/deps.err" | tr '\n' ' ')"
|
||||||
|
fi
|
||||||
|
|
||||||
# A recognizable catalogue command without --legacy must enter the AI workflow
|
# A recognizable catalogue command without --legacy must enter the AI workflow
|
||||||
# and must not run deterministically when no model is available.
|
# and must not run deterministically when no model is available.
|
||||||
if ! PHOEBUS_AI_PROVIDER="" PHOEBUS_AI_BACKEND=direct \
|
if ! PHOEBUS_AI_PROVIDER="" PHOEBUS_AI_BACKEND=direct \
|
||||||
|
|
|
||||||
Loading…
Add table
Reference in a new issue