rustls-letsencrypt 0.1.4

Automatic Let's Encrypt, ACME, and local-CA certificate management for rustls listeners
Documentation
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);
    }
}