phoebus_os/installer-rs/crates/phoebus-core/src/policy.rs
Phoebus 9573f2e37a
Some checks failed
ci / test (push) Has been cancelled
feat(desktop): seat management, thunderbird-bin fast default, AI timeout
P0 seat fix: sys-auth/seatd installed and enabled before greetd,
gui-libs/libseat with systemd+builtin+server USE, seat in default user
groups, greeter in video/input/render/seat, and a bounded 3 s seat wait
in phoebus-session-mango (LIBSEAT_BACKEND deliberately unset so every
compiled backend stays available).

P1 fast install: mail-client/thunderbird-bin replaces the source build
in workstation_packages; Thunderbird joins fast_default_deliveries and
SOURCE_CONVERSIONS (source target mail-client/thunderbird, honest
45-90 min estimate), the preference-neutrality guard covers it, and the
first-login welcome names it. All lanes and the mandatory-AI install
requirement are unchanged.

AI robustness: CurlTransport max-time 120 s -> 300 s default,
overrideable via PHOEBUS_AI_TIMEOUT (fail-closed parsing; zero refused)
for both direct and sandboxed sends.

Verified: cargo fmt --check, clippy --workspace --all-targets -- -D
warnings, cargo test --workspace 759/759 (was 757), bash -n on the
session script. Seat-VM reverification, thunderbird VM journeys, and
live CPU-inference proof are NotRun (no VM run this session).
2026-09-26 15:41:19 -07:00

359 lines
11 KiB
Rust

//! Deterministic source-versus-binary package policy.
//!
//! The rule is:
//! * cheap compiles are done from source;
//! * packages where local compilation or USE customisation matters are
//! compiled;
//! * expensive packages with negligible practical benefit use a signed
//! Gentoo binary when one is available.
//!
//! Decisions are deterministic and never consult a model. Measured compile
//! times can override the built-in estimates.
use std::collections::{HashMap, HashSet};
use serde::{Deserialize, Serialize};
use crate::config::PackagePolicy;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum InstallMethod {
Source,
Binary,
}
impl InstallMethod {
pub fn as_str(self) -> &'static str {
match self {
InstallMethod::Source => "source",
InstallMethod::Binary => "binary",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PackageDecisionReason {
CheapCompile,
RequiredUseFlags,
NativeOptimizationBenefit,
HighBuildCostLowBenefit,
BinaryUnavailable,
UserPreference,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct PackageDecision {
pub method: InstallMethod,
pub reason: PackageDecisionReason,
pub estimated_seconds: u64,
}
pub struct PolicyContext {
pub policy: PackagePolicy,
pub binhost_available: bool,
pub memory_mib: u64,
pub cores: u32,
}
pub struct PackagePolicyEngine {
estimates: HashMap<&'static str, u64>,
binary_preferred: HashSet<&'static str>,
source_preferred: HashSet<&'static str>,
history: HashMap<String, u64>,
}
impl Default for PackagePolicyEngine {
fn default() -> Self {
Self::new()
}
}
impl PackagePolicyEngine {
pub fn new() -> Self {
let mut estimates = HashMap::new();
for (pkg, secs) in [
("app-editors/vim", 45u64),
("app-misc/tmux", 20),
("app-shells/zsh", 60),
("dev-lang/python", 900),
("dev-lang/rust", 3600),
("dev-libs/glib", 120),
("dev-util/cmake", 300),
("dev-vcs/git", 120),
("media-video/ffmpeg", 900),
("net-misc/curl", 90),
("sys-apps/busybox", 60),
("sys-apps/coreutils", 120),
("sys-apps/systemd", 420),
("sys-devel/gcc", 3600),
("sys-kernel/gentoo-kernel", 1800),
("sys-kernel/gentoo-sources", 120),
("sys-libs/glibc", 900),
("www-client/firefox", 4200),
("www-client/firefox-bin", 0),
("www-client/chromium", 7200),
("app-office/libreoffice", 5400),
("app-office/libreoffice-bin", 0),
("mail-client/thunderbird-bin", 0),
("dev-qt/qtbase", 900),
("kde-plasma/plasma-desktop", 600),
("net-im/discord-bin", 0),
("games-util/steam-launcher", 0),
] {
estimates.insert(pkg, secs);
}
let binary_preferred: HashSet<&'static str> = [
"www-client/firefox",
"www-client/firefox-bin",
"www-client/chromium",
"app-office/libreoffice",
"app-office/libreoffice-bin",
"mail-client/thunderbird",
"mail-client/thunderbird-bin",
"dev-lang/rust",
"dev-lang/llvm",
"dev-qt/qtwebengine",
"sys-devel/gcc",
"sys-libs/glibc",
"net-im/discord-bin",
"games-util/steam-launcher",
]
.into_iter()
.collect();
let source_preferred: HashSet<&'static str> = [
"sys-kernel/gentoo-kernel",
"sys-kernel/gentoo-sources",
"sys-apps/systemd",
"app-shells/zsh",
"sys-apps/busybox",
"sys-fs/btrfs-progs",
"sys-fs/cryptsetup",
]
.into_iter()
.collect();
Self {
estimates,
binary_preferred,
source_preferred,
history: HashMap::new(),
}
}
/// Install measured compile times (seconds) keyed by package atom.
pub fn with_history(mut self, history: HashMap<String, u64>) -> Self {
self.history = history;
self
}
pub fn estimate_seconds(&self, pkg: &str) -> u64 {
if let Some(secs) = self.history.get(pkg) {
return *secs;
}
self.estimates.get(pkg).copied().unwrap_or(300)
}
pub fn decide(&self, pkg: &str, ctx: &PolicyContext) -> PackageDecision {
let seconds = self.estimate_seconds(pkg);
let binary = |reason| PackageDecision {
method: InstallMethod::Binary,
reason,
estimated_seconds: seconds,
};
let source = |reason| PackageDecision {
method: InstallMethod::Source,
reason,
estimated_seconds: seconds,
};
match ctx.policy {
PackagePolicy::SourceFirst => {
return source(PackageDecisionReason::UserPreference);
}
PackagePolicy::BinaryFirst => {
if ctx.binhost_available {
return binary(PackageDecisionReason::UserPreference);
}
return source(PackageDecisionReason::BinaryUnavailable);
}
PackagePolicy::Balanced => {}
}
if self.binary_preferred.contains(pkg) && ctx.binhost_available {
return binary(PackageDecisionReason::HighBuildCostLowBenefit);
}
if self.source_preferred.contains(pkg) {
return source(PackageDecisionReason::NativeOptimizationBenefit);
}
if seconds <= 120 {
return source(PackageDecisionReason::CheapCompile);
}
if ctx.binhost_available {
return binary(PackageDecisionReason::HighBuildCostLowBenefit);
}
source(PackageDecisionReason::BinaryUnavailable)
}
/// Extra `emerge` flags for a package, based on its decision.
pub fn emerge_args(&self, pkg: &str, ctx: &PolicyContext) -> Vec<String> {
match self.decide(pkg, ctx).method {
InstallMethod::Binary => {
vec!["--getbinpkg".into(), "--binpkg-respect-use=y".into()]
}
InstallMethod::Source => Vec::new(),
}
}
}
/// Read a measured compile-time history file.
///
/// Format: `category/package<TAB>seconds<TAB>updates-per-year`.
pub fn load_history(path: &std::path::Path) -> HashMap<String, u64> {
let mut out = HashMap::new();
let Ok(text) = std::fs::read_to_string(path) else {
return out;
};
for line in text.lines() {
let line = line.trim();
if line.is_empty() || line.starts_with('#') {
continue;
}
let mut parts = line.split('\t');
let (Some(pkg), Some(secs)) = (parts.next(), parts.next()) else {
continue;
};
if let Ok(secs) = secs.trim().parse::<u64>() {
out.insert(pkg.trim().to_string(), secs);
}
}
out
}
/// Write a measured compile-time history file, replacing its contents.
pub fn save_history(path: &std::path::Path, history: &HashMap<String, u64>) -> std::io::Result<()> {
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
let mut keys: Vec<&String> = history.keys().collect();
keys.sort();
let mut out = String::new();
out.push_str("# Phoebus measured compile times (seconds) and update frequency.\n");
out.push_str("# atom\tseconds\tupdates-per-year\n");
for key in keys {
out.push_str(&format!("{key}\t{}\t6\n", history[key]));
}
std::fs::write(path, out)
}
/// Append a measured compile time to the history file.
pub fn append_history(
path: &std::path::Path,
pkg: &str,
seconds: u64,
updates_per_year: u64,
) -> std::io::Result<()> {
use std::io::Write;
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
let mut file = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(path)?;
writeln!(file, "{pkg}\t{seconds}\t{updates_per_year}")
}
#[cfg(test)]
mod tests {
use super::*;
fn ctx(policy: PackagePolicy) -> PolicyContext {
PolicyContext {
policy,
binhost_available: true,
memory_mib: 8192,
cores: 8,
}
}
#[test]
fn balanced_compiles_cheap_and_binaries_expensive() {
let e = PackagePolicyEngine::new();
let c = ctx(PackagePolicy::Balanced);
assert_eq!(
e.decide("app-editors/vim", &c).method,
InstallMethod::Source
);
assert_eq!(
e.decide("www-client/firefox", &c).method,
InstallMethod::Binary
);
assert_eq!(
e.decide("sys-kernel/gentoo-kernel", &c).method,
InstallMethod::Source
);
}
#[test]
fn source_first_always_compiles() {
let e = PackagePolicyEngine::new();
let c = ctx(PackagePolicy::SourceFirst);
assert_eq!(
e.decide("www-client/firefox", &c).method,
InstallMethod::Source
);
}
#[test]
fn binary_first_prefers_binary_but_falls_back() {
let e = PackagePolicyEngine::new();
assert_eq!(
e.decide("app-editors/vim", &ctx(PackagePolicy::BinaryFirst))
.method,
InstallMethod::Binary
);
let mut no_binhost = ctx(PackagePolicy::BinaryFirst);
no_binhost.binhost_available = false;
assert_eq!(
e.decide("www-client/firefox", &no_binhost).method,
InstallMethod::Source
);
}
#[test]
fn history_overrides_estimate() {
let mut hist = HashMap::new();
hist.insert("app-editors/vim".to_string(), 7u64);
let e = PackagePolicyEngine::new().with_history(hist);
assert_eq!(e.estimate_seconds("app-editors/vim"), 7);
}
#[test]
fn unknown_package_defaults_to_300s() {
let e = PackagePolicyEngine::new();
assert_eq!(e.estimate_seconds("dev-libs/unknown"), 300);
}
#[test]
fn emerge_args_match_method() {
let e = PackagePolicyEngine::new();
let c = ctx(PackagePolicy::Balanced);
assert!(e
.emerge_args("www-client/firefox", &c)
.contains(&"--getbinpkg".to_string()));
assert!(e.emerge_args("app-editors/vim", &c).is_empty());
}
#[test]
fn history_file_roundtrip() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("compile-times.tsv");
append_history(&path, "app-editors/vim", 7, 25).unwrap();
let hist = load_history(&path);
assert_eq!(hist.get("app-editors/vim"), Some(&7));
}
}