use serde::Serialize;
use std::collections::VecDeque;
use std::sync::Mutex;
use tokio::sync::broadcast;
pub const RING: usize = 256;
pub const TYPES: &[&str] = &[
"summary.changed",
"job.started",
"job.finished",
"policy.changed",
"sandbox.state",
"squad.changed",
"env.state",
"problem.raised",
"problem.cleared",
];
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct Event {
pub id: u64,
#[serde(rename = "type")]
pub kind: String,
pub at: String,
pub data: serde_json::Value,
}
#[derive(Debug, PartialEq)]
pub enum Replay {
Events(Vec<Event>),
Resync,
}
pub struct EventBus {
ring: Mutex<VecDeque<Event>>,
next: Mutex<u64>,
tx: broadcast::Sender<Event>,
}
impl Default for EventBus {
fn default() -> Self {
Self::new()
}
}
impl EventBus {
pub fn new() -> Self {
let (tx, _) = broadcast::channel(RING);
Self {
ring: Mutex::new(VecDeque::with_capacity(RING)),
next: Mutex::new(1),
tx,
}
}
pub fn publish(&self, kind: &str, data: serde_json::Value) -> u64 {
debug_assert!(TYPES.contains(&kind), "unknown event type {kind}");
let mut next = self.next.lock().unwrap();
let id = *next;
*next += 1;
let event = Event {
id,
kind: kind.to_string(),
at: chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true),
data,
};
let mut ring = self.ring.lock().unwrap();
if ring.len() == RING {
ring.pop_front();
}
ring.push_back(event.clone());
let _ = self.tx.send(event);
id
}
pub fn last_id(&self) -> u64 {
*self.next.lock().unwrap() - 1
}
pub fn subscribe(&self, last_seen: Option<u64>) -> (Replay, broadcast::Receiver<Event>) {
let next = self.next.lock().unwrap();
let ring = self.ring.lock().unwrap();
let rx = self.tx.subscribe();
let replay = match last_seen {
None => Replay::Events(vec![]),
Some(seen) if seen >= *next => Replay::Resync, Some(seen) => {
let oldest = ring.front().map_or(*next, |e| e.id);
if seen + 1 < oldest {
Replay::Resync
} else {
Replay::Events(ring.iter().filter(|e| e.id > seen).cloned().collect())
}
}
};
(replay, rx)
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn ids_increase_and_a_reconnect_gets_what_it_missed() {
let bus = EventBus::new();
assert_eq!(bus.last_id(), 0);
let a = bus.publish("job.started", json!({"id": "j1"}));
let b = bus.publish("job.finished", json!({"id": "j1"}));
assert_eq!((a, b, bus.last_id()), (1, 2, 2));
let (replay, _) = bus.subscribe(Some(1));
match replay {
Replay::Events(ev) => {
assert_eq!(ev.len(), 1);
assert_eq!((ev[0].id, ev[0].kind.as_str()), (2, "job.finished"));
}
other => panic!("{other:?}"),
}
assert_eq!(bus.subscribe(Some(2)).0, Replay::Events(vec![]));
assert_eq!(bus.subscribe(None).0, Replay::Events(vec![]));
let (replay, _) = bus.subscribe(Some(0));
assert!(matches!(replay, Replay::Events(ref e) if e.len() == 2));
}
#[test]
fn too_far_behind_or_from_another_run_is_a_resync() {
let bus = EventBus::new();
for i in 0..(RING + 10) {
bus.publish("summary.changed", json!({ "n": i }));
}
assert_eq!(
bus.subscribe(Some(1)).0,
Replay::Resync,
"fell off the ring"
);
assert_eq!(
bus.subscribe(Some(10_000)).0,
Replay::Resync,
"an id this run never issued"
);
let last = bus.last_id();
match bus.subscribe(Some(last - 3)).0 {
Replay::Events(ev) => assert_eq!(ev.len(), 3),
other => panic!("{other:?}"),
}
let oldest = last - RING as u64 + 1;
match bus.subscribe(Some(oldest - 1)).0 {
Replay::Events(ev) => assert_eq!(ev.len(), RING),
other => panic!("{other:?}"),
}
}
#[test]
fn a_subscriber_receives_events_published_after_it_subscribed() {
let bus = EventBus::new();
bus.publish("summary.changed", json!({}));
let (_, mut rx) = bus.subscribe(None);
bus.publish("problem.raised", json!({"code": "uv_missing"}));
let e = rx.try_recv().unwrap();
assert_eq!((e.id, e.kind.as_str()), (2, "problem.raised"));
let wire = serde_json::to_value(&e).unwrap();
assert_eq!(wire["type"], "problem.raised");
assert!(wire["at"].as_str().unwrap().ends_with('Z'));
}
}