diff --git a/Cargo.lock b/Cargo.lock index ca7463a..7b7f963 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2210,6 +2210,7 @@ dependencies = [ "rmm-domain", "serde", "serde_json", + "tokio", "uuid", ] diff --git a/crates/agent-linux/Cargo.toml b/crates/agent-linux/Cargo.toml index ea6d753..5e98c1e 100644 --- a/crates/agent-linux/Cargo.toml +++ b/crates/agent-linux/Cargo.toml @@ -11,3 +11,5 @@ uuid.workspace = true serde.workspace = true serde_json.workspace = true chrono.workspace = true +[dev-dependencies] +tokio = { workspace = true } diff --git a/crates/agent-linux/src/inventory.rs b/crates/agent-linux/src/inventory.rs index 8e68f41..ac081b1 100644 --- a/crates/agent-linux/src/inventory.rs +++ b/crates/agent-linux/src/inventory.rs @@ -5,6 +5,7 @@ use crate::{ process, }; mod disks; +pub mod proxmox; use rmm_domain::inventory_document::{CpuTimes, DeviceType, firmware_identifier}; use std::{ collections::BTreeMap, @@ -1281,6 +1282,10 @@ fn machine_type(proxmox_ve: bool) -> Option { virtualization_type(&output) } +pub fn proxmox_ve() -> bool { + Path::new("/usr/bin/pveversion").is_file() && Path::new("/usr/bin/pvedaemon").is_file() +} + pub fn hardware() -> Observation { const SOURCE: &str = "linux.dmi:/sys/class/dmi/id;systemd-detect-virt;pve-manager"; let mut readable_dmi = BTreeMap::new(); @@ -1298,8 +1303,7 @@ pub fn hardware() -> Observation { readable_dmi.insert(field.into(), value); } } - let proxmox_ve = - Path::new("/usr/bin/pveversion").is_file() && Path::new("/usr/bin/pvedaemon").is_file(); + let proxmox_ve = proxmox_ve(); let device_type = machine_type(proxmox_ve); let manufacturer = readable_dmi .get("sys_vendor") diff --git a/crates/agent-linux/src/inventory/proxmox.rs b/crates/agent-linux/src/inventory/proxmox.rs new file mode 100644 index 0000000..76beede --- /dev/null +++ b/crates/agent-linux/src/inventory/proxmox.rs @@ -0,0 +1,566 @@ +//! Read-only Proxmox VE observation: hosted guests, scheduled vzdump jobs and recent +//! backup runs. Uses a dedicated PVEAuditor API token supplied by the installer as a +//! systemd credential. No writes, no root, no shell; the transport is injected so the +//! orchestration and parsing stay testable without a Proxmox host. +use super::{Observation, Quality}; +use serde::Serialize; +use serde_json::Value; +use std::collections::{BTreeMap, BTreeSet}; + +pub const SOURCE: &str = "proxmox.api:/api2/json"; +pub const OBSERVATION_MAX_BYTES: usize = rmm_domain::inventory_document::PROXMOX_OBSERVATION_MAX_BYTES; +pub const MAX_GUESTS: usize = 512; +pub const MAX_JOBS: usize = 64; +pub const MAX_RUNS: usize = 64; +const MAX_LOG_LINES: usize = 4000; +/// Weekly schedules must still show their previous due time. +const SCHEDULE_LOOKBACK_SECONDS: i64 = 8 * 24 * 3600; +const SCHEDULE_ITERATIONS: usize = 100; + +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct Proxmox { + pub node: String, + pub cluster: Option, + pub version: Option, + pub guests: Vec, + pub backup_jobs: Vec, + pub backup_runs: Vec, + /// Local guests that no backup job selects (Proxmox's own analysis). + pub not_backed_up: Vec, +} + +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct Guest { + pub vmid: u32, + pub name: String, + pub kind: &'static str, + pub status: String, + pub template: bool, + pub cpus: Option, + pub memory_bytes: Option, + pub disk_bytes: Option, + pub uptime_seconds: Option, + pub pool: Option, + pub macs: Vec, + pub smbios_uuid: Option, +} + +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct BackupJob { + pub id: String, + pub enabled: bool, + pub schedule: Option, + pub storage: Option, + pub mode: Option, + pub selection: &'static str, + /// Local guests this job backs up, resolved from all/vmid/pool minus exclude. + pub covered_vmids: Vec, + pub next_run: Option, + /// Most recent scheduled time at or before the observation time. + pub last_expected_run: Option, +} + +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct BackupRun { + pub upid: String, + pub started_at: i64, + pub ended_at: Option, + /// ok | warning | error | running + pub status: &'static str, + pub message: Option, + pub guests: Vec, +} + +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct GuestResult { + pub vmid: u32, + /// ok | error + pub result: &'static str, +} + +/// Bounded GET of one `/api2/json` path, returning the `data` member. +pub trait Api { + fn get(&self, path: &str) -> impl std::future::Future> + Send; +} + +pub fn not_configured() -> Observation { + Observation::unavailable(SOURCE, Quality::Unsupported, "PROXMOX_NOT_CONFIGURED") +} + +pub fn failed(code: &str) -> Observation { + Observation::unavailable(SOURCE, Quality::Error, code) +} + +/// The token secret never appears in errors, logs or observations. +pub fn token_header(credential: &str) -> Option { + let token = credential.trim(); + let (id, secret) = token.split_once('=')?; + let (user, name) = id.split_once('!')?; + let ok = |s: &str| !s.is_empty() && s.len() <= 128 + && s.bytes().all(|b| b.is_ascii_alphanumeric() || b"-_.@".contains(&b)); + (ok(user) && user.contains('@') && ok(name) && ok(secret)) + .then(|| format!("PVEAPIToken={token}")) +} + +pub async fn collect(api: &impl Api, now: i64) -> Observation { + match collect_data(api, now).await { + Ok((data, truncated)) => { + let mut observation = Observation::valid(SOURCE, data); + if truncated { + observation = observation.partial("PROXMOX_LIMIT"); + observation.truncated = true; + } + fit(observation) + } + Err(error) => { + let code = error.to_string(); + failed(if code.starts_with("PROXMOX_") && code.len() <= 64 { &code } else { "PROXMOX_API_ERROR" }) + } + } +} + +async fn collect_data(api: &impl Api, now: i64) -> anyhow::Result<(Proxmox, bool)> { + let status = api.get("/cluster/status").await?; + let rows = status.as_array().ok_or_else(|| anyhow::anyhow!("PROXMOX_API_SHAPE"))?; + let node = rows.iter() + .find(|r| r["type"] == "node" && flag(&r["local"]) == Some(true)) + .and_then(|r| r["name"].as_str()) + .filter(|n| clean(n, 64)) + .ok_or_else(|| anyhow::anyhow!("PROXMOX_LOCAL_NODE_UNKNOWN"))? + .to_owned(); + let cluster = rows.iter().find(|r| r["type"] == "cluster") + .and_then(|r| r["name"].as_str()).filter(|n| clean(n, 64)).map(str::to_owned); + let version = api.get("/version").await.ok() + .and_then(|v| v["version"].as_str().filter(|s| clean(s, 32)).map(str::to_owned)); + let mut truncated = false; + + let resources = api.get("/cluster/resources?type=vm").await?; + let mut guests = Vec::new(); + for row in resources.as_array().into_iter().flatten() { + if row["node"].as_str() != Some(node.as_str()) { + continue; + } + let Some(mut guest) = guest(row) else { continue }; + if guests.len() == MAX_GUESTS { + truncated = true; + break; + } + let path = format!("/nodes/{node}/{}/{}/config", guest.kind, guest.vmid); + if let Ok(config) = api.get(&path).await { + guest.macs = macs(&config); + guest.smbios_uuid = config["smbios1"].as_str().and_then(smbios_uuid); + } else { + truncated = true; + } + guests.push(guest); + } + guests.sort_by_key(|g| g.vmid); + + let jobs = api.get("/cluster/backup").await?; + let mut backup_jobs = Vec::new(); + for row in jobs.as_array().into_iter().flatten() { + if row["type"].as_str().is_some_and(|t| t != "vzdump") { + continue; + } + if backup_jobs.len() == MAX_JOBS { + truncated = true; + break; + } + let Some(mut job) = backup_job(row, &node, &guests) else { continue }; + if job.enabled && let Some(schedule) = &job.schedule { + job.last_expected_run = last_expected_run(api, schedule, now).await; + } + backup_jobs.push(job); + } + + let local: BTreeSet = guests.iter().map(|g| g.vmid).collect(); + let not_backed_up = api.get("/cluster/backup-info/not-backed-up").await.ok() + .and_then(|v| v.as_array().cloned()).unwrap_or_default().iter() + .filter_map(|r| vmid(&r["vmid"])).filter(|id| local.contains(id)) + .collect::>().into_iter().collect(); + + let since = now - SCHEDULE_LOOKBACK_SECONDS; + let tasks = api.get(&format!( + "/nodes/{node}/tasks?typefilter=vzdump&source=all&since={since}&limit={MAX_RUNS}" + )).await?; + let mut backup_runs = Vec::new(); + for row in tasks.as_array().into_iter().flatten() { + let Some(mut run) = backup_run(row) else { continue }; + if backup_runs.len() == MAX_RUNS { + truncated = true; + break; + } + let encoded = percent_encode(&run.upid); + match api.get(&format!("/nodes/{node}/tasks/{encoded}/log?start=0&limit={MAX_LOG_LINES}")).await { + Ok(log) => { + let lines: Vec<&str> = log.as_array().into_iter().flatten() + .filter_map(|l| l["t"].as_str()).collect(); + run.guests = guest_results(&lines); + if run.guests.is_empty() { + // A single-guest task names its guest in the UPID. + if let (Some(id), "ok" | "warning") = (upid_vmid(&run.upid), run.status) { + run.guests.push(GuestResult { vmid: id, result: "ok" }); + } + } + if lines.len() >= MAX_LOG_LINES { + truncated = true; + } + } + Err(_) => truncated = true, + } + backup_runs.push(run); + } + backup_runs.sort_by(|a, b| b.started_at.cmp(&a.started_at).then_with(|| a.upid.cmp(&b.upid))); + Ok((Proxmox { node, cluster, version, guests, backup_jobs, backup_runs, not_backed_up }, truncated)) +} + +/// The scheduler's own calendar evaluation, so no local schedule parser can disagree. +/// The API returns at most 100 occurrences, so frequent schedules use shorter windows. +async fn last_expected_run(api: &impl Api, schedule: &str, now: i64) -> Option { + for lookback in [SCHEDULE_LOOKBACK_SECONDS, 86_400, 7_200, 600] { + let path = format!( + "/cluster/jobs/schedule-analyze?schedule={}&starttime={}&iterations={SCHEDULE_ITERATIONS}", + percent_encode(schedule), now - lookback + ); + let runs: Vec = api.get(&path).await.ok()?.as_array()?.iter() + .filter_map(|r| r["timestamp"].as_i64()).collect(); + if runs.len() < SCHEDULE_ITERATIONS || runs.iter().any(|t| *t > now) { + return runs.into_iter().filter(|t| *t <= now).max(); + } + } + None +} + +/// Keep the newest information when the scope exceeds its wire budget. +fn fit(mut observation: Observation) -> Observation { + let size = |o: &Observation| serde_json::to_vec(o).map(|b| b.len()).unwrap_or(usize::MAX); + while size(&observation) > OBSERVATION_MAX_BYTES - 1024 { + let Some(data) = observation.data.as_mut() else { break }; + if data.backup_runs.len() > 8 { + data.backup_runs.pop(); + } else if !data.guests.is_empty() { + data.guests.pop(); + } else { + return failed("WIRE_SCOPE_LIMIT"); + } + observation.truncated = true; + observation = observation.partial("PROXMOX_LIMIT"); + } + observation +} + +fn guest(row: &Value) -> Option { + let kind = match row["type"].as_str()? { + "qemu" => "qemu", + "lxc" => "lxc", + _ => return None, + }; + let vmid = vmid(&row["vmid"])?; + let name = row["name"].as_str().filter(|n| clean(n, 128)).unwrap_or("").to_owned(); + Some(Guest { + vmid, + name: if name.is_empty() { format!("{kind}-{vmid}") } else { name }, + kind, + status: row["status"].as_str().filter(|s| clean(s, 32)).unwrap_or("unknown").to_owned(), + template: flag(&row["template"]) == Some(true), + cpus: row["maxcpu"].as_f64().filter(|c| *c >= 0.0 && *c < 65536.0).map(|c| c.ceil() as u32), + memory_bytes: row["maxmem"].as_u64(), + disk_bytes: row["maxdisk"].as_u64(), + uptime_seconds: row["uptime"].as_u64(), + pool: row["pool"].as_str().filter(|p| clean(p, 64)).map(str::to_owned), + macs: Vec::new(), + smbios_uuid: None, + }) +} + +fn backup_job(row: &Value, node: &str, guests: &[Guest]) -> Option { + let id = row["id"].as_str().filter(|s| clean(s, 64))?.to_owned(); + let text = |key: &str, limit| row[key].as_str().filter(|s| clean(s, limit)).map(str::to_owned); + let list = |key: &str| -> BTreeSet { + row[key].as_str().unwrap_or("").split([',', ' ', ';']) + .filter_map(|s| s.trim().parse().ok()).collect() + }; + let exclude = list("exclude"); + let pool = text("pool", 64); + let vmids = list("vmid"); + let all = flag(&row["all"]) == Some(true); + let selection = if all { "all" } else if pool.is_some() { "pool" } else { "vmid" }; + let node_matches = row["node"].as_str().is_none_or(|n| n == node); + let covered_vmids = guests.iter() + .filter(|g| node_matches && !g.template) + .filter(|g| match selection { + "all" => !exclude.contains(&g.vmid), + "pool" => g.pool == pool, + _ => vmids.contains(&g.vmid), + }) + .map(|g| g.vmid).collect(); + Some(BackupJob { + id, + enabled: flag(&row["enabled"]).unwrap_or(true), + schedule: text("schedule", 128).or_else(|| { + // Pre-7.1 format: days of week plus start time. + let time = text("starttime", 16)?; + Some(text("dow", 64).map_or(time.clone(), |dow| format!("{dow} {time}"))) + }), + storage: text("storage", 64), + mode: text("mode", 16), + selection, + covered_vmids, + next_run: row["next-run"].as_i64(), + last_expected_run: None, + }) +} + +fn backup_run(row: &Value) -> Option { + let upid = row["upid"].as_str().filter(|s| clean(s, 160))?.to_owned(); + let started_at = row["starttime"].as_i64()?; + let ended_at = row["endtime"].as_i64(); + let raw = row["status"].as_str(); + let (status, message) = match (ended_at, raw) { + (None, _) | (_, None) => ("running", None), + (Some(_), Some("OK")) => ("ok", None), + (Some(_), Some(s)) if s.starts_with("WARNINGS") => ("warning", Some(s)), + (Some(_), Some(s)) => ("error", Some(s)), + }; + Some(BackupRun { + upid, + started_at, + ended_at, + status, + message: message.map(|m| truncate(m, 256)), + guests: Vec::new(), + }) +} + +/// vzdump task log lines; the last statement per guest wins. +pub fn guest_results(lines: &[&str]) -> Vec { + let mut results = BTreeMap::new(); + for line in lines { + let line = line.trim(); + if let Some(rest) = line.strip_prefix("INFO: Finished Backup of VM ") + && let Some(id) = leading_number(rest) + { + results.insert(id, "ok"); + } else if let Some(rest) = line.strip_prefix("ERROR: Backup of VM ") + && let Some(id) = leading_number(rest) + { + results.insert(id, "error"); + } + } + results.into_iter().map(|(vmid, result)| GuestResult { vmid, result }).collect() +} + +/// `netN` values: qemu `virtio=AA:..,bridge=..`; lxc `name=eth0,hwaddr=AA:..`. +pub fn macs(config: &Value) -> Vec { + let mut found = BTreeSet::new(); + if let Some(map) = config.as_object() { + for (key, value) in map { + let is_net = key.strip_prefix("net").is_some_and(|n| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit())); + let Some(value) = value.as_str().filter(|_| is_net) else { continue }; + for part in value.split(',') { + if let Some((_, candidate)) = part.split_once('=') + && let Some(mac) = normalize_mac(candidate) + { + found.insert(mac); + } + } + } + } + found.into_iter().take(32).collect() +} + +pub fn smbios_uuid(value: &str) -> Option { + value.split(',').find_map(|part| part.strip_prefix("uuid=")) + .and_then(|u| uuid::Uuid::parse_str(u.trim()).ok()) + .filter(|u| !u.is_nil()) + .map(|u| u.hyphenated().to_string()) +} + +pub fn normalize_mac(value: &str) -> Option { + let parts: Vec<&str> = value.trim().split([':', '-']).collect(); + (parts.len() == 6 && parts.iter().all(|p| p.len() == 2 && p.bytes().all(|b| b.is_ascii_hexdigit()))) + .then(|| parts.join(":").to_ascii_lowercase()) + .filter(|m| m != "00:00:00:00:00:00") +} + +/// UPID:node:pid:pstart:starttime:type:id:user: — `id` is the vmid for single-guest runs. +fn upid_vmid(upid: &str) -> Option { + upid.split(':').nth(6).and_then(|id| id.parse().ok()) +} + +fn vmid(value: &Value) -> Option { + value.as_u64().or_else(|| value.as_str()?.parse().ok()) + .filter(|id| (100..1_000_000_000).contains(id)).map(|id| id as u32) +} + +fn flag(value: &Value) -> Option { + match value { + Value::Bool(b) => Some(*b), + Value::Number(n) => n.as_u64().map(|n| n != 0), + Value::String(s) => match s.as_str() { "1" | "true" => Some(true), "0" | "false" => Some(false), _ => None }, + _ => None, + } +} + +fn leading_number(text: &str) -> Option { + let digits: String = text.chars().take_while(char::is_ascii_digit).collect(); + digits.parse().ok() +} + +fn clean(s: &str, limit: usize) -> bool { + !s.trim().is_empty() && s.len() <= limit && !s.chars().any(char::is_control) +} + +fn truncate(s: &str, limit: usize) -> String { + let s: String = s.chars().filter(|c| !c.is_control()).collect(); + if s.len() <= limit { + return s; + } + let mut end = limit; + while !s.is_char_boundary(end) { + end -= 1; + } + s[..end].to_owned() +} + +pub fn percent_encode(value: &str) -> String { + value.bytes().map(|b| if b.is_ascii_alphanumeric() || b"-_.~".contains(&b) { + (b as char).to_string() + } else { + format!("%{b:02X}") + }).collect() +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + use std::collections::HashMap; + + struct Fixture(HashMap); + impl Api for Fixture { + async fn get(&self, path: &str) -> anyhow::Result { + let key = path.split('?').next().unwrap(); + self.0.get(path).or_else(|| self.0.get(key)).cloned() + .ok_or_else(|| anyhow::anyhow!("PROXMOX_HTTP_404")) + } + } + + fn block(future: F) -> F::Output { + tokio::runtime::Builder::new_current_thread().build().unwrap().block_on(future) + } + + const NOW: i64 = 1_763_640_000; + const UPID_JOB: &str = "UPID:pve:00001234:00ABCDEF:691EE8A0:vzdump::root@pam:"; + const UPID_ONE: &str = "UPID:pve:00001235:00ABCDF0:691EE000:vzdump:101:root@pam:"; + + fn fixture() -> Fixture { + let mut m = HashMap::new(); + m.insert("/cluster/status".into(), json!([ + {"type":"cluster","name":"lab"}, + {"type":"node","name":"pve","local":1}, + {"type":"node","name":"pve2","local":0}])); + m.insert("/version".into(), json!({"version":"9.2.4"})); + m.insert("/cluster/resources".into(), json!([ + {"type":"qemu","vmid":100,"name":"debian","node":"pve","status":"running","maxcpu":2,"maxmem":1073741824u64,"maxdisk":10737418240u64,"uptime":42,"template":0}, + {"type":"lxc","vmid":101,"name":"alpine","node":"pve","status":"stopped","maxcpu":1,"maxmem":134217728,"pool":"lab"}, + {"type":"qemu","vmid":9000,"name":"tpl","node":"pve","status":"stopped","template":1}, + {"type":"qemu","vmid":200,"name":"elsewhere","node":"pve2","status":"running"}])); + m.insert("/nodes/pve/qemu/100/config".into(), json!({ + "net0":"virtio=BC:24:11:AA:BB:01,bridge=vmbr0,firewall=1", + "net1":"e1000=bc-24-11-aa-bb-02,bridge=vmbr1", + "smbios1":"uuid=6E1A2B3C-0000-4000-8000-0000000000AA", + "netmask":"virtio=BC:24:11:FF:FF:FF"})); + m.insert("/nodes/pve/lxc/101/config".into(), json!({ + "net0":"name=eth0,bridge=vmbr0,hwaddr=BC:24:11:AA:BB:03,ip=dhcp,type=veth"})); + m.insert("/nodes/pve/qemu/9000/config".into(), json!({})); + m.insert("/cluster/backup".into(), json!([ + {"id":"backup-a","type":"vzdump","schedule":"*/2:00","storage":"local","mode":"snapshot","vmid":"100,200","enabled":1,"next-run":NOW+3600}, + {"id":"backup-all","type":"vzdump","schedule":"sat 03:00","all":1,"exclude":"100","enabled":0}, + {"id":"backup-pool","type":"vzdump","dow":"mon,tue","starttime":"02:30","pool":"lab"}, + {"id":"backup-other-node","type":"vzdump","schedule":"daily","all":1,"node":"pve2"}])); + m.insert("/cluster/jobs/schedule-analyze".into(), json!([ + {"timestamp":NOW-7200},{"timestamp":NOW-1},{"timestamp":NOW+7199}])); + m.insert("/cluster/backup-info/not-backed-up".into(), json!([{"vmid":101},{"vmid":200}])); + m.insert("/nodes/pve/tasks".into(), json!([ + {"upid":UPID_JOB,"starttime":NOW-600,"endtime":NOW-500,"status":"job errors"}, + {"upid":UPID_ONE,"starttime":NOW-9000,"endtime":NOW-8900,"status":"OK"}, + {"upid":"UPID:pve:1:2:3:vzdump::root@pam:","starttime":NOW-10}])); + m.insert(format!("/nodes/pve/tasks/{}/log", percent_encode(UPID_JOB)), json!([ + {"n":1,"t":"INFO: starting new backup job: vzdump 100 101 --storage local"}, + {"n":2,"t":"INFO: Starting Backup of VM 100 (qemu)"}, + {"n":3,"t":"INFO: Finished Backup of VM 100 (00:00:12)"}, + {"n":4,"t":"ERROR: Backup of VM 101 failed - storage full"}])); + m.insert(format!("/nodes/pve/tasks/{}/log", percent_encode(UPID_ONE)), json!([ + {"n":1,"t":"INFO: Backup job finished successfully"}])); + m.insert("/nodes/pve/tasks/UPID%3Apve%3A1%3A2%3A3%3Avzdump%3A%3Aroot%40pam%3A/log".into(), json!([])); + Fixture(m) + } + + #[test] + fn collects_local_guests_jobs_and_runs() { + let observation = block(collect(&fixture(), NOW)); + assert_eq!(observation.quality, Quality::Valid); + let data = observation.data.unwrap(); + assert_eq!(data.node, "pve"); + assert_eq!(data.cluster.as_deref(), Some("lab")); + assert_eq!(data.guests.iter().map(|g| g.vmid).collect::>(), [100, 101, 9000]); + let vm = &data.guests[0]; + assert_eq!(vm.macs, ["bc:24:11:aa:bb:01", "bc:24:11:aa:bb:02"]); + assert_eq!(vm.smbios_uuid.as_deref(), Some("6e1a2b3c-0000-4000-8000-0000000000aa")); + assert_eq!(data.guests[1].macs, ["bc:24:11:aa:bb:03"]); + let jobs: BTreeMap<_, _> = data.backup_jobs.iter().map(|j| (j.id.as_str(), j)).collect(); + assert_eq!(jobs["backup-a"].covered_vmids, [100]); + assert_eq!(jobs["backup-a"].last_expected_run, Some(NOW - 1)); + assert!(!jobs["backup-all"].enabled); + assert_eq!(jobs["backup-all"].covered_vmids, [101]); + assert_eq!(jobs["backup-all"].last_expected_run, None); + assert_eq!(jobs["backup-pool"].schedule.as_deref(), Some("mon,tue 02:30")); + assert_eq!(jobs["backup-pool"].covered_vmids, [101]); + assert!(jobs["backup-other-node"].covered_vmids.is_empty()); + assert_eq!(data.not_backed_up, [101]); + assert_eq!(data.backup_runs[0].status, "running"); + assert_eq!(data.backup_runs[1].status, "error"); + assert_eq!(data.backup_runs[1].guests, + [GuestResult { vmid: 100, result: "ok" }, GuestResult { vmid: 101, result: "error" }]); + assert_eq!(data.backup_runs[2].guests, [GuestResult { vmid: 101, result: "ok" }]); + } + + #[test] + fn missing_local_node_or_api_is_an_error_observation() { + let observation = block(collect(&Fixture(HashMap::new()), NOW)); + assert_eq!(observation.quality, Quality::Error); + assert_eq!(observation.error_code.as_deref(), Some("PROXMOX_HTTP_404")); + assert!(observation.data.is_none()); + assert_eq!(not_configured().error_code.as_deref(), Some("PROXMOX_NOT_CONFIGURED")); + } + + #[test] + fn oversized_observation_keeps_newest_runs_and_marks_truncation() { + let mut data = block(collect(&fixture(), NOW)).data.unwrap(); + let guest = data.guests[0].clone(); + data.guests = (0..512).map(|i| Guest { vmid: 100 + i, name: "x".repeat(120), ..guest.clone() }).collect(); + let observation = fit(Observation::valid(SOURCE, data)); + assert!(observation.truncated); + assert!(serde_json::to_vec(&observation).unwrap().len() <= OBSERVATION_MAX_BYTES); + assert_eq!(observation.data.unwrap().backup_runs.len(), 3); + } + + #[test] + fn token_header_rejects_malformed_credentials() { + assert_eq!(token_header("rmm-agent@pve!inventory=0f3c-11\n").as_deref(), + Some("PVEAPIToken=rmm-agent@pve!inventory=0f3c-11")); + for bad in ["", "rmm-agent@pve=abc", "rmm-agent!x=abc", "a@pve!x=a b", "a@pve!x=a\r\nX: y"] { + assert!(token_header(bad).is_none(), "{bad}"); + } + } + + #[test] + fn mac_and_uuid_parsing_is_strict() { + assert_eq!(normalize_mac("BC:24:11:0a:0B:0c").as_deref(), Some("bc:24:11:0a:0b:0c")); + assert!(normalize_mac("bc:24:11:0a:0b").is_none()); + assert!(normalize_mac("00:00:00:00:00:00").is_none()); + assert!(smbios_uuid("manufacturer=QEMU").is_none()); + assert!(smbios_uuid("uuid=00000000-0000-0000-0000-000000000000").is_none()); + } +} diff --git a/crates/agent-linux/src/lib.rs b/crates/agent-linux/src/lib.rs index 77deef9..31bde7b 100644 --- a/crates/agent-linux/src/lib.rs +++ b/crates/agent-linux/src/lib.rs @@ -27,7 +27,8 @@ pub fn apt_planning_metadata() -> Result> { Ok(output.stdout) } -/// Read-only local collection. No shell, package manager or hypervisor access. +/// Read-only local collection. No shell or package manager; Proxmox VE is read only +/// through its local API with a PVEAuditor token (`inventory::proxmox`). pub fn collect() -> Result { let os = fs::read_to_string("/etc/os-release").context("read OS release")?; let hostname = fs::read_to_string("/proc/sys/kernel/hostname")?; diff --git a/crates/agent/src/main.rs b/crates/agent/src/main.rs index 1e913a3..c3faf80 100644 --- a/crates/agent/src/main.rs +++ b/crates/agent/src/main.rs @@ -7,6 +7,7 @@ mod certificate_rotation; mod helper_sync; mod https_channel; mod jobs; +mod proxmox_api; mod reconcile; #[cfg(test)] mod runtime_tests; @@ -524,14 +525,21 @@ impl Agent { let extended = env::var("RMM_EXTENDED_INVENTORY").unwrap_or_else(|_| "1".into()) == "1"; let binding = self.binding.clone(); let catalog = self.catalog.cached(Utc::now()); + let runtime = tokio::runtime::Handle::current(); tokio::task::spawn_blocking(move || { let collected_at = Utc::now(); let result = rmm_agent_linux::wire::snapshot(extended).and_then(|mut inventory| { if extended { - inventory["observations"] + let proxmox = runtime.block_on(proxmox_api::observation( + rmm_agent_linux::inventory::proxmox_ve(), + )); + let scopes = inventory["observations"] .as_array_mut() - .context("INVENTORY_OBSERVATIONS")? - .push(apt::planning_observation(binding.as_ref())); + .context("INVENTORY_OBSERVATIONS")?; + scopes.push(apt::planning_observation(binding.as_ref())); + if let Some(observation) = proxmox { + scopes.push(proxmox_api::wire(&observation)?); + } inventory["collection_completed_at"] = serde_json::json!(Utc::now()); } if let Some(report) = catalog { diff --git a/crates/agent/src/proxmox_api.rs b/crates/agent/src/proxmox_api.rs new file mode 100644 index 0000000..76f8ed6 --- /dev/null +++ b/crates/agent/src/proxmox_api.rs @@ -0,0 +1,88 @@ +//! Local, read-only Proxmox VE API client for the `linux.proxmox` observation. +//! +//! Only `https://127.0.0.1:8006` with the cluster CA copied by the installer. The +//! PVEAuditor token arrives as the systemd credential `rmm-proxmox-token`; it is never +//! logged, persisted by the agent or placed in an observation. +use anyhow::{Context, Result, ensure}; +use reqwest::{Client, StatusCode}; +use rmm_agent_linux::inventory::{Observation, proxmox}; +use serde_json::Value; +use std::{path::PathBuf, time::Duration}; + +const BASE: &str = "https://127.0.0.1:8006/api2/json"; +const CREDENTIAL: &str = "rmm-proxmox-token"; +const DEFAULT_CA: &str = "/etc/rmm/pve-ca.pem"; +const MAX_RESPONSE: usize = 2 * 1024 * 1024; +const TOTAL_BUDGET: Duration = Duration::from_secs(45); + +struct LocalApi { + client: Client, + authorization: String, +} + +impl proxmox::Api for LocalApi { + async fn get(&self, path: &str) -> Result { + ensure!(path.starts_with('/') && !path.contains(".."), "PROXMOX_PATH"); + let mut response = self.client.get(format!("{BASE}{path}")) + .header(reqwest::header::AUTHORIZATION, &self.authorization) + .send().await.map_err(|_| anyhow::anyhow!("PROXMOX_UNREACHABLE"))?; + match response.status() { + StatusCode::OK => (), + StatusCode::UNAUTHORIZED => anyhow::bail!("PROXMOX_TOKEN_REJECTED"), + StatusCode::FORBIDDEN => anyhow::bail!("PROXMOX_PERMISSION_DENIED"), + status => anyhow::bail!("PROXMOX_HTTP_{}", status.as_u16()), + } + ensure!(response.content_length().is_none_or(|n| n <= MAX_RESPONSE as u64), "PROXMOX_RESPONSE_LIMIT"); + let mut body = Vec::new(); + while let Some(chunk) = response.chunk().await? { + ensure!(chunk.len() <= MAX_RESPONSE.saturating_sub(body.len()), "PROXMOX_RESPONSE_LIMIT"); + body.extend_from_slice(&chunk); + } + let mut value: Value = serde_json::from_slice(&body).map_err(|_| anyhow::anyhow!("PROXMOX_API_SHAPE"))?; + Ok(value["data"].take()) + } +} + +fn credential_path() -> Option { + std::env::var_os("CREDENTIALS_DIRECTORY").map(|d| PathBuf::from(d).join(CREDENTIAL)) +} + +fn client(ca: &[u8]) -> Result { + Ok(Client::builder() + .https_only(true) + .tls_built_in_root_certs(false) + .add_root_certificate(reqwest::Certificate::from_pem(ca)?) + .no_proxy() + .redirect(reqwest::redirect::Policy::none()) + .connect_timeout(Duration::from_secs(5)) + .timeout(Duration::from_secs(15)) + .build()?) +} + +/// `None` on hosts without Proxmox VE: no scope is reported there at all. +pub async fn observation(proxmox_ve: bool) -> Option> { + if !proxmox_ve { + return None; + } + let Some(token) = credential_path().and_then(|p| std::fs::read_to_string(p).ok()) else { + return Some(proxmox::not_configured()); + }; + let Some(authorization) = proxmox::token_header(&token) else { + return Some(proxmox::failed("PROXMOX_TOKEN_INVALID")); + }; + let ca_path = std::env::var("RMM_PROXMOX_CA_FILE").unwrap_or_else(|_| DEFAULT_CA.into()); + let api = match std::fs::read(&ca_path).context("ca").and_then(|ca| client(&ca)) { + Ok(client) => LocalApi { client, authorization }, + Err(_) => return Some(proxmox::failed("PROXMOX_CA_UNAVAILABLE")), + }; + let now = chrono::Utc::now().timestamp(); + Some(tokio::time::timeout(TOTAL_BUDGET, proxmox::collect(&api, now)).await + .unwrap_or_else(|_| proxmox::failed("PROXMOX_TIMEOUT"))) +} + +/// Wire form with the scope label the server's `linux.base` validation expects. +pub fn wire(observation: &Observation) -> Result { + let mut value = serde_json::to_value(observation)?; + value["scope"] = Value::String("linux.proxmox".into()); + Ok(value) +} diff --git a/crates/domain/src/inventory_document.rs b/crates/domain/src/inventory_document.rs index 3c9a308..39b032d 100644 --- a/crates/domain/src/inventory_document.rs +++ b/crates/domain/src/inventory_document.rs @@ -6,6 +6,7 @@ use serde_json::Value; pub const SOFTWARE_OBSERVATION_MAX_BYTES: usize = 128 * 1024; pub const LINUX_SOFTWARE_OBSERVATION_MAX_BYTES: usize = 256 * 1024; +pub const PROXMOX_OBSERVATION_MAX_BYTES: usize = 128 * 1024; pub fn firmware_identifier(value: &str) -> Option { let value = value.trim_matches(|c: char| c == '\0' || c.is_whitespace());