A0: contract stubs types, transport, fake and registry seams
Land the shared peer contracts: types, error mapping, transport trait, fake transport and fixtures, registry/proxy/health skeletons, the AppState.peers and Config.peers seams, the ping and peers route stubs, and unit plus integration tests. No loops, no network, feature off by default.
This commit is contained in:
1 parent
746b389a2b
commit
4bfb097be6
22 files changed
+1781
-1
No files matched your search
@@ -0,0 +1,254 @@
|
||||
//! 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::config::ConfigError;
|
||||
use crate::error::AppError;
|
||||
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> {
|
||||
lock_read(&self.state)
|
||||
.statuses
|
||||
.values()
|
||||
.find(|s| s.name.as_str() == name)
|
||||
.cloned()
|
||||
.ok_or_else(|| AppError::NotFound(format!("peer {name}: unknown peer")))
|
||||
}
|
||||
|
||||
pub fn contains(&self, name: &str) -> bool {
|
||||
lock_read(&self.state)
|
||||
.statuses
|
||||
.keys()
|
||||
.any(|n| n.as_str() == name)
|
||||
}
|
||||
|
||||
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 (peer, timeout) = {
|
||||
let st = lock_read(&self.state);
|
||||
let peer = st
|
||||
.config
|
||||
.peer
|
||||
.iter()
|
||||
.find(|p| p.name.as_str() == name)
|
||||
.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<(), ConfigError> {
|
||||
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"));
|
||||
}
|
||||
|
||||
#[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");
|
||||
}
|
||||
|
||||
#[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;
|
||||
reg.reload(new).await.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);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user