//! One bounded passive mTLS catalog/read-only SYSTEM observation actor. //! Its cache is evidence for planning, never an execution permit. use anyhow::{Result,ensure}; use rmm_domain::agent_update::{AgentUpdateObservation,ReleaseEnvelope,ReleaseManifest}; use rmm_agent_windows::{helper_runtime::Client,update_observer::{Request,Response}}; use serde::Deserialize; use std::{net::SocketAddr,time::{Duration,Instant}}; #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct Catalog {status:String,release:Option,observed_at:chrono::DateTime,server_time:chrono::DateTime,job_created:bool} #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct CatalogRelease {release_envelope:ReleaseEnvelope,manifest:ReleaseManifest} async fn collect(client:reqwest::Client,address:SocketAddr,helper:Client,generation:u64)->Result{ let url=format!("https://{}:{}/agent/v1/releases/current?platform={}",crate::https_channel::server_name()?,address.port(),rmm_agent_windows::release_platform::TRIPLE); let response=client.get(&url).send().await?; ensure!(response.url().as_str()==url,"UPDATE_CATALOG_REDIRECT"); let raw=crate::https_channel::bounded_body(response,64*1024,"application/json").await?; let catalog:Catalog=serde_json::from_slice(&raw)?; ensure!(!catalog.job_created && catalog.observed_at.timestamp()>0 && catalog.server_time.timestamp()>0,"UPDATE_CATALOG_NOT_A_JOB"); let candidate=match (catalog.status.as_str(),catalog.release) { ("not_configured",None)=>None, ("available",Some(release))=>{ ensure!(release.release_envelope.decode().map_err(anyhow::Error::msg)?.manifest==release.manifest && release.manifest.platform==rmm_agent_windows::release_platform::WIRE,"UPDATE_CATALOG_UNSIGNED_VIEW");Some(release.release_envelope) } _=>anyhow::bail!("UPDATE_CATALOG_RESPONSE_SHAPE"), }; helper.observe_update(Request{generation,candidate}).await } #[derive(Default)] pub struct Observer {current:Option,pending:Option>>,started:Option} impl Observer { pub async fn poll(&mut self,generation:u64,transport:impl FnOnce()->Result<(reqwest::Client,SocketAddr,Client)>){ if self.pending.as_ref().is_some_and(|task|task.is_finished()) { let task=self.pending.take().expect("finished task"); self.current=match task.await {Ok(Ok(value)) if value.validate(generation).is_ok()=>Some(value),_=>None}; } if self.pending.is_none() && self.started.is_none_or(|at|at.elapsed()>=Duration::from_secs(60)) { self.started=Some(Instant::now()); if let Ok((client,address,helper))=transport(){self.pending=Some(tokio::spawn(async move{tokio::time::timeout(Duration::from_secs(50),collect(client,address,helper,generation)).await?}));} else {self.current=None;} } } pub fn cached(&self)->Option<&Response>{ let value=self.current.as_ref()?; let age=chrono::Utc::now()-value.observation.observed_at; (value.validate(value.generation).is_ok() && age>=chrono::Duration::zero() && age<=chrono::Duration::seconds(90)).then_some(value) } pub fn observation(&self,generation:u64)->AgentUpdateObservation{ self.cached().filter(|v|v.generation==generation).map(|v|v.observation.clone()).unwrap_or_else(||AgentUpdateObservation::not_configured(rmm_agent_windows::release_platform::WIRE,chrono::Utc::now())) } pub fn capabilities(&self)->Vec{ let Some(value)=self.cached() else{return vec![];}; let(Some(updater),Some(predecessor))=(&value.observation.updater,&value.observation.predecessor) else{return vec![];}; vec![rmm_domain::agent_update::APPLY_CAPABILITY.into(),rmm_domain::agent_update::CHECK_CAPABILITY.into(),"update_agent".into(),"system:update_agent".into(),"helper.system.v1".into(),format!("updater.binary.sha256:{}",updater.binary_sha256),format!("updater.policy.sha256:{}",updater.policy_sha256),format!("helper.binary.sha256:{}",predecessor.helper_sha256)] } }