Skip to main content

rustls_letsencrypt/
event.rs

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}