Struct HealthState 

pub struct HealthState {
    ticks: AtomicU64,
    last_tick_unix: AtomicI64,
    started_unix: i64,
    certificates: OnceLock<Arc<dyn CertificateAlerts>>,
    data_dir: OnceLock<(PathBuf, DiskWatermarks)>,
    disk_alert: AtomicU8,
}

The tick’s pulse, shared with whoever answers GET /health.

Kept separate from HealthTick itself so a caller can hand the state to the HTTP router and the join handle to nothing but the shutdown path — the router has no business awaiting the task or aborting it, only reading the counters.

Fields

ticks: AtomicU64

How many ticks have fired since the process started.

last_tick_unix: AtomicI64

Unix seconds of the most recent tick, or 0 for “never yet” — the first tick fires one interval after startup, by design; see HealthTick::spawn.

started_unix: i64

Unix seconds this state was created, which is startup for all practical purposes: it is built and handed to HealthTick::spawn in the same breath the tick task is.

certificates: OnceLock<Arc<dyn CertificateAlerts>>

Whoever can answer for the certificates, once there is one — see HealthState::attach_certificates for why this is filled in after the router is already serving rather than passed to the constructor.

data_dir: OnceLock<(PathBuf, DiskWatermarks)>

The data directory whose volume HealthState::disk reads, and the watermarks its free space is measured against; see HealthState::attach_data_dir.

disk_alert: AtomicU8

The DiskAlert the last tick read, as its u8: ok before one has.

Implementations

impl HealthState

pub fn new() -> Arc<Self>

A fresh state, stamped with the current time as its start.

fn record_tick(&self)

Records that a tick just fired.

pub fn attach_certificates(&self, alerts: Arc<dyn CertificateAlerts>)

Names who can answer for the certificates.

Separate from HealthState::new because of the order the binary builds things in: the router — and this state with it — exists before the ACME fleet does, since the fleet is bootstrapped by the code that is handed the finished router to serve. The first call wins and later ones are ignored, so a second fleet cannot quietly replace the one the listener is actually serving certificates from.

pub fn attach_data_dir(&self, dir: PathBuf, watermarks: DiskWatermarks)

Names the data directory whose volume HealthState::disk reads, and the watermarks its free space is measured against.

The first call wins, as it does for HealthState::attach_certificates. A state nothing names has no volume to read, which is every in-memory run.

pub async fn disk(&self) -> Option<DiskHealth>

The data volume’s free and total bytes, read as this is called.

Read on the blocking pool, because statvfs asks the filesystem, and a volume that has stopped answering must not hold an async worker. None when no data directory was named, and when the read fails, which is logged.

pub(crate) fn watch_disk(&self, disk: &DiskHealth) -> Option<DiskAlert>

Writes a line when disk has crossed a watermark since the last reading: warn going down, info coming back up. A first reading below a watermark is a crossing. Answers the alert it wrote about.

pub async fn certificates(&self) -> CertificateHealth

The certificate half of the health response.

async, and so kept out of HealthState::snapshot: the levels are read from the renewal trackers themselves rather than from a copy something has to remember to refresh, which is what makes a warning in this response and a warning in the log the same fact.

pub fn snapshot(&self) -> HealthSnapshot

A point-in-time read, safe to serialize into an HTTP response.

Trait Implementations

impl Debug for HealthState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for HealthState

fn default() -> HealthState

Returns the “default value” for a type.