Struct ShutdownProbe 

pub struct ShutdownProbe { /* private fields */ }

Polls a set of ShutdownComponents until they all drain or the deadline elapses.

Example

use dev_async::shutdown::{ShutdownComponent, ShutdownProbe};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;

let drained = Arc::new(AtomicBool::new(true));
let comp = {
    let drained = drained.clone();
    ShutdownComponent::new("worker", move || {
        let d = drained.clone();
        async move { d.load(Ordering::Relaxed) }
    })
};

let probe = ShutdownProbe::new("system")
    .deadline(Duration::from_millis(200))
    .poll_interval(Duration::from_millis(10))
    .with_component(comp);

let checks = probe.run().await;
assert!(!checks.is_empty());

Implementations

impl ShutdownProbe

pub fn new(name: impl Into<String>) -> Self

Begin building a probe with a stable name.

pub fn deadline(self, d: Duration) -> Self

Maximum time to wait for the system to drain.

pub fn poll_interval(self, d: Duration) -> Self

How often to re-evaluate each component’s drain predicate.

pub fn with_component(self, component: ShutdownComponent) -> Self

Add a component to the probe.

pub async fn run(self) -> Vec<CheckResult>

Run the probe and return one CheckResult per component plus an aggregate.

Per-component verdicts:

• Drained before deadline -> Pass with elapsed_ms evidence.
• Did not drain in time -> Fail (Error) with not_drained tag.

The aggregate verdict is Fail if any component failed, otherwise Pass. It is the last entry in the returned vector and tagged aggregate.