Files
skyg-linux-tracker/src/peers/registry.rs
T

265 lines
8.7 KiB
Rust

//! 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<String>,
pub accept_sse: bool,
}
struct RegistryState {
config: Arc<PeersConfig>,
statuses: BTreeMap<PeerName, PeerStatus>,
}
pub struct PeerRegistry {
transport: Arc<dyn PeerTransport>,
state: RwLock<RegistryState>,
}
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<T>(lock: &RwLock<T>) -> std::sync::RwLockReadGuard<'_, T> {
lock.read().unwrap_or_else(|e| e.into_inner())
}
fn lock_write<T>(lock: &RwLock<T>) -> std::sync::RwLockWriteGuard<'_, T> {
lock.write().unwrap_or_else(|e| e.into_inner())
}
impl PeerRegistry {
pub(crate) fn new(config: PeersConfig, transport: Arc<dyn PeerTransport>) -> 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<PeerStatus>,
config: PeersConfig,
transport: Arc<dyn PeerTransport>,
) -> 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<PeerStatus> {
lock_read(&self.state).statuses.values().cloned().collect()
}
pub fn status(&self, name: &str) -> Result<PeerStatus, AppError> {
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<PeersConfig> {
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<PeerResponse, AppError> {
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(&reg.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);
}
}