use std::{collections::VecDeque, io::Write, net::IpAddr, sync::{Arc, Mutex}, time::{Duration, SystemTime}};
use serde::{Deserialize, Serialize};
use tokio::sync::broadcast;
use crate::{DnsName, Error, Result, config::{EventHandler, EventOutput}};
#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
pub enum EventLevel { Debug, Info, Warn, Error }
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum EventKind {
ManagerInitializing,
ManagerReady,
RenewalScanStarted { known_variants: usize },
CertificateChecked { domain: DnsName, issuer: String, not_after: i64, days_remaining: i64 },
RenewalDue { domain: DnsName, issuer: String, not_after: i64 },
RenewalStarted { domain: DnsName, issuer: String, attempt: u32 },
RenewalSucceeded { domain: DnsName, issuer: String, not_after: i64, elapsed: Duration },
RenewalFailed { domain: DnsName, issuer: String, error: String, retry_at: i64 },
IssuanceStarted { domain: DnsName, issuer: String, reason: String },
IssuanceSucceeded { domain: DnsName, issuer: String, not_after: i64, elapsed: Duration },
IssuanceFailed { domain: DnsName, issuer: String, error: String },
ChallengeInstalled { domain: DnsName },
ChallengeValidated { domain: DnsName },
ChallengeRemoved { domain: DnsName, reason: String },
CertificateLoaded { domain: DnsName, issuer: String },
CertificateSelected { domain: DnsName, issuer: String },
CertificateExpiredRemoved { domain: DnsName, issuer: String },
DnsOwnershipCheckFailed { domain: DnsName, resolved: Vec<IpAddr> },
DnsVerificationDisabled,
UnknownDomainRejected { domain: Option<DnsName> },
LocalCaGenerated { fingerprint: String },
LocalCaLoaded { fingerprint: String },
LocalCaReloadStarted,
LocalCaReplaced { old_fingerprint: String, new_fingerprint: String },
LocalCaReloadFailed { error: String },
LocalCertificateQuarantined { domain: DnsName, ca_fingerprint: String },
PebbleStarted { address: String },
PebbleStopped,
}
#[derive(Clone, Debug)]
pub struct Event {
pub sequence: u64,
pub timestamp: SystemTime,
pub level: EventLevel,
pub kind: EventKind,
}
impl std::fmt::Display for Event {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?} #{} {:?}", self.level, self.sequence, self.kind)
}
}
pub struct EventReceiver {
replay: VecDeque<Arc<Event>>,
live: broadcast::Receiver<Arc<Event>>,
}
impl EventReceiver {
pub async fn recv(&mut self) -> Result<Option<Arc<Event>>> {
if let Some(event) = self.replay.pop_front() { return Ok(Some(event)); }
match self.live.recv().await {
Ok(event) => Ok(Some(event)),
Err(broadcast::error::RecvError::Closed) => Ok(None),
Err(broadcast::error::RecvError::Lagged(n)) => Err(Error::EventLagged(n)),
}
}
pub fn try_recv(&mut self) -> Result<Option<Arc<Event>>> {
if let Some(event) = self.replay.pop_front() { return Ok(Some(event)); }
match self.live.try_recv() {
Ok(event) => Ok(Some(event)),
Err(broadcast::error::TryRecvError::Empty | broadcast::error::TryRecvError::Closed) => Ok(None),
Err(broadcast::error::TryRecvError::Lagged(n)) => Err(Error::EventLagged(n)),
}
}
}
pub(crate) struct EventBus {
sender: broadcast::Sender<Arc<Event>>,
presentation: std::sync::mpsc::SyncSender<Arc<Event>>,
state: Mutex<EventState>,
history_capacity: usize,
}
struct EventState { next_sequence: u64, history: VecDeque<Arc<Event>> }
impl EventBus {
pub fn new(capacity: usize, history_capacity: usize, output: EventOutput, handler: Option<EventHandler>) -> Self {
let (sender, _) = broadcast::channel(capacity.max(1));
let (presentation, receiver) = std::sync::mpsc::sync_channel::<Arc<Event>>(capacity.max(1));
std::thread::Builder::new().name("acme-cert-events".into()).spawn(move || {
while let Ok(event) = receiver.recv() {
if let Some(handler) = &handler { let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| handler(&event))); }
match output {
EventOutput::Subscribe => {}
EventOutput::Stderr => { let _ = writeln!(std::io::stderr().lock(), "{event}"); }
EventOutput::Stdout => { let _ = writeln!(std::io::stdout().lock(), "{event}"); }
}
}
}).expect("event dispatcher thread");
Self { sender, presentation, state: Mutex::new(EventState { next_sequence: 1, history: VecDeque::new() }), history_capacity }
}
pub fn subscribe(&self) -> EventReceiver {
let state = self.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
EventReceiver { replay: state.history.clone(), live: self.sender.subscribe() }
}
pub fn emit(&self, level: EventLevel, kind: EventKind) {
let event = {
let mut state = self.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
let event = Arc::new(Event { sequence: state.next_sequence, timestamp: SystemTime::now(), level, kind });
state.next_sequence = state.next_sequence.saturating_add(1);
if self.history_capacity > 0 {
state.history.push_back(Arc::clone(&event));
while state.history.len() > self.history_capacity { state.history.pop_front(); }
}
event
};
let _ = self.sender.send(Arc::clone(&event));
let _ = self.presentation.try_send(event);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn subscription_replays_history_then_receives_live() {
let bus = EventBus::new(8, 8, EventOutput::Subscribe, None);
bus.emit(EventLevel::Info, EventKind::ManagerInitializing);
let mut receiver = bus.subscribe();
assert_eq!(receiver.recv().await.unwrap().unwrap().sequence, 1);
bus.emit(EventLevel::Info, EventKind::ManagerReady);
assert_eq!(receiver.recv().await.unwrap().unwrap().sequence, 2);
}
#[test]
fn callback_receives_structured_event_and_display_is_loggable() {
let (sender, receiver) = std::sync::mpsc::sync_channel(1);
let handler: crate::config::EventHandler = Arc::new(move |event| {
let _ = sender.send((event.sequence, event.to_string()));
});
let bus = EventBus::new(8, 8, EventOutput::Subscribe, Some(handler));
bus.emit(EventLevel::Info, EventKind::RenewalScanStarted { known_variants: 3 });
let (sequence, line) = receiver.recv_timeout(Duration::from_secs(2)).unwrap();
assert_eq!(sequence, 1);
assert!(line.contains("Info #1 RenewalScanStarted"));
assert!(line.contains("known_variants: 3"));
}
#[test]
fn panicking_callback_does_not_stop_event_dispatch() {
let calls = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let observed = Arc::clone(&calls);
let handler: crate::config::EventHandler = Arc::new(move |_| {
if observed.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0 { panic!("test callback panic"); }
});
let bus = EventBus::new(8, 8, EventOutput::Subscribe, Some(handler));
bus.emit(EventLevel::Info, EventKind::ManagerInitializing);
bus.emit(EventLevel::Info, EventKind::ManagerReady);
let deadline = std::time::Instant::now() + Duration::from_secs(2);
while calls.load(std::sync::atomic::Ordering::SeqCst) < 2 && std::time::Instant::now() < deadline {
std::thread::yield_now();
}
assert_eq!(calls.load(std::sync::atomic::Ordering::SeqCst), 2);
}
}