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.
349 lines
11 KiB
Rust
349 lines
11 KiB
Rust
//! Fixture-backed in-memory sources for tests and for developing surfaces
|
|
//! without systemd, journald or Docker.
|
|
//!
|
|
//! `fake_state(config)` returns a ready `AppState`.
|
|
|
|
use std::sync::Arc;
|
|
|
|
use async_trait::async_trait;
|
|
use jiff::Timestamp;
|
|
use tokio::sync::mpsc;
|
|
use tokio_util::sync::CancellationToken;
|
|
|
|
use super::{
|
|
clamp_count, ContainerStatus, ContainerSummary, DockerSource, JournalEntry, JournalQuery,
|
|
JournalSource, LogLine, LogOptions, LogStream, Priority, SystemdSource, TimerInfo, UnitStatus,
|
|
UnitSummary,
|
|
};
|
|
use crate::config::Config;
|
|
use crate::error::AppError;
|
|
use crate::state::AppState;
|
|
|
|
fn ts(s: &str) -> Timestamp {
|
|
s.parse().expect("valid fixture timestamp")
|
|
}
|
|
|
|
/// An `AppState` backed by the fakes, without a DB pool.
|
|
pub fn fake_state(config: Config) -> AppState {
|
|
let shutdown = CancellationToken::new();
|
|
AppState {
|
|
config: Arc::new(config),
|
|
systemd: Arc::new(FakeSystemd::default()),
|
|
journal: Arc::new(FakeJournal::new(shutdown.clone())),
|
|
docker: Arc::new(FakeDocker::new(shutdown.clone())),
|
|
db: None,
|
|
peers: None,
|
|
shutdown,
|
|
}
|
|
}
|
|
|
|
struct FakeSystemd {
|
|
units: Vec<UnitStatus>,
|
|
timers: Vec<TimerInfo>,
|
|
}
|
|
|
|
impl Default for FakeSystemd {
|
|
fn default() -> Self {
|
|
let unit = |name: &str, desc: &str, active: &str, sub: &str, service: bool| UnitStatus {
|
|
name: name.into(),
|
|
description: desc.into(),
|
|
load_state: "loaded".into(),
|
|
active_state: active.into(),
|
|
sub_state: sub.into(),
|
|
fragment_path: Some(format!("/etc/systemd/system/{name}")),
|
|
unit_file_state: Some("enabled".into()),
|
|
active_enter_time: Some(ts("2026-10-15T08:00:00Z")),
|
|
active_exit_time: None,
|
|
main_pid: service.then_some(1234),
|
|
exec_main_status: service.then_some(if active == "failed" { 1 } else { 0 }),
|
|
n_restarts: service.then_some(if active == "failed" { 5 } else { 0 }),
|
|
result: service.then(|| {
|
|
if active == "failed" {
|
|
"exit-code"
|
|
} else {
|
|
"success"
|
|
}
|
|
.into()
|
|
}),
|
|
};
|
|
Self {
|
|
units: vec![
|
|
unit("sshd.service", "OpenSSH Daemon", "active", "running", true),
|
|
unit(
|
|
"nginx.service",
|
|
"Nginx web server",
|
|
"failed",
|
|
"failed",
|
|
true,
|
|
),
|
|
unit(
|
|
"logrotate.timer",
|
|
"Daily rotation of log files",
|
|
"active",
|
|
"waiting",
|
|
false,
|
|
),
|
|
],
|
|
timers: vec![TimerInfo {
|
|
name: "logrotate.timer".into(),
|
|
unit: "logrotate.service".into(),
|
|
active_state: "active".into(),
|
|
next_elapse: Some(ts("2026-10-16T00:00:00Z")),
|
|
last_trigger: Some(ts("2026-10-15T00:00:00Z")),
|
|
}],
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl SystemdSource for FakeSystemd {
|
|
async fn list_units(&self, state: Option<&str>) -> Result<Vec<UnitSummary>, AppError> {
|
|
Ok(self
|
|
.units
|
|
.iter()
|
|
.filter(|u| state.is_none_or(|s| u.active_state == s))
|
|
.map(|u| UnitSummary {
|
|
name: u.name.clone(),
|
|
description: u.description.clone(),
|
|
load_state: u.load_state.clone(),
|
|
active_state: u.active_state.clone(),
|
|
sub_state: u.sub_state.clone(),
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
async fn list_timers(&self) -> Result<Vec<TimerInfo>, AppError> {
|
|
Ok(self.timers.clone())
|
|
}
|
|
|
|
async fn unit_status(&self, name: &str) -> Result<UnitStatus, AppError> {
|
|
self.units
|
|
.iter()
|
|
.find(|u| u.name == name)
|
|
.cloned()
|
|
.ok_or_else(|| AppError::NotFound(format!("unit not loaded or unknown: {name}")))
|
|
}
|
|
}
|
|
|
|
struct FakeJournal {
|
|
entries: Vec<JournalEntry>,
|
|
shutdown: CancellationToken,
|
|
}
|
|
|
|
impl FakeJournal {
|
|
fn new(shutdown: CancellationToken) -> Self {
|
|
let e = |t: &str, p: Priority, unit: &str, msg: &str| JournalEntry {
|
|
timestamp: ts(t),
|
|
priority: Some(p),
|
|
unit: Some(unit.into()),
|
|
identifier: Some(unit.trim_end_matches(".service").into()),
|
|
pid: Some(1234),
|
|
hostname: Some("fakehost".into()),
|
|
message: msg.into(),
|
|
cursor: Some(format!("s={t}")),
|
|
};
|
|
Self {
|
|
entries: vec![
|
|
e(
|
|
"2026-10-15T08:00:01Z",
|
|
Priority::Info,
|
|
"sshd.service",
|
|
"Server listening on 0.0.0.0 port 22.",
|
|
),
|
|
e(
|
|
"2026-10-15T08:05:00Z",
|
|
Priority::Err,
|
|
"nginx.service",
|
|
"bind() to 0.0.0.0:80 failed",
|
|
),
|
|
e(
|
|
"2026-10-15T08:05:01Z",
|
|
Priority::Crit,
|
|
"nginx.service",
|
|
"nginx.service: Failed with result 'exit-code'.",
|
|
),
|
|
],
|
|
shutdown,
|
|
}
|
|
}
|
|
|
|
fn matching(&self, q: &JournalQuery) -> Vec<JournalEntry> {
|
|
self.entries
|
|
.iter()
|
|
.filter(|e| {
|
|
q.unit
|
|
.as_deref()
|
|
.is_none_or(|u| e.unit.as_deref() == Some(u))
|
|
})
|
|
.filter(|e| {
|
|
q.priority
|
|
.is_none_or(|p| e.priority.is_some_and(|ep| ep <= p))
|
|
})
|
|
.filter(|e| q.since.is_none_or(|s| e.timestamp >= s))
|
|
.cloned()
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl JournalSource for FakeJournal {
|
|
async fn query(&self, q: &JournalQuery) -> Result<Vec<JournalEntry>, AppError> {
|
|
let all = self.matching(q);
|
|
let n = clamp_count(q.lines, usize::MAX);
|
|
let skip = all.len().saturating_sub(n);
|
|
Ok(all.into_iter().skip(skip).collect())
|
|
}
|
|
|
|
/// Sends the matching backlog, then idles until the receiver is dropped
|
|
/// or shutdown fires.
|
|
async fn follow(&self, q: &JournalQuery) -> Result<mpsc::Receiver<JournalEntry>, AppError> {
|
|
let backlog = self.query(q).await?;
|
|
let (tx, rx) = mpsc::channel(64);
|
|
let shutdown = self.shutdown.clone();
|
|
tokio::spawn(async move {
|
|
for e in backlog {
|
|
if tx.send(e).await.is_err() {
|
|
return;
|
|
}
|
|
}
|
|
tokio::select! {
|
|
() = tx.closed() => {}
|
|
() = shutdown.cancelled() => {}
|
|
}
|
|
});
|
|
Ok(rx)
|
|
}
|
|
}
|
|
|
|
struct FakeDocker {
|
|
containers: Vec<ContainerStatus>,
|
|
logs: Vec<LogLine>,
|
|
shutdown: CancellationToken,
|
|
}
|
|
|
|
impl FakeDocker {
|
|
fn new(shutdown: CancellationToken) -> Self {
|
|
let c = |id: &str, name: &str, state: &str, health: Option<&str>| ContainerStatus {
|
|
summary: ContainerSummary {
|
|
id: id.into(),
|
|
name: name.into(),
|
|
image: format!("{name}:latest"),
|
|
state: state.into(),
|
|
health: health.map(Into::into),
|
|
created: Some(ts("2026-10-14T00:00:00Z")),
|
|
started_at: Some(ts("2026-10-14T00:00:05Z")),
|
|
uptime_seconds: (state == "running").then_some(3600),
|
|
restart_count: Some(0),
|
|
},
|
|
finished_at: None,
|
|
exit_code: None,
|
|
oom_killed: Some(false),
|
|
health_output: health.map(|h| format!("probe says {h}")),
|
|
};
|
|
Self {
|
|
containers: vec![
|
|
c("aaaa1111", "web", "running", Some("healthy")),
|
|
c("bbbb2222", "db", "running", None),
|
|
c("cccc3333", "job", "exited", None),
|
|
],
|
|
logs: vec![
|
|
LogLine {
|
|
stream: LogStream::Stdout,
|
|
ts: Some(ts("2026-10-15T09:00:00Z")),
|
|
message: "ready".into(),
|
|
},
|
|
LogLine {
|
|
stream: LogStream::Stderr,
|
|
ts: Some(ts("2026-10-15T09:00:01Z")),
|
|
message: "warning: slow query".into(),
|
|
},
|
|
],
|
|
shutdown,
|
|
}
|
|
}
|
|
|
|
fn find(&self, name: &str) -> Result<&ContainerStatus, AppError> {
|
|
self.containers
|
|
.iter()
|
|
.find(|c| c.summary.name == name || c.summary.id == name)
|
|
.ok_or_else(|| AppError::NotFound(format!("container {name}")))
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl DockerSource for FakeDocker {
|
|
async fn ps(&self, all: bool) -> Result<Vec<ContainerSummary>, AppError> {
|
|
Ok(self
|
|
.containers
|
|
.iter()
|
|
.filter(|c| all || c.summary.state == "running")
|
|
.map(|c| c.summary.clone())
|
|
.collect())
|
|
}
|
|
|
|
async fn container_status(&self, name: &str) -> Result<ContainerStatus, AppError> {
|
|
self.find(name).cloned()
|
|
}
|
|
|
|
async fn logs(&self, name: &str, opts: &LogOptions) -> Result<Vec<LogLine>, AppError> {
|
|
self.find(name)?;
|
|
let n = clamp_count(opts.tail, usize::MAX);
|
|
let skip = self.logs.len().saturating_sub(n);
|
|
Ok(self.logs.iter().skip(skip).cloned().collect())
|
|
}
|
|
|
|
async fn follow_logs(
|
|
&self,
|
|
name: &str,
|
|
opts: &LogOptions,
|
|
) -> Result<mpsc::Receiver<LogLine>, AppError> {
|
|
let backlog = self.logs(name, opts).await?;
|
|
let (tx, rx) = mpsc::channel(64);
|
|
let shutdown = self.shutdown.clone();
|
|
tokio::spawn(async move {
|
|
for l in backlog {
|
|
if tx.send(l).await.is_err() {
|
|
return;
|
|
}
|
|
}
|
|
tokio::select! {
|
|
() = tx.closed() => {}
|
|
() = shutdown.cancelled() => {}
|
|
}
|
|
});
|
|
Ok(rx)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[tokio::test]
|
|
async fn fakes_behave() {
|
|
let st = fake_state(Config::default());
|
|
assert_eq!(
|
|
st.systemd.list_units(Some("failed")).await.unwrap().len(),
|
|
1
|
|
);
|
|
assert!(matches!(
|
|
st.systemd.unit_status("nope.service").await,
|
|
Err(AppError::NotFound(_))
|
|
));
|
|
let q = JournalQuery {
|
|
priority: Some(Priority::Err),
|
|
..Default::default()
|
|
};
|
|
assert_eq!(st.journal.query(&q).await.unwrap().len(), 2);
|
|
assert_eq!(st.docker.ps(false).await.unwrap().len(), 2);
|
|
let mut rx = st
|
|
.docker
|
|
.follow_logs("web", &LogOptions::default())
|
|
.await
|
|
.unwrap();
|
|
assert!(rx.recv().await.is_some());
|
|
st.shutdown.cancel();
|
|
while rx.recv().await.is_some() {}
|
|
}
|
|
}
|