54 lines
3.4 KiB
Rust
54 lines
3.4 KiB
Rust
//! 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<CatalogRelease>,observed_at:chrono::DateTime<chrono::Utc>,server_time:chrono::DateTime<chrono::Utc>,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<Response>{
|
|
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<Response>,pending:Option<tokio::task::JoinHandle<Result<Response>>>,started:Option<Instant>}
|
|
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()))
|
|
}
|
|
|
|
}
|