Struct DurableTimerService 

pub struct DurableTimerService { /* private fields */ }

Background task that fires durable timers whose instant has arrived.

Spawn DurableTimerService::run on a supervised task. It owns no timer state of its own — the durable_timers table is the source of truth — so it is safe to stop and restart: a restarted service re-reads due timers and fires any that elapsed while it was down.

Implementations

impl DurableTimerService

pub fn new(backend: Arc<DurableBackendEnum>, poll_interval: Duration) -> Self

Build the service from the shared backend and a poll cadence.

poll_interval is the worst-case latency between a timer’s instant and its firing; the promise_poll_interval_secs config value (default 2 s) is the natural source.

Examples

use std::sync::Arc;
use std::time::Duration;
use zeph_durable::{DurableBackendEnum, DurableTimerService, LocalBackend};

let backend = Arc::new(DurableBackendEnum::Local(Arc::new(
    LocalBackend::open("durable.db", 1_048_576).await?,
)));
let service = DurableTimerService::new(backend, Duration::from_secs(2));
let task = tokio::spawn(service.run());

pub async fn run(self)

Run the timer poll loop until the task is aborted.

Each tick fires every timer whose due_at has elapsed (including, on the first tick after a restart, timers that came due during downtime — FR-DE-06). A backend error is logged and the loop continues so a transient failure does not strand future timers.

Trait Implementations

impl Debug for DurableTimerService

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

Formats the value using the given formatter.