//! In-memory peer views. Health loops refresh the status entries; the read //! side never awaits on a peer and is cheap enough for a metrics scrape. use std::collections::BTreeMap; use std::sync::{Arc, RwLock}; use std::time::Duration; use crate::error::AppError; use crate::peers::error::PeerConfigError; use crate::peers::transport::{PeerResponse, PeerTransport}; use crate::peers::types::{ApiStatus, PeerConfig, PeerName, PeerStatus, PeersConfig, ServerStatus}; /// Options a surface passes down to the proxy layer. Trace context is a /// pre-built `traceparent` header value; the peer hop is always marked. #[derive(Debug, Clone, Default, PartialEq, Eq)] pub struct ProxyOpts { pub traceparent: Option, pub accept_sse: bool, } struct RegistryState { config: Arc, statuses: BTreeMap, } pub struct PeerRegistry { transport: Arc, state: RwLock, } fn initial_status(peer: &PeerConfig) -> PeerStatus { PeerStatus { name: peer.name.clone(), enabled: peer.enabled, url: peer.display_url(), server: ServerStatus::default(), api: ApiStatus::default(), } } fn lock_read(lock: &RwLock) -> std::sync::RwLockReadGuard<'_, T> { lock.read().unwrap_or_else(|e| e.into_inner()) } fn lock_write(lock: &RwLock) -> std::sync::RwLockWriteGuard<'_, T> { lock.write().unwrap_or_else(|e| e.into_inner()) } impl PeerRegistry { pub(crate) fn new(config: PeersConfig, transport: Arc) -> Self { let statuses = config .peer .iter() .map(|peer| (peer.name.clone(), initial_status(peer))) .collect(); Self { transport, state: RwLock::new(RegistryState { config: Arc::new(config), statuses, }), } } pub(crate) fn from_statuses( statuses: Vec, config: PeersConfig, transport: Arc, ) -> Self { Self { transport, state: RwLock::new(RegistryState { config: Arc::new(config), statuses: statuses.into_iter().map(|s| (s.name.clone(), s)).collect(), }), } } /// Sorted by name; disabled peers included. pub fn snapshot(&self) -> Vec { lock_read(&self.state).statuses.values().cloned().collect() } pub fn status(&self, name: &str) -> Result { let Ok(key) = PeerName::parse(name) else { return Err(AppError::NotFound(format!("peer {name}: unknown peer"))); }; lock_read(&self.state) .statuses .get(&key) .cloned() .ok_or_else(|| AppError::NotFound(format!("peer {name}: unknown peer"))) } pub fn contains(&self, name: &str) -> bool { let Ok(key) = PeerName::parse(name) else { return false; }; lock_read(&self.state).statuses.contains_key(&key) } pub fn config(&self) -> Arc { lock_read(&self.state).config.clone() } /// Single proxy entry point for REST and MCP. pub async fn get( &self, name: &str, path: &str, query: &[(String, String)], opts: ProxyOpts, ) -> Result { let key = PeerName::parse(name).ok(); let (peer, timeout) = { let st = lock_read(&self.state); let peer = key.and_then(|key| st.config.peer.iter().find(|p| p.name == key).cloned()); (peer, Duration::from_secs(st.config.request_timeout_secs)) }; let peer = peer.ok_or_else(|| AppError::NotFound(format!("peer {name}: unknown peer")))?; crate::peers::proxy::get(self.transport.as_ref(), &peer, path, query, opts, timeout).await } /// Replace the peer set. Statuses of peers that survive a reload are kept /// so `since` survives a config change. Validation arrives with the /// config and secrets tasks; this body only swaps state. pub async fn reload(&self, new: PeersConfig) -> Result<(), PeerConfigError> { let mut st = lock_write(&self.state); let old = std::mem::take(&mut st.statuses); st.statuses = new .peer .iter() .map(|peer| { let mut status = old .get(&peer.name) .cloned() .unwrap_or_else(|| initial_status(peer)); status.enabled = peer.enabled; status.url = peer.display_url(); (peer.name.clone(), status) }) .collect(); st.config = Arc::new(new); Ok(()) } /// Health loops stop on this; nothing is running yet. pub async fn shutdown(&self) {} } #[cfg(test)] mod tests { use super::*; use crate::peers::testing::{fake_peers_config, registry_with, static_registry, FakeTransport}; use crate::peers::transport::PeerBody; fn status(name: &str, up: bool) -> PeerStatus { PeerStatus { name: PeerName::parse(name).unwrap(), enabled: true, url: format!("http://{name}:1984"), server: ServerStatus { up, ..ServerStatus::default() }, api: ApiStatus::default(), } } #[test] fn snapshot_is_sorted_and_includes_initial_state() { let reg = static_registry(vec![status("gamma", false), status("beta", true)]); let names: Vec<_> = reg .snapshot() .into_iter() .map(|s| s.name.as_str().to_owned()) .collect(); assert_eq!(names, ["beta", "gamma"]); let b = reg.status("beta").unwrap(); assert!(b.server.up); assert_eq!(b.api.auth, crate::peers::types::AuthState::Unknown); } #[test] fn unknown_peer_status_is_not_found() { let reg = static_registry(vec![status("beta", true)]); let err = reg.status("nope").unwrap_err(); assert_eq!(err.code(), "not_found"); assert_eq!(err.message(), "peer nope: unknown peer"); assert!(reg.contains("beta")); assert!(!reg.contains("nope")); assert!(!reg.contains("Beta")); assert!(!reg.contains("-beta")); let err = reg.status("Beta").unwrap_err(); assert_eq!(err.code(), "not_found"); assert_eq!(err.message(), "peer Beta: unknown peer"); } #[test] fn config_is_shared() { let cfg = fake_peers_config(&["beta"]); let reg = registry_with(FakeTransport::new(), cfg); let got = reg.config(); assert!(got.enabled); assert_eq!(got.peer[0].name.as_str(), "beta"); assert_eq!(got.request_timeout_secs, 2); } #[tokio::test] async fn get_forwards_and_maps_errors() { let fake = FakeTransport::new(); fake.peer("beta") .respond("/systemd/units", 200, "application/json", "{\"ok\":true}"); let reg = registry_with(fake, fake_peers_config(&["beta"])); let resp = reg .get("beta", "/systemd/units", &[], ProxyOpts::default()) .await .unwrap(); assert_eq!(resp.status, 200); match resp.body { PeerBody::Bytes(b) => assert_eq!(&b[..], b"{\"ok\":true}"), PeerBody::Stream(_) => panic!("expected buffered body"), } let err = reg .get("nope", "/x", &[], ProxyOpts::default()) .await .unwrap_err(); assert_eq!(err.code(), "not_found"); assert_eq!(err.message(), "peer nope: unknown peer"); let err = reg .get("Beta", "/x", &[], ProxyOpts::default()) .await .unwrap_err(); assert_eq!(err.message(), "peer Beta: unknown peer"); } #[tokio::test] async fn reload_keeps_surviving_status_and_prunes_removed() { let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta", "gamma"])); { let mut st = lock_write(®.state); let beta = st .statuses .get_mut(&PeerName::parse("beta").unwrap()) .unwrap(); beta.server.up = true; } let mut new = fake_peers_config(&["beta", "delta"]); new.peer[0].enabled = false; let reloaded: Result<(), PeerConfigError> = reg.reload(new).await; reloaded.unwrap(); let snap = reg.snapshot(); assert_eq!(snap.len(), 2); assert_eq!(snap[0].name.as_str(), "beta"); assert!(snap[0].server.up, "health survives a reload"); assert!(!snap[0].enabled); assert_eq!(snap[1].name.as_str(), "delta"); assert!(!snap[1].server.up); } }