Feat/redesign frontend

agent/src/disks.rs

@@ -0,0 +1,197 @@
+use serde::Serialize;
+use std::path::Path;
+use sysinfo::Disks;
+use tokio::process::Command;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct SmartInfo {
+    pub health: String,
+    pub power_on_hours: Option<u64>,
+    pub temperature_celsius: Option<f32>,
+    pub reallocated_sectors: Option<u64>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct DiskInfo {
+    pub device: String,
+    pub model: Option<String>,
+    pub media_type: String,
+    pub total_bytes: u64,
+    pub used_bytes: u64,
+    pub mount_point: Option<String>,
+    pub smart: Option<SmartInfo>,
+}
+
+pub async fn collect_disks() -> Vec<DiskInfo> {
+    if std::env::var("CSFX_FAKE_DISKS").is_ok() {
+        return fake_disks();
+    }
+
+    let block_devices = list_block_devices();
+    let mounts = Disks::new_with_refreshed_list();
+
+    let mut disks = Vec::with_capacity(block_devices.len());
+    for device in block_devices {
+        let media_type = detect_media_type(&device);
+        let model = read_sys_string(&device, "device/model");
+        let mount = mounts
+            .iter()
+            .find(|d| d.name().to_string_lossy().contains(&device));
+
+        let total_bytes = mount.map(|d| d.total_space()).unwrap_or(0);
+        let used_bytes = mount
+            .map(|d| d.total_space() - d.available_space())
+            .unwrap_or(0);
+        let mount_point = mount.map(|d| d.mount_point().to_string_lossy().to_string());
+
+        disks.push(DiskInfo {
+            smart: collect_smart(&device).await,
+            device,
+            model,
+            media_type,
+            total_bytes,
+            used_bytes,
+            mount_point,
+        });
+    }
+
+    disks
+}
+
+fn fake_disks() -> Vec<DiskInfo> {
+    vec![
+        DiskInfo {
+            device: "nvme0n1".to_string(),
+            model: Some("Samsung SSD 990 PRO 2TB".to_string()),
+            media_type: "nvme".to_string(),
+            total_bytes: 2_000_398_934_016,
+            used_bytes: 812_000_000_000,
+            mount_point: Some("/".to_string()),
+            smart: Some(SmartInfo {
+                health: "healthy".to_string(),
+                power_on_hours: Some(3120),
+                temperature_celsius: Some(41.0),
+                reallocated_sectors: Some(0),
+            }),
+        },
+        DiskInfo {
+            device: "sda".to_string(),
+            model: Some("Seagate IronWolf 8TB".to_string()),
+            media_type: "hdd".to_string(),
+            total_bytes: 8_001_563_222_016,
+            used_bytes: 5_200_000_000_000,
+            mount_point: Some("/mnt/csfx-volumes".to_string()),
+            smart: Some(SmartInfo {
+                health: "healthy".to_string(),
+                power_on_hours: Some(18544),
+                temperature_celsius: Some(34.0),
+                reallocated_sectors: Some(0),
+            }),
+        },
+        DiskInfo {
+            device: "sdb".to_string(),
+            model: Some("Seagate IronWolf 8TB".to_string()),
+            media_type: "hdd".to_string(),
+            total_bytes: 8_001_563_222_016,
+            used_bytes: 7_600_000_000_000,
+            mount_point: None,
+            smart: Some(SmartInfo {
+                health: "failing".to_string(),
+                power_on_hours: Some(31022),
+                temperature_celsius: Some(52.0),
+                reallocated_sectors: Some(12),
+            }),
+        },
+    ]
+}
+
+fn list_block_devices() -> Vec<String> {
+    let Ok(entries) = std::fs::read_dir("/sys/block") else {
+        return Vec::new();
+    };
+
+    entries
+        .filter_map(|e| e.ok())
+        .filter_map(|e| e.file_name().into_string().ok())
+        .filter(|name| !name.starts_with("loop") && !name.starts_with("ram"))
+        .collect()
+}
+
+fn read_sys_string(device: &str, relative_path: &str) -> Option<String> {
+    let path = format!("/sys/block/{device}/{relative_path}");
+    std::fs::read_to_string(path)
+        .ok()
+        .map(|v| v.trim().to_string())
+        .filter(|v| !v.is_empty())
+}
+
+fn detect_media_type(device: &str) -> String {
+    if device.starts_with("nvme") {
+        return "nvme".to_string();
+    }
+    match read_sys_string(device, "queue/rotational").as_deref() {
+        Some("0") => "ssd".to_string(),
+        Some("1") => "hdd".to_string(),
+        _ => "unknown".to_string(),
+    }
+}
+
+async fn collect_smart(device: &str) -> Option<SmartInfo> {
+    if !Path::new("/dev").join(device).exists() {
+        return None;
+    }
+
+    let output = Command::new("smartctl")
+        .args(["-j", "-a", &format!("/dev/{device}")])
+        .output()
+        .await
+        .ok()?;
+
+    let json: serde_json::Value = serde_json::from_slice(&output.stdout).ok()?;
+    parse_smart_json(&json)
+}
+
+fn parse_smart_json(json: &serde_json::Value) -> Option<SmartInfo> {
+    let passed = json
+        .get("smart_status")
+        .and_then(|s| s.get("passed"))
+        .and_then(|p| p.as_bool());
+
+    let health = match passed {
+        Some(true) => "healthy",
+        Some(false) => "failing",
+        None => return None,
+    }
+    .to_string();
+
+    let power_on_hours = json
+        .get("power_on_time")
+        .and_then(|p| p.get("hours"))
+        .and_then(|h| h.as_u64());
+
+    let temperature_celsius = json
+        .get("temperature")
+        .and_then(|t| t.get("current"))
+        .and_then(|c| c.as_f64())
+        .map(|c| c as f32);
+
+    let reallocated_sectors = json
+        .get("ata_smart_attributes")
+        .and_then(|a| a.get("table"))
+        .and_then(|t| t.as_array())
+        .and_then(|attrs| {
+            attrs
+                .iter()
+                .find(|a| a.get("id").and_then(|i| i.as_u64()) == Some(5))
+        })
+        .and_then(|a| a.get("raw"))
+        .and_then(|r| r.get("value"))
+        .and_then(|v| v.as_u64());
+
+    Some(SmartInfo {
+        health,
+        power_on_hours,
+        temperature_celsius,
+        reallocated_sectors,
+    })
+}

agent/src/main.rs

@@ -1,6 +1,7 @@
 mod agent_stream;
 mod client;
 mod config;
+mod disks;
 mod firecracker;
 mod nftables;
 mod pki;

agent/src/qemu/runtime.rs

@@ -108,7 +108,10 @@ impl QemuRuntime {
 
         match crate::runtime::Runtime::list_managed_workloads(self).await {
             Ok(recovered) => {
-                info!(count = recovered.len(), "Reconciled running vms from disk state");
+                info!(
+                    count = recovered.len(),
+                    "Reconciled running vms from disk state"
+                );
                 recovered
             }
             Err(e) => {

agent/src/server.rs

@@ -26,6 +26,7 @@ use crate::system::LiveMetricsCollector;
 const TICKET_HEADER: &str = "X-Csfx-Proxy-Ticket";
 pub const METRICS_TICKET_SCOPE: &str = "__node_metrics__";
 pub const POWER_TICKET_SCOPE: &str = "__power__";
+pub const DISKS_TICKET_SCOPE: &str = "__disks__";
 
 #[derive(Clone)]
 pub struct ServerState {
@@ -42,6 +43,7 @@ pub async fn run(state: ServerState, port: u16) -> Result<()> {
         .route("/vnc/{workload_id}", get(vnc_handler))
         .route("/metrics/stream", get(metrics_stream_handler))
         .route("/power", post(power_handler))
+        .route("/disks", get(disks_handler))
         .with_state(state);
 
     let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), port);
@@ -445,6 +447,22 @@ impl PowerAction {
     }
 }
 
+async fn disks_handler(
+    State(state): State<ServerState>,
+    ConnectInfo(addr): ConnectInfo<SocketAddr>,
+    headers: HeaderMap,
+) -> Result<Json<Vec<crate::disks::DiskInfo>>, (StatusCode, String)> {
+    if !is_internal_source(&addr) {
+        warn!(source = %addr, "rejected agent inbound request from non-internal source");
+        return Err((StatusCode::FORBIDDEN, "source not allowed".to_string()));
+    }
+
+    verify_ticket(&headers, DISKS_TICKET_SCOPE, &state.agent_id.to_string())
+        .map_err(|e| (StatusCode::UNAUTHORIZED, e.to_string()))?;
+
+    Ok(Json(crate::disks::collect_disks().await))
+}
+
 async fn power_handler(
     State(state): State<ServerState>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,

agent/src/system.rs

@@ -23,23 +23,27 @@ pub struct SystemMetrics {
 
 pub struct LiveMetricsCollector {
     sys: System,
+    simulator: Option<LoadSimulator>,
 }
 
 impl LiveMetricsCollector {
     pub fn new() -> Self {
         let mut sys = System::new_all();
         sys.refresh_cpu_usage();
-        Self { sys }
+        let simulator = std::env::var("CSFX_SIMULATE_LOAD")
+            .ok()
+            .filter(|v| v == "1" || v.eq_ignore_ascii_case("true"))
+            .map(|_| LoadSimulator::new(sys.total_memory(), sys.cpus().len() as u32));
+        Self { sys, simulator }
     }
 
     pub fn sample(&mut self) -> SystemMetrics {
         self.sys.refresh_cpu_usage();
         self.sys.refresh_memory();
 
-        let cpu_usage_percent = self.sys.global_cpu_usage();
-        let cpu_cores = self.sys.cpus().len() as u32;
-        let memory_total_bytes = self.sys.total_memory();
-        let memory_used_bytes = self.sys.used_memory();
+        if let Some(simulator) = &mut self.simulator {
+            return simulator.sample();
+        }
 
         let disks = Disks::new_with_refreshed_list();
         let (disk_total_bytes, disk_used_bytes) =
@@ -50,6 +54,11 @@ impl LiveMetricsCollector {
                 )
             });
 
+        let cpu_usage_percent = self.sys.global_cpu_usage();
+        let cpu_cores = self.sys.cpus().len() as u32;
+        let memory_total_bytes = self.sys.total_memory();
+        let memory_used_bytes = self.sys.used_memory();
+
         let networks = Networks::new_with_refreshed_list();
         let (network_rx_bytes, network_tx_bytes) =
             networks.iter().fold((0u64, 0u64), |(rx, tx), (_, data)| {
@@ -70,6 +79,77 @@ impl LiveMetricsCollector {
     }
 }
 
+struct LoadSimulator {
+    memory_total_bytes: u64,
+    disk_total_bytes: u64,
+    cpu_cores: u32,
+    cpu_usage_percent: f32,
+    memory_usage_percent: f32,
+    disk_usage_percent: f32,
+    network_rx_bytes: u64,
+    network_tx_bytes: u64,
+    seed: u64,
+}
+
+impl LoadSimulator {
+    fn new(memory_total_bytes: u64, cpu_cores: u32) -> Self {
+        Self {
+            memory_total_bytes,
+            disk_total_bytes: 512 * 1_073_741_824,
+            cpu_cores: cpu_cores.max(1),
+            cpu_usage_percent: 25.0,
+            memory_usage_percent: 35.0,
+            disk_usage_percent: 42.0,
+            network_rx_bytes: 0,
+            network_tx_bytes: 0,
+            seed: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .map(|d| d.as_nanos() as u64)
+                .unwrap_or(1),
+        }
+    }
+
+    fn next_random(&mut self) -> f32 {
+        self.seed ^= self.seed << 13;
+        self.seed ^= self.seed >> 7;
+        self.seed ^= self.seed << 17;
+        (self.seed % 10_000) as f32 / 10_000.0
+    }
+
+    fn walk(&mut self, value: f32, max_step: f32, min: f32, max: f32) -> f32 {
+        let step = (self.next_random() - 0.5) * 2.0 * max_step;
+        (value + step).clamp(min, max)
+    }
+
+    fn sample(&mut self) -> SystemMetrics {
+        self.cpu_usage_percent = self.walk(self.cpu_usage_percent, 8.0, 3.0, 95.0);
+        self.memory_usage_percent = self.walk(self.memory_usage_percent, 3.0, 10.0, 90.0);
+        self.disk_usage_percent = self.walk(self.disk_usage_percent, 0.2, 5.0, 85.0);
+
+        let rx_rate_bytes = (self.walk(2.0, 1.5, 0.05, 12.0) * 1_048_576.0) as u64;
+        let tx_rate_bytes = (self.walk(0.8, 0.6, 0.02, 5.0) * 1_048_576.0) as u64;
+        self.network_rx_bytes += rx_rate_bytes;
+        self.network_tx_bytes += tx_rate_bytes;
+
+        let memory_used_bytes =
+            ((self.memory_usage_percent / 100.0) as f64 * self.memory_total_bytes as f64) as u64;
+        let disk_used_bytes =
+            ((self.disk_usage_percent / 100.0) as f64 * self.disk_total_bytes as f64) as u64;
+
+        SystemMetrics {
+            cpu_usage_percent: self.cpu_usage_percent,
+            cpu_cores: self.cpu_cores,
+            memory_total_bytes: self.memory_total_bytes,
+            memory_used_bytes,
+            disk_total_bytes: self.disk_total_bytes,
+            disk_used_bytes,
+            network_rx_bytes: self.network_rx_bytes,
+            network_tx_bytes: self.network_tx_bytes,
+            uptime_seconds: System::uptime(),
+        }
+    }
+}
+
 fn parse_os_release_field(content: &str, field: &str) -> Option<String> {
     content
         .lines()

app/.gitignore

@@ -24,3 +24,6 @@ vite.config.ts.timestamp-*
 
 .DS_Store
 .Thumbs.db
+
+*storybook.log
+storybook-static