Initial commit: PXEForge Phases 1-4

Container-native PXE boot server in Rust, designed as a clean-room alternative to iVentoy that never touches the client OS trust store. This is the first commit of the project; it lands the full output of Phases 1, 2, 3, and 4 in one shot. ## Phase 1 — protocol stack - 8-crate workspace (core, dhcp-proxy, tftp, http-api, iso-store, ipxe-assets, webui, pxeforge bin). - DHCP proxy (RFC 4578): replies with boot info only, never leases — sidesteps CAP_NET_RAW. Architecture-aware bootfile selection from option 93 (BIOS, IA32, x64-UEFI alias 0x0007/0x0009, ARM64). - TFTP server with full OACK negotiation: blksize, tsize, windowsize. Without it a 1 MiB iPXE binary takes 2000 packets and unusably long. - Two-stage iPXE chain: firmware PXE -> TFTP iPXE binary -> iPXE re-DHCPs with user-class iPXE -> HTTP /boot.ipxe -> kernel+initrd. - HTTP server (axum) with byte-Range ISO streaming and an in-place ISO9660 lookup so kernel/initrd are served from inside the ISO without ever extracting it to disk. - Linux ISOs boot via kernel+initrd extraction (memdisk/sanboot fail for >1-2 GiB modern distros). Distro-family detection drives the cmdline (Debian/Ubuntu, RHEL/Fedora, openSUSE, Arch, Alpine). ## Phase 2 — UX + Windows - Hierarchical PXE menu (Default / Installers / Tools / Gated Deployment) generated from settings — no hand-written .ipxe paths surface in the UI. Number-key + letter hotkeys, BIOS+UEFI variants for some RHEL ISOs. - Gated Deployment "horse-race" queue: clients join, operator picks one ISO, every gate launches simultaneously via tokio::sync::Notify. - Bootimus-pattern Windows: WimPatcher injects a CRLF startnet.cmd into boot.wim so vanilla WinPE net-uses an SMB share and runs setup.exe. All Microsoft-signed; no test certs, no testsigning, no httpdisk.sys. SmbManager supervises smbd start/stop/SIGHUP. - Netbox-style dark UI, fully offline (no CDN, no external fonts). ## Phase 3 — MVP hardening - TFTP retransmit rewrite with explicit window tracking — UEFI SNP clients no longer hang on files that end mid-window. 4 new tests. - DHCP broadcast-flag honored per RFC 2131 §4.1. - Multi-arch container (linux/amd64 + linux/arm64). Entrypoint chowns bind-mounts as root then drops to uid 10001 via gosu. - /healthz + /readyz split from /api/status — readyz fails if no iPXE binaries are bundled. - pxeforge seed --from <path> CLI: same pipeline as web upload (slug, sha256, introspection, boot-entry). - All timestamps RFC 3339 (browser Date couldn't parse the 9-tuple). - Gate poll retains assignment until operator releases — clients that retry on transient network errors reuse the assignment instead of falling back to the menu. - Custom OpenShift SCC: hostNetwork + NET_BIND_SERVICE only, no NET_RAW. ## Phase 4 — UI restructure + remote storage - Web UI rebuilt around six tabs inspired by the iVentoy layout: Dashboard / Network / Forge Gate / Storage / Terminal / About. Old "Monitoring/Content/Configuration" sidebar groups are gone. - NFS share manager (crates/iso-store/src/nfs.rs): mount NFSv3 or NFSv4.1 shares as ISO sources instead of uploading every file into the PVC. New IsoSource enum on IsoMeta lets the store resolve Local vs NFS lazily. Persisted to <work_dir>/nfs.json; failed mounts surface in the UI rather than blocking startup. - Dockerfile gains nfs-common + iproute2; mounting NFS in-container also requires CAP_SYS_ADMIN. Documented in docs/architecture.md. - LogBus + tracing layer in core: 500-line ring buffer + broadcast channel feed an SSE endpoint at /api/log/stream. - Operator terminal at /api/terminal: whitelisted commands (status, isos, clients, gate, nfs, smb, log) — deliberately not a shell. Output mirrored onto the LogBus so the live tail and the terminal pane share one timeline. - Network tab: read-only nic_name / subnet_mask / gateway probed from `ip` at startup; only DNS server is editable. Editing IP/mask on a hot UI would silently break PXE for every client mid-boot. - Bootimus parity (releases v0.1.55 -> v0.1.62): amber row tint on un-bootable ISOs with inline reasons, dashboard "won't boot" panel. ## Tests 56 tests passing across the workspace: - 16 core (LogBus, gate, settings, arch, client) - 1 dhcp-proxy (raw option-93 extraction) - 8 http-api unit (range parsing, terminal split/format) - 13 http-api integration (gated deployment, range, settings, NFS, terminal, log SSE, network endpoint, ui assets, no-external-urls) - 12 iso-store (introspect, slugify, smb, windows wim, NFS options) - 6 tftp (RRQ parsing, plan_window edges) cargo build --workspace and cargo clippy --workspace --all-targets both finish clean (warnings only, no errors).
2026-04-29 02:47:00 -04:00
commit cc309da062
67 changed files with 9032 additions and 0 deletions
@@ -0,0 +1,200 @@
+//! In-process log bus.
+//!
+//! The web UI's Terminal tab streams live server logs over SSE. To feed it
+//! we install a `tracing_subscriber::Layer` that captures formatted lines
+//! and pushes them onto:
+//!
+//!   1. A bounded `tokio::sync::broadcast` channel for live subscribers.
+//!   2. A small in-memory ring buffer (default 500 lines) so a UI that
+//!      connects mid-session sees recent context, not a blank pane.
+//!
+//! No file logging happens here — Docker/OpenShift already capture stdout.
+//! This is purely an extra fan-out for the UI.
+
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use std::collections::VecDeque;
+use std::sync::Arc;
+use time::OffsetDateTime;
+use tokio::sync::broadcast;
+use tracing::field::{Field, Visit};
+use tracing::{Event, Level, Subscriber};
+use tracing_subscriber::layer::Context;
+use tracing_subscriber::registry::LookupSpan;
+use tracing_subscriber::Layer;
+
+/// One captured log line. Cheap to clone (small struct, short strings).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LogLine {
+    #[serde(with = "time::serde::rfc3339")]
+    pub timestamp: OffsetDateTime,
+    /// Lowercase: `error`, `warn`, `info`, `debug`, `trace`.
+    pub level: String,
+    pub target: String,
+    pub message: String,
+}
+
+impl LogLine {
+    /// Compact one-line "tail -f"-style render.
+    #[must_use]
+    pub fn render(&self) -> String {
+        // 2026-04-29T12:34:56Z [info]  pxeforge::http: HTTP listening on 0.0.0.0:80
+        let ts = self
+            .timestamp
+            .format(&time::format_description::well_known::Rfc3339)
+            .unwrap_or_else(|_| "?".into());
+        format!(
+            "{ts} [{:>5}]  {}: {}",
+            self.level, self.target, self.message
+        )
+    }
+}
+
+#[derive(Debug)]
+pub struct LogBus {
+    tx: broadcast::Sender<LogLine>,
+    buf: Mutex<VecDeque<LogLine>>,
+    cap: usize,
+}
+
+impl LogBus {
+    #[must_use]
+    pub fn new(capacity: usize) -> Arc<Self> {
+        // 256 = upper bound on concurrent live subscribers' lag tolerance.
+        // If a slow client falls behind it'll get a Lagged error and skip
+        // ahead — which is what we want for a live tail.
+        let (tx, _) = broadcast::channel(256);
+        Arc::new(Self {
+            tx,
+            buf: Mutex::new(VecDeque::with_capacity(capacity)),
+            cap: capacity,
+        })
+    }
+
+    /// Subscribe to new log lines as they're emitted.
+    #[must_use]
+    pub fn subscribe(&self) -> broadcast::Receiver<LogLine> {
+        self.tx.subscribe()
+    }
+
+    /// Snapshot of the recent ring buffer (oldest → newest).
+    #[must_use]
+    pub fn recent(&self) -> Vec<LogLine> {
+        self.buf.lock().iter().cloned().collect()
+    }
+
+    /// Drop everything in the recent ring buffer.
+    pub fn clear(&self) {
+        self.buf.lock().clear();
+    }
+
+    /// Manually push a synthetic log line (used by the terminal-command
+    /// handler so operator commands appear inline in the live tail).
+    pub fn push(&self, level: &str, target: &str, message: impl Into<String>) {
+        let line = LogLine {
+            timestamp: OffsetDateTime::now_utc(),
+            level: level.to_string(),
+            target: target.to_string(),
+            message: message.into(),
+        };
+        self.record(line);
+    }
+
+    fn record(&self, line: LogLine) {
+        {
+            let mut g = self.buf.lock();
+            if g.len() == self.cap {
+                g.pop_front();
+            }
+            g.push_back(line.clone());
+        }
+        // Send errors are fine — just means no live subscribers right now.
+        let _ = self.tx.send(line);
+    }
+}
+
+/// `tracing_subscriber::Layer` that funnels every event into the LogBus.
+///
+/// Install once in `main` alongside the existing `fmt::layer()` so console
+/// output and the UI tail see the same stream.
+pub struct LogBusLayer {
+    bus: Arc<LogBus>,
+}
+
+impl LogBusLayer {
+    #[must_use]
+    pub fn new(bus: Arc<LogBus>) -> Self {
+        Self { bus }
+    }
+}
+
+impl<S> Layer<S> for LogBusLayer
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+{
+    fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
+        let meta = event.metadata();
+        let level = match *meta.level() {
+            Level::ERROR => "error",
+            Level::WARN => "warn",
+            Level::INFO => "info",
+            Level::DEBUG => "debug",
+            Level::TRACE => "trace",
+        };
+        let mut visitor = MessageVisitor::default();
+        event.record(&mut visitor);
+        let line = LogLine {
+            timestamp: OffsetDateTime::now_utc(),
+            level: level.to_string(),
+            target: meta.target().to_string(),
+            message: visitor.message,
+        };
+        self.bus.record(line);
+    }
+}
+
+#[derive(Default)]
+struct MessageVisitor {
+    message: String,
+}
+
+impl Visit for MessageVisitor {
+    fn record_str(&mut self, field: &Field, value: &str) {
+        if field.name() == "message" {
+            self.message = value.to_string();
+        }
+    }
+    fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
+        if field.name() == "message" {
+            self.message = format!("{value:?}").trim_matches('"').to_string();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn push_and_recent() {
+        let bus = LogBus::new(3);
+        bus.push("info", "test", "first");
+        bus.push("info", "test", "second");
+        bus.push("info", "test", "third");
+        bus.push("info", "test", "fourth");
+        let r = bus.recent();
+        assert_eq!(r.len(), 3);
+        assert_eq!(r[0].message, "second");
+        assert_eq!(r[2].message, "fourth");
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn subscribe_sees_new_lines() {
+        let bus = LogBus::new(8);
+        let mut rx = bus.subscribe();
+        bus.push("info", "test", "live");
+        let l = rx.recv().await.unwrap();
+        assert_eq!(l.message, "live");
+        assert_eq!(l.level, "info");
+    }
+}