phoebus_os/installer-rs/crates/phoebus-core/src/config.rs
Phoebus b4a6b5df80
Some checks are pending
ci / test (push) Waiting to run
feat(nvidia): hardware-driven driver policy, installed integration and live payload
- resolve the NVIDIA branch and kernel-module flavor from PCI device IDs
  (Turing+ open modules; Maxwell/Pascal/Volta proprietary, masked below 595;
  Fermi/Kepler fall back to nouveau, reported; unknown IDs reported)
- capture pci_id/pci_address in the probe; drive VIDEO_CARDS, package.use,
  package.accept_keywords, package.mask, modprobe.d and dracut from the plan,
  preserving hybrid Intel/AMD
- add the nvidia_drivers install stage (after the kernel, before boot) that
  emerges the driver, regenerates the initramfs, records /etc/phoebus/nvidia and
  fails the install on failure; sys update rebuilds modules and the initramfs
- refuse AI changes to x11-drivers/nvidia-drivers
- live ISO: signed non-free components, stable-kernel pin (testing 7.2 breaks
  the 550 driver), DKMS build for the exact kernel, gated pre-greetd load,
  fail-safe entry, gpu-report, and a --verify-live-nvidia build gate that runs
  on cached rootfs builds and fails on any missing component
- docs: ADR 0012, STATUS/CHANGELOG/HANDOFF, live README
- also carries the pending OpenCode model-variant/streaming changes and fixes
  the GUI bridge install thread join that could hang
2026-09-22 21:53:28 -07:00

794 lines
26 KiB
Rust

//! Structured, strongly-typed installation configuration.
//!
//! Closed sets (filesystem, encryption, bootloader, kernel profile, package
//! policy, desktop profile) are enums. Free-form values (hostname, locale,
//! timezone, ...) are validated by `validate::validate`.
//!
//! Two input formats are supported during the Bash -> Rust migration:
//! * TOML (the native format)
//! * the legacy flat `KEY='value'` format used by the Bash prototype
//!
//! Secrets are never part of this structure.
use std::path::{Path, PathBuf};
use std::str::FromStr;
use serde::{Deserialize, Deserializer, Serialize};
use crate::error::{CoreError, Result};
// ---------------------------------------------------------------------------
// Closed enums
// ---------------------------------------------------------------------------
macro_rules! string_enum {
($name:ident { $($variant:ident => $text:literal),+ $(,)? }) => {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum $name {
$(#[serde(rename = $text)] $variant),+
}
impl $name {
pub fn as_str(self) -> &'static str {
match self { $(Self::$variant => $text),+ }
}
}
impl std::fmt::Display for $name {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
impl FromStr for $name {
type Err = CoreError;
fn from_str(s: &str) -> Result<Self> {
match s {
$($text => Ok(Self::$variant),)+
other => Err(CoreError::UnknownValue {
field: stringify!($name),
value: other.to_string(),
}),
}
}
}
};
}
string_enum!(Filesystem { Btrfs => "btrfs", Ext4 => "ext4" });
string_enum!(Encryption { None => "none", Luks2 => "luks2" });
string_enum!(Bootloader { SystemdBoot => "systemd-boot" });
string_enum!(KernelProfile { Safe => "safe", Optimized => "optimized", Aggressive => "aggressive" });
string_enum!(PackagePolicy { Balanced => "balanced", SourceFirst => "source_first", BinaryFirst => "binary_first" });
string_enum!(DesktopProfile { None => "none", Minimal => "minimal", Dwl => "dwl", Mango => "mango", Full => "full" });
impl DesktopProfile {
/// Whether this profile installs a graphical session.
pub fn is_desktop(self) -> bool {
!matches!(self, DesktopProfile::None)
}
/// Whether the profile's session entry point is the Mango one.
pub fn is_mango(self) -> bool {
matches!(self, DesktopProfile::Mango)
}
}
impl Bootloader {
pub fn default_systemd_boot() -> Self {
Bootloader::SystemdBoot
}
}
// ---------------------------------------------------------------------------
// serde helper: accept either a string or a sequence of strings
// ---------------------------------------------------------------------------
fn de_string_or_seq<'de, D>(deserializer: D) -> std::result::Result<Vec<String>, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum StringOrVec {
One(String),
Many(Vec<String>),
}
let value = StringOrVec::deserialize(deserializer)?;
Ok(match value {
StringOrVec::One(s) => split_list(&s),
StringOrVec::Many(v) => v,
})
}
/// Split a whitespace- or comma-separated list, dropping empty items.
pub fn split_list(s: &str) -> Vec<String> {
s.split(|c: char| c.is_whitespace() || c == ',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_string)
.collect()
}
// ---------------------------------------------------------------------------
// Sections
// ---------------------------------------------------------------------------
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct SystemConfig {
pub distro_name: String,
pub distro_id: String,
pub arch: String,
pub hostname: String,
pub keymap: String,
pub locale: String,
pub timezone: String,
pub root_shell: String,
pub init_system: String,
}
impl Default for SystemConfig {
fn default() -> Self {
Self {
distro_name: "Phoebus OS".into(),
distro_id: "phoebus".into(),
arch: "x86_64".into(),
hostname: "phoebus".into(),
keymap: "us".into(),
locale: "en_US.UTF-8".into(),
timezone: "UTC".into(),
root_shell: "/bin/bash".into(),
init_system: "systemd".into(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct UserConfig {
pub username: String,
pub fullname: String,
#[serde(deserialize_with = "de_string_or_seq")]
pub groups: Vec<String>,
pub home: String,
}
impl Default for UserConfig {
fn default() -> Self {
Self {
username: String::new(),
fullname: "Phoebus User".into(),
groups: split_list("wheel,audio,video,input,render,plugdev,libinput,network,power"),
home: "/home".into(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct StorageConfig {
pub disk: String,
pub partition_scheme: String,
pub efi_size_mib: u32,
pub efi_mount: String,
pub swap_size_mib: u32,
pub filesystem: Filesystem,
pub btrfs_label: String,
pub compress: String,
pub install_root: String,
#[serde(deserialize_with = "de_string_or_seq")]
pub subvols: Vec<String>,
}
impl Default for StorageConfig {
fn default() -> Self {
Self {
disk: String::new(),
partition_scheme: "whole_disk".into(),
efi_size_mib: 1024,
efi_mount: "/efi".into(),
swap_size_mib: 0,
filesystem: Filesystem::Btrfs,
btrfs_label: "phoebus".into(),
compress: "zstd:3".into(),
install_root: "/mnt/phoebus".into(),
subvols: split_list("@ @home @var @snapshots @swap"),
}
}
}
impl StorageConfig {
/// The subvolume mounted at `/` (the first listed subvolume).
pub fn root_subvolume(&self) -> String {
self.subvols
.first()
.cloned()
.unwrap_or_else(|| "@".to_string())
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct EncryptionConfig {
pub mode: Encryption,
pub name: String,
pub cipher: String,
pub key_size: u32,
pub pbkdf: String,
}
impl Default for EncryptionConfig {
fn default() -> Self {
Self {
mode: Encryption::Luks2,
name: "cryptroot".into(),
cipher: "aes-xts-plain64".into(),
key_size: 512,
pbkdf: "argon2id".into(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct Stage3Config {
pub url: String,
pub sha256: String,
pub mirror: String,
pub gentoo_profile: String,
pub binhost_uri: String,
}
impl Default for Stage3Config {
fn default() -> Self {
Self {
url: String::new(),
sha256: String::new(),
mirror: "https://distfiles.gentoo.org/releases/amd64/autobuilds".into(),
gentoo_profile: "default/linux/amd64/23.0/systemd".into(),
binhost_uri: "https://distfiles.gentoo.org/releases/amd64/binpackages/23.0/x86-64"
.into(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct KernelConfig {
pub profile: KernelProfile,
pub package: String,
pub uki: bool,
pub console: String,
pub keep_kernels: u32,
pub secureboot: bool,
}
impl Default for KernelConfig {
fn default() -> Self {
Self {
profile: KernelProfile::Optimized,
package: "sys-kernel/gentoo-kernel".into(),
uki: false,
console: "console=tty0".into(),
keep_kernels: 3,
secureboot: false,
}
}
}
impl KernelConfig {
/// The kernel package the profile resolves to.
pub fn selected_package(&self) -> String {
match self.profile {
KernelProfile::Safe => "sys-kernel/gentoo-kernel-bin".to_string(),
KernelProfile::Optimized | KernelProfile::Aggressive => {
if self.package.is_empty() {
"sys-kernel/gentoo-kernel".to_string()
} else {
self.package.clone()
}
}
}
}
}
/// A scoped `package.use` entry: one atom and one flag. Used by the installer
/// defaults and by validated AI proposals.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
pub struct PackageUse {
pub atom: String,
pub flag: String,
#[serde(default = "default_enabled")]
pub enabled: bool,
}
fn default_enabled() -> bool {
true
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct PackagesConfig {
pub policy: PackagePolicy,
pub binary_packages: bool,
pub accept_license: String,
/// Explicit `MAKEOPTS -j` value; `None` derives it from cores and memory.
#[serde(default)]
pub build_jobs: Option<u32>,
/// Extra scoped USE entries appended to `package.use`.
#[serde(default)]
pub package_use: Vec<PackageUse>,
/// Bootstrap Nix into the target (the second, built-in package lane).
/// On by default; set `NIX_ENABLED='no'` to skip.
#[serde(default = "default_enabled")]
pub nix: bool,
}
impl Default for PackagesConfig {
fn default() -> Self {
Self {
policy: PackagePolicy::Balanced,
binary_packages: true,
accept_license: "@FREE @BINARY-REDISTRIBUTABLE".into(),
build_jobs: None,
package_use: Vec::new(),
nix: true,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct DesktopConfig {
pub profile: DesktopProfile,
pub flatpak: bool,
pub audio_stack: String,
}
impl Default for DesktopConfig {
fn default() -> Self {
Self {
// Mango + DankMaterialShell is the default desktop. An explicit
// `DESKTOP_PROFILE`/`profile` value (including `none`) is respected.
profile: DesktopProfile::Mango,
// Flatpak and PipeWire are part of the default desktop experience.
flatpak: true,
audio_stack: "pipewire".into(),
}
}
}
/// How the assistant reaches a model. `Direct` is an OpenAI-compatible
/// endpoint; `OpenCode` is an OpenCode **agent server** (a different protocol
/// and trust boundary), never an OpenAI-compatible model endpoint.
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
pub enum AiBackend {
#[default]
#[serde(rename = "direct")]
Direct,
#[serde(rename = "opencode")]
OpenCode,
}
impl AiBackend {
pub fn as_str(self) -> &'static str {
match self {
AiBackend::Direct => "direct",
AiBackend::OpenCode => "opencode",
}
}
pub fn parse(value: &str) -> Option<Self> {
match value.trim().to_ascii_lowercase().as_str() {
"" | "direct" | "provider" => Some(AiBackend::Direct),
"opencode" | "open-code" | "open_code" => Some(AiBackend::OpenCode),
_ => None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(default)]
pub struct AiConfig {
pub enabled: bool,
pub provider: String,
pub model: String,
pub endpoint: String,
/// Direct provider endpoint or the OpenCode agent server.
pub backend: AiBackend,
/// OpenCode server base URL, e.g. `http://127.0.0.1:4096`.
pub opencode_server: String,
/// OpenCode provider id (e.g. `deepseek`).
pub opencode_provider: String,
/// OpenCode model id (e.g. `deepseek-chat`).
pub opencode_model: String,
/// OpenCode model variant (e.g. `default`, `low`, `high`, `max`).
pub opencode_variant: String,
}
impl AiConfig {
pub fn is_opencode(&self) -> bool {
self.backend == AiBackend::OpenCode
}
/// The OpenCode endpoint, if this configuration uses one.
pub fn opencode_endpoint(&self) -> Option<&str> {
let server = self.opencode_server.trim();
if server.is_empty() {
None
} else {
Some(server)
}
}
/// OpenCode model variant, defaulting to "default".
pub fn opencode_variant(&self) -> &str {
let v = self.opencode_variant.trim();
if v.is_empty() {
"default"
} else {
v
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct RuntimeConfig {
pub dry_run: bool,
pub assume_yes: bool,
pub log_dir: String,
pub state_dir: String,
}
impl Default for RuntimeConfig {
fn default() -> Self {
Self {
dry_run: false,
assume_yes: false,
log_dir: "/var/log/phoebus-installer".into(),
state_dir: "/run/phoebus-installer".into(),
}
}
}
// ---------------------------------------------------------------------------
// Top level
// ---------------------------------------------------------------------------
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(default)]
pub struct InstallConfig {
pub system: SystemConfig,
pub user: UserConfig,
pub storage: StorageConfig,
pub encryption: EncryptionConfig,
pub stage3: Stage3Config,
pub kernel: KernelConfig,
pub packages: PackagesConfig,
pub desktop: DesktopConfig,
pub ai: AiConfig,
pub runtime: RuntimeConfig,
}
impl InstallConfig {
pub fn is_encrypted(&self) -> bool {
self.encryption.mode != Encryption::None
}
pub fn target_disk(&self) -> &str {
&self.storage.disk
}
/// Load a configuration from TOML or the legacy flat format.
///
/// The legacy `KEY='value'` format is also *valid* TOML (single quotes are
/// TOML literal strings), so format must be detected structurally rather
/// than by attempting TOML first.
pub fn load_from_path(path: &Path) -> Result<Self> {
let text =
std::fs::read_to_string(path).map_err(|e| CoreError::io(path.to_path_buf(), e))?;
if path.extension().and_then(|e| e.to_str()) == Some("toml") {
return Self::from_toml(&text);
}
if looks_like_legacy(&text) {
return Self::from_legacy(&text);
}
Self::from_toml(&text)
}
pub fn from_toml(text: &str) -> Result<Self> {
let cfg: InstallConfig = toml::from_str(text)?;
Ok(cfg)
}
pub fn to_toml_string(&self) -> Result<String> {
Ok(toml::to_string_pretty(self)?)
}
/// Parse the Bash prototype's flat `KEY='value'` configuration format.
pub fn from_legacy(text: &str) -> Result<Self> {
let mut cfg = InstallConfig::default();
for raw_line in text.lines() {
let line = raw_line.trim();
if line.is_empty() || line.starts_with('#') {
continue;
}
let Some((key, value)) = line.split_once('=') else {
continue;
};
let key = key.trim();
let value = unquote(value.trim());
cfg.apply_legacy_kv(key, &value)?;
}
Ok(cfg)
}
fn apply_legacy_kv(&mut self, key: &str, value: &str) -> Result<()> {
match key {
"DISTRO_NAME" => self.system.distro_name = value.into(),
"DISTRO_ID" => self.system.distro_id = value.into(),
"ARCH" => self.system.arch = value.into(),
"HOSTNAME" => self.system.hostname = value.into(),
"KEYMAP" => self.system.keymap = value.into(),
"LOCALE" => self.system.locale = value.into(),
"TIMEZONE" => self.system.timezone = value.into(),
"ROOT_SHELL" => self.system.root_shell = value.into(),
"INIT_SYSTEM" => self.system.init_system = value.into(),
"USERNAME" => self.user.username = value.into(),
"USER_FULLNAME" => self.user.fullname = value.into(),
"USER_GROUPS" => self.user.groups = split_list(value),
"USER_HOME" => self.user.home = value.into(),
"TARGET_DISK" => self.storage.disk = value.into(),
"PARTITION_SCHEME" => self.storage.partition_scheme = value.into(),
"EFI_SIZE_MIB" => self.storage.efi_size_mib = parse_num(key, value)?,
"EFI_MOUNT" => self.storage.efi_mount = value.into(),
"SWAP_SIZE_MIB" => self.storage.swap_size_mib = parse_num(key, value)?,
"FILESYSTEM" => self.storage.filesystem = Filesystem::from_str(value)?,
"BTRFS_LABEL" => self.storage.btrfs_label = value.into(),
"COMPRESS" => self.storage.compress = value.into(),
"INSTALL_ROOT" => self.storage.install_root = value.into(),
"BTRFS_SUBVOLS" => self.storage.subvols = split_list(value),
"ENCRYPTION" => self.encryption.mode = Encryption::from_str(value)?,
"LUKS_NAME" => self.encryption.name = value.into(),
"LUKS_CIPHER" => self.encryption.cipher = value.into(),
"LUKS_KEY_SIZE" => self.encryption.key_size = parse_num(key, value)?,
"LUKS_PBKDF" => self.encryption.pbkdf = value.into(),
"STAGE3_URL" => self.stage3.url = value.into(),
"STAGE3_SHA256" => self.stage3.sha256 = value.into(),
"STAGE3_MIRROR" => self.stage3.mirror = value.into(),
"GENTOO_PROFILE" => self.stage3.gentoo_profile = value.into(),
"BINHOST_URI" => self.stage3.binhost_uri = value.into(),
"BOOTLOADER" => {
// Bootloader is currently fixed to systemd-boot; validate value.
let _ = Bootloader::from_str(value)?;
}
"KERNEL_PROFILE" => self.kernel.profile = KernelProfile::from_str(value)?,
"KERNEL_PACKAGE" => self.kernel.package = value.into(),
"KERNEL_UKI" => self.kernel.uki = parse_bool(value),
"KERNEL_CONSOLE" => self.kernel.console = value.into(),
"KEEP_KERNELS" => self.kernel.keep_kernels = parse_num(key, value)?,
"SECUREBOOT" => self.kernel.secureboot = parse_bool(value),
"PACKAGE_POLICY" => self.packages.policy = PackagePolicy::from_str(value)?,
"FEATURES_BINPKG" => self.packages.binary_packages = parse_bool(value),
"ACCEPT_LICENSE" => self.packages.accept_license = value.into(),
"BUILD_JOBS" => {
self.packages.build_jobs = if value.trim().is_empty() {
None
} else {
Some(parse_num(key, value)?)
}
}
"NIX" | "NIX_ENABLED" => self.packages.nix = parse_bool(value),
"DESKTOP_PROFILE" => self.desktop.profile = DesktopProfile::from_str(value)?,
"FLATPAK" => self.desktop.flatpak = parse_bool(value),
"AUDIO_STACK" => self.desktop.audio_stack = value.into(),
"AI_ENABLED" => self.ai.enabled = parse_bool(value),
"AI_PROVIDER" => self.ai.provider = value.into(),
"AI_MODEL" => self.ai.model = value.into(),
"AI_ENDPOINT" => self.ai.endpoint = value.into(),
"DRY_RUN" => self.runtime.dry_run = parse_bool(value),
"ASSUME_YES" => self.runtime.assume_yes = parse_bool(value),
"LOG_DIR" => self.runtime.log_dir = value.into(),
// Ignored legacy keys (not part of the Rust model yet).
_ => {}
}
Ok(())
}
}
/// True when the text looks like the Bash prototype's flat `KEY='value'` file.
fn looks_like_legacy(text: &str) -> bool {
for raw in text.lines() {
let line = raw.trim();
if line.is_empty() || line.starts_with('#') || line.starts_with('[') {
continue;
}
if line.contains('=') {
let key = line.split('=').next().unwrap().trim();
if !key.is_empty()
&& key
.chars()
.all(|c| c.is_ascii_uppercase() || c.is_ascii_digit() || c == '_')
{
return true;
}
}
}
false
}
fn parse_bool(value: &str) -> bool {
matches!(
value.trim().to_ascii_lowercase().as_str(),
"yes" | "true" | "1" | "on" | "y"
)
}
fn parse_num<T: FromStr>(field: &str, value: &str) -> Result<T> {
value.trim().parse::<T>().map_err(|_| {
CoreError::Config(format!("{field} must be a positive integer, got `{value}`"))
})
}
fn unquote(value: &str) -> String {
let bytes = value.as_bytes();
if bytes.len() >= 2
&& ((bytes[0] == b'\'' && bytes[bytes.len() - 1] == b'\'')
|| (bytes[0] == b'"' && bytes[bytes.len() - 1] == b'"'))
{
value[1..value.len() - 1].to_string()
} else {
value.to_string()
}
}
/// The install root as a path.
impl StorageConfig {
pub fn install_root_path(&self) -> PathBuf {
PathBuf::from(&self.install_root)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn defaults_match_bash_baseline() {
let c = InstallConfig::default();
assert_eq!(c.system.hostname, "phoebus");
assert_eq!(c.user.groups.len(), 9);
assert_eq!(c.storage.filesystem, Filesystem::Btrfs);
assert_eq!(c.encryption.mode, Encryption::Luks2);
assert_eq!(c.encryption.name, "cryptroot");
assert!(c.stage3.binhost_uri.contains("binpackages"));
assert_eq!(c.kernel.console, "console=tty0");
assert!(c.packages.binary_packages);
assert!(!c.packages.policy.eq(&PackagePolicy::SourceFirst));
}
#[test]
fn default_desktop_is_mango_with_flatpak_and_pipewire() {
let c = InstallConfig::default();
assert_eq!(c.desktop.profile, DesktopProfile::Mango);
assert!(c.desktop.flatpak);
assert_eq!(c.desktop.audio_stack, "pipewire");
assert!(c.desktop.profile.is_desktop());
assert!(c.desktop.profile.is_mango());
}
#[test]
fn omitting_the_desktop_key_selects_mango_but_explicit_values_win() {
// Legacy format with no DESKTOP_PROFILE key -> default (Mango).
let implicit =
InstallConfig::from_legacy("HOSTNAME='box'\nTARGET_DISK='/dev/vda'\n").unwrap();
assert_eq!(implicit.desktop.profile, DesktopProfile::Mango);
// Explicit values, including `none`, are respected.
for (value, expected) in [
("none", DesktopProfile::None),
("minimal", DesktopProfile::Minimal),
("dwl", DesktopProfile::Dwl),
("mango", DesktopProfile::Mango),
("full", DesktopProfile::Full),
] {
let text = format!("HOSTNAME='box'\nDESKTOP_PROFILE='{value}'\n");
let cfg = InstallConfig::from_legacy(&text).unwrap();
assert_eq!(cfg.desktop.profile, expected, "value {value}");
}
// TOML: a bare `[desktop]` section without `profile` keeps the default.
let toml = InstallConfig::from_toml("[desktop]\nflatpak = false\n").unwrap();
assert_eq!(toml.desktop.profile, DesktopProfile::Mango);
assert!(!toml.desktop.flatpak);
}
#[test]
fn legacy_config_parses_flat_keys() {
let text = "\
HOSTNAME='testbox'\n\
USERNAME='alice'\n\
USER_GROUPS=\"wheel,audio,video\"\n\
TARGET_DISK='/dev/vda'\n\
ENCRYPTION='luks2'\n\
FILESYSTEM='btrfs'\n\
KERNEL_PROFILE='safe'\n\
DESKTOP_PROFILE='none'\n\
STAGE3_URL='http://10.0.2.2:8000/stage3.tar.xz'\n\
STAGE3_SHA256='abc'\n";
let c = InstallConfig::from_legacy(text).unwrap();
assert_eq!(c.system.hostname, "testbox");
assert_eq!(c.user.username, "alice");
assert_eq!(c.user.groups, vec!["wheel", "audio", "video"]);
assert_eq!(c.storage.disk, "/dev/vda");
assert_eq!(c.kernel.profile, KernelProfile::Safe);
assert_eq!(c.kernel.selected_package(), "sys-kernel/gentoo-kernel-bin");
assert_eq!(c.stage3.url, "http://10.0.2.2:8000/stage3.tar.xz");
}
#[test]
fn toml_roundtrip() {
let mut c = InstallConfig::default();
c.system.hostname = "box".into();
c.storage.subvols = vec!["@".into(), "@home".into()];
c.desktop.profile = DesktopProfile::Dwl;
let text = c.to_toml_string().unwrap();
// The deserializer accepts a bare string for list fields too.
let back = InstallConfig::from_toml(&text).unwrap();
assert_eq!(back.system.hostname, "box");
assert_eq!(back.storage.subvols, vec!["@", "@home"]);
assert_eq!(back.desktop.profile, DesktopProfile::Dwl);
}
#[test]
fn toml_accepts_string_lists() {
let text = "\
[user]\ngroups = \"wheel,audio\"\n\
[storage]\nsubvols = \"@ @home @var\"\n";
let c = InstallConfig::from_toml(text).unwrap();
assert_eq!(c.user.groups, vec!["wheel", "audio"]);
assert_eq!(c.storage.subvols, vec!["@", "@home", "@var"]);
}
#[test]
fn load_from_path_detects_legacy_format() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("test.conf");
std::fs::write(
&path,
"HOSTNAME='box'\nTARGET_DISK='/dev/vda'\nKERNEL_PROFILE='safe'\n",
)
.unwrap();
let c = InstallConfig::load_from_path(&path).unwrap();
assert_eq!(c.system.hostname, "box");
assert_eq!(c.storage.disk, "/dev/vda");
assert_eq!(c.kernel.profile, KernelProfile::Safe);
}
#[test]
fn load_from_path_parses_toml() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("test.toml");
std::fs::write(&path, "[system]\nhostname = \"tomlbox\"\n").unwrap();
let c = InstallConfig::load_from_path(&path).unwrap();
assert_eq!(c.system.hostname, "tomlbox");
}
#[test]
fn unknown_enum_value_is_rejected() {
let text = "[storage]\nfilesystem = \"zfs\"\n";
assert!(InstallConfig::from_toml(text).is_err());
}
}