265 lines
8.7 KiB
Rust
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(®.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);
|
|
}
|
|
}
|