1use std::{collections::VecDeque, io::Write, net::IpAddr, sync::{Arc, Mutex}, time::{Duration, SystemTime}};
2
3use serde::{Deserialize, Serialize};
4use tokio::sync::broadcast;
5
6use crate::{DnsName, Error, Result, config::{EventHandler, EventOutput}};
7
8#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
9pub enum EventLevel { Debug, Info, Warn, Error }
10
11#[derive(Clone, Debug)]
12#[non_exhaustive]
13pub enum EventKind {
14 ManagerInitializing,
15 ManagerReady,
16 RenewalScanStarted { known_variants: usize },
17 CertificateChecked { domain: DnsName, issuer: String, not_after: i64, days_remaining: i64 },
18 RenewalDue { domain: DnsName, issuer: String, not_after: i64 },
19 RenewalStarted { domain: DnsName, issuer: String, attempt: u32 },
20 RenewalSucceeded { domain: DnsName, issuer: String, not_after: i64, elapsed: Duration },
21 RenewalFailed { domain: DnsName, issuer: String, error: String, retry_at: i64 },
22 IssuanceStarted { domain: DnsName, issuer: String, reason: String },
23 IssuanceSucceeded { domain: DnsName, issuer: String, not_after: i64, elapsed: Duration },
24 IssuanceFailed { domain: DnsName, issuer: String, error: String },
25 ChallengeInstalled { domain: DnsName },
26 ChallengeValidated { domain: DnsName },
27 ChallengeRemoved { domain: DnsName, reason: String },
28 CertificateLoaded { domain: DnsName, issuer: String },
29 CertificateSelected { domain: DnsName, issuer: String },
30 CertificateExpiredRemoved { domain: DnsName, issuer: String },
31 DnsOwnershipCheckFailed { domain: DnsName, resolved: Vec<IpAddr> },
32 DnsVerificationDisabled,
33 UnknownDomainRejected { domain: Option<DnsName> },
34 LocalCaGenerated { fingerprint: String },
35 LocalCaLoaded { fingerprint: String },
36 LocalCaReloadStarted,
37 LocalCaReplaced { old_fingerprint: String, new_fingerprint: String },
38 LocalCaReloadFailed { error: String },
39 LocalCertificateQuarantined { domain: DnsName, ca_fingerprint: String },
40 PebbleStarted { address: String },
41 PebbleStopped,
42}
43
44#[derive(Clone, Debug)]
45pub struct Event {
46 pub sequence: u64,
47 pub timestamp: SystemTime,
48 pub level: EventLevel,
49 pub kind: EventKind,
50}
51
52impl std::fmt::Display for Event {
53 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(f, "{:?} #{} {:?}", self.level, self.sequence, self.kind)
55 }
56}
57
58pub struct EventReceiver {
59 replay: VecDeque<Arc<Event>>,
60 live: broadcast::Receiver<Arc<Event>>,
61}
62
63impl EventReceiver {
64 pub async fn recv(&mut self) -> Result<Option<Arc<Event>>> {
65 if let Some(event) = self.replay.pop_front() { return Ok(Some(event)); }
66 match self.live.recv().await {
67 Ok(event) => Ok(Some(event)),
68 Err(broadcast::error::RecvError::Closed) => Ok(None),
69 Err(broadcast::error::RecvError::Lagged(n)) => Err(Error::EventLagged(n)),
70 }
71 }
72
73 pub fn try_recv(&mut self) -> Result<Option<Arc<Event>>> {
74 if let Some(event) = self.replay.pop_front() { return Ok(Some(event)); }
75 match self.live.try_recv() {
76 Ok(event) => Ok(Some(event)),
77 Err(broadcast::error::TryRecvError::Empty | broadcast::error::TryRecvError::Closed) => Ok(None),
78 Err(broadcast::error::TryRecvError::Lagged(n)) => Err(Error::EventLagged(n)),
79 }
80 }
81}
82
83pub(crate) struct EventBus {
84 sender: broadcast::Sender<Arc<Event>>,
85 presentation: std::sync::mpsc::SyncSender<Arc<Event>>,
86 state: Mutex<EventState>,
87 history_capacity: usize,
88}
89
90struct EventState { next_sequence: u64, history: VecDeque<Arc<Event>> }
91
92impl EventBus {
93 pub fn new(capacity: usize, history_capacity: usize, output: EventOutput, handler: Option<EventHandler>) -> Self {
94 let (sender, _) = broadcast::channel(capacity.max(1));
95 let (presentation, receiver) = std::sync::mpsc::sync_channel::<Arc<Event>>(capacity.max(1));
96 std::thread::Builder::new().name("acme-cert-events".into()).spawn(move || {
97 while let Ok(event) = receiver.recv() {
98 if let Some(handler) = &handler { let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| handler(&event))); }
99 match output {
100 EventOutput::Subscribe => {}
101 EventOutput::Stderr => { let _ = writeln!(std::io::stderr().lock(), "{event}"); }
102 EventOutput::Stdout => { let _ = writeln!(std::io::stdout().lock(), "{event}"); }
103 }
104 }
105 }).expect("event dispatcher thread");
106 Self { sender, presentation, state: Mutex::new(EventState { next_sequence: 1, history: VecDeque::new() }), history_capacity }
107 }
108
109 pub fn subscribe(&self) -> EventReceiver {
110 let state = self.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
111 EventReceiver { replay: state.history.clone(), live: self.sender.subscribe() }
112 }
113
114 pub fn emit(&self, level: EventLevel, kind: EventKind) {
115 let event = {
116 let mut state = self.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
117 let event = Arc::new(Event { sequence: state.next_sequence, timestamp: SystemTime::now(), level, kind });
118 state.next_sequence = state.next_sequence.saturating_add(1);
119 if self.history_capacity > 0 {
120 state.history.push_back(Arc::clone(&event));
121 while state.history.len() > self.history_capacity { state.history.pop_front(); }
122 }
123 event
124 };
125 let _ = self.sender.send(Arc::clone(&event));
126 let _ = self.presentation.try_send(event);
127 }
128}
129
130#[cfg(test)]
131mod tests {
132 use super::*;
133 #[tokio::test]
134 async fn subscription_replays_history_then_receives_live() {
135 let bus = EventBus::new(8, 8, EventOutput::Subscribe, None);
136 bus.emit(EventLevel::Info, EventKind::ManagerInitializing);
137 let mut receiver = bus.subscribe();
138 assert_eq!(receiver.recv().await.unwrap().unwrap().sequence, 1);
139 bus.emit(EventLevel::Info, EventKind::ManagerReady);
140 assert_eq!(receiver.recv().await.unwrap().unwrap().sequence, 2);
141 }
142
143 #[test]
144 fn callback_receives_structured_event_and_display_is_loggable() {
145 let (sender, receiver) = std::sync::mpsc::sync_channel(1);
146 let handler: crate::config::EventHandler = Arc::new(move |event| {
147 let _ = sender.send((event.sequence, event.to_string()));
148 });
149 let bus = EventBus::new(8, 8, EventOutput::Subscribe, Some(handler));
150 bus.emit(EventLevel::Info, EventKind::RenewalScanStarted { known_variants: 3 });
151 let (sequence, line) = receiver.recv_timeout(Duration::from_secs(2)).unwrap();
152 assert_eq!(sequence, 1);
153 assert!(line.contains("Info #1 RenewalScanStarted"));
154 assert!(line.contains("known_variants: 3"));
155 }
156
157 #[test]
158 fn panicking_callback_does_not_stop_event_dispatch() {
159 let calls = Arc::new(std::sync::atomic::AtomicUsize::new(0));
160 let observed = Arc::clone(&calls);
161 let handler: crate::config::EventHandler = Arc::new(move |_| {
162 if observed.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0 { panic!("test callback panic"); }
163 });
164 let bus = EventBus::new(8, 8, EventOutput::Subscribe, Some(handler));
165 bus.emit(EventLevel::Info, EventKind::ManagerInitializing);
166 bus.emit(EventLevel::Info, EventKind::ManagerReady);
167 let deadline = std::time::Instant::now() + Duration::from_secs(2);
168 while calls.load(std::sync::atomic::Ordering::SeqCst) < 2 && std::time::Instant::now() < deadline {
169 std::thread::yield_now();
170 }
171 assert_eq!(calls.load(std::sync::atomic::Ordering::SeqCst), 2);
172 }
173}