Files
rust-discovery/crates/agent/src/agent_update_apply.rs
T

113 lines
4.2 KiB
Rust

//! Passive signed-release observations and retained update evidence.
use anyhow::{Context, Result, ensure};
use rmm_domain::agent_update::Platform;
use rmm_privileged_helper::Binding;
use std::path::Path;
/// Opaque public metadata authenticated by the current protected Full peer,
/// with complete guarded history verified there. No caller JSON constructor.
#[derive(Clone)]
pub struct GuardedRecord {
raw: Vec<u8>,
observation: rmm_domain::agent_update::AgentUpdateObservation,
}
impl GuardedRecord {
pub fn bytes(&self, policy_raw: &[u8], keys_raw: &[u8]) -> Result<&[u8]> {
use rmm_domain::agent_update::ObservationQuality;
let o = &self.observation;
let age = chrono::Utc::now() - o.observed_at;
let p = o
.predecessor
.as_ref()
.context("UPDATE_CATALOG_PREDECESSOR")?;
let u = o.updater.as_ref().context("UPDATE_CATALOG_UPDATER")?;
ensure!(
o.validate()
&& o.quality == ObservationQuality::Valid
&& o.platform == Platform::LinuxX64
&& age >= chrono::Duration::zero()
&& age <= chrono::Duration::seconds(90)
&& rmm_domain::jobs::hash(policy_raw) == u.policy_sha256
&& rmm_domain::jobs::hash(keys_raw) == u.keyring_sha256
&& rmm_domain::jobs::hash(&self.raw) == p.installed_record_sha256,
"UPDATE_CATALOG_GUARDED_RECORD"
);
Ok(&self.raw)
}
}
/// Passive cached Full observations only; never a live MCP collection.
type Observation = rmm_domain::agent_update::AgentUpdateObservation;
struct Observing {
receiver: tokio::sync::oneshot::Receiver<Result<(Observation, Vec<u8>)>>,
task: tokio::task::JoinHandle<()>,
}
impl Drop for Observing {
fn drop(&mut self) {
self.task.abort();
}
}
#[derive(Default)]
pub struct Observer {
current: Option<Observation>,
record: Option<GuardedRecord>,
pending: Option<Observing>,
}
impl Observer {
pub fn cached(&self) -> Option<&Observation> {
let value = self.current.as_ref()?;
let age = chrono::Utc::now() - value.observed_at;
(value.validate()
&& age >= chrono::Duration::zero()
&& age <= chrono::Duration::seconds(90))
.then_some(value)
}
pub fn poll(
&mut self,
binding: Option<&Binding>,
candidate: Option<(rmm_domain::agent_update::ReleaseEnvelope, u64)>,
) -> Observation {
if let Some(pending) = &mut self.pending {
match pending.receiver.try_recv() {
Ok(Ok((value, raw))) if value.validate() => {
self.record = Some(GuardedRecord {
raw,
observation: value.clone(),
});
self.current = Some(value);
self.pending = None;
}
Ok(_) | Err(tokio::sync::oneshot::error::TryRecvError::Closed) => {
self.current = None;
self.record = None;
self.pending = None;
}
Err(tokio::sync::oneshot::error::TryRecvError::Empty) => {}
}
}
if self.pending.is_none()
&& let Some(binding) = binding.cloned()
{
let (sender, receiver) = tokio::sync::oneshot::channel();
let task = tokio::task::spawn_blocking(move || {
let (envelope, generation) =
candidate.map_or((None, None), |(e, g)| (Some(e), Some(g)));
let value = rmm_privileged_helper::update_admission::observe_record(
Path::new("/run/rmm-helper-maintenance/control.sock"),
&binding,
envelope,
generation,
);
let _ = sender.send(value);
});
self.pending = Some(Observing { receiver, task });
}
self.cached()
.cloned()
.unwrap_or_else(|| Observation::not_configured(Platform::NATIVE_LINUX, chrono::Utc::now()))
}
pub fn catalog_record(&self) -> Option<GuardedRecord> {
self.cached()?;
self.record.clone()
}
}