feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s

This commit is contained in:
BuTzZ
2026-11-12 22:06:25 +01:00
commit 6c3203d725
194 changed files with 49234 additions and 0 deletions
+117
View File
@@ -0,0 +1,117 @@
//! Additive bounded passive metadata; the strict original Inventory stays intact.
use chrono::{DateTime, Utc};
use serde::Deserialize;
use serde_json::Value;
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Observation {
scope: String,
source_id: String,
observed_at: DateTime<Utc>,
quality: String,
completeness: String,
truncated: bool,
error_code: Option<String>,
data: Value,
}
pub fn validate(bytes: &[u8], now: DateTime<Utc>) -> Result<Value, &'static str> {
if bytes.len() > 512 * 1024 {
return Err("INVENTORY_SIZE");
}
let value: Value = serde_json::from_slice(bytes).map_err(|_| "INVALID_INVENTORY_JSON")?;
let mut base = value.as_object().cloned().ok_or("INVENTORY_OBJECT")?;
let observations = base.remove("observations");
let started = base.remove("collection_started_at");
let completed = base.remove("collection_completed_at");
let inventory: crate::Inventory =
serde_json::from_value(Value::Object(base)).map_err(|_| "INVALID_BASE_INVENTORY")?;
if !inventory.validate() {
return Err("INVALID_BASE_INVENTORY");
}
if let Some(observations) = observations {
let started: DateTime<Utc> =
serde_json::from_value(started.ok_or("COLLECTION_WINDOW_REQUIRED")?)
.map_err(|_| "INVALID_COLLECTION_TIME")?;
let completed: DateTime<Utc> =
serde_json::from_value(completed.ok_or("COLLECTION_WINDOW_REQUIRED")?)
.map_err(|_| "INVALID_COLLECTION_TIME")?;
if started > completed
|| (completed - started).num_seconds() > 3600
|| (now - started).num_seconds() > 72 * 3600
|| (completed - now).num_seconds() > 45
{
return Err("INVALID_COLLECTION_WINDOW");
}
let observations = observations.as_array().ok_or("OBSERVATION_ARRAY")?;
if observations.len() > 32 {
return Err("OBSERVATION_COUNT");
}
let mut scopes = std::collections::BTreeSet::new();
for item in observations {
if serde_json::to_vec(item)
.map_err(|_| "INVALID_OBSERVATION")?
.len()
> 32768
{
return Err("OBSERVATION_SIZE");
}
let o: Observation =
serde_json::from_value(item.clone()).map_err(|_| "INVALID_OBSERVATION")?;
if !o.scope.starts_with("linux.")
|| o.scope.len() > 64
|| !o
.scope
.bytes()
.all(|c| c.is_ascii_lowercase() || b"._".contains(&c))
|| !scopes.insert(o.scope)
{
return Err("INVALID_OBSERVATION_SCOPE");
}
if o.source_id.is_empty()
|| o.source_id.len() > 255
|| o.source_id.contains('\0')
|| o.observed_at < started - chrono::Duration::seconds(1)
|| o.observed_at > completed + chrono::Duration::seconds(1)
|| !matches!(
o.quality.as_str(),
"valid" | "unknown" | "unsupported" | "permission_denied" | "error"
)
|| !matches!(o.completeness.as_str(), "complete" | "partial" | "unknown")
|| (o.truncated && o.completeness == "complete")
|| o.error_code.as_ref().is_some_and(|s| s.len() > 128)
|| (o.quality == "valid" && o.data.is_null())
{
return Err("INVALID_OBSERVATION_METADATA");
}
}
} else if started.is_some() || completed.is_some() {
return Err("OBSERVATIONS_REQUIRED");
}
Ok(value)
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn base() -> Value {
json!({"os":"Linux","hostname":"fixture","architecture":"x86_64","root_total_bytes":2,"root_available_bytes":1,"root_available_inodes":1})
}
#[test]
fn additive_metadata_and_bounds() {
let now = Utc::now();
let mut v = base();
assert!(validate(&serde_json::to_vec(&v).unwrap(), now).is_ok());
v["observations"] = json!([{"scope":"linux.smart","source_id":"linux.smart","observed_at":now,"quality":"unsupported","completeness":"unknown","truncated":false,"error_code":"NOT_SUPPORTED","data":null}]);
v["collection_started_at"] = json!(now);
v["collection_completed_at"] = json!(now);
assert_eq!(validate(&serde_json::to_vec(&v).unwrap(), now).unwrap(), v);
v["observations"][0]["data"] = json!("x".repeat(32768));
assert_eq!(
validate(&serde_json::to_vec(&v).unwrap(), now).unwrap_err(),
"OBSERVATION_SIZE"
);
let mut unknown = base();
unknown["tenant_id"] = json!("forged");
assert!(validate(&serde_json::to_vec(&unknown).unwrap(), now).is_err());
}
}