Struct Scheduler 

pub struct Scheduler {
    specs: Vec<SourceSpec>,
    leases: Vec<Lease>,
    state: HashMap<SourceId, SourceState>,
    coalesce_ms: u64,
}

Fields

specs: Vec<SourceSpec>

leases: Vec<Lease>

state: HashMap<SourceId, SourceState>

coalesce_ms: u64

Sources due within this much of each other run in one pass, so a shared input (one process snapshot) is read once for all of them.

Implementations

impl Scheduler

pub fn new(specs: Vec<SourceSpec>, coalesce_ms: u64) -> Self

specs in dependency order: each source’s needs come before it.

pub fn lease( &mut self, holder: &str, source: SourceId, interval_ms: u64, expires_at: Option<u64>, now: u64, )

holder wants source every interval_ms until expires_at (None: until released). A holder has one lease per source, so asking again renews it.

pub fn release(&mut self, holder: &str, now: u64)

Drops all of holder’s leases.

pub fn release_source(&mut self, holder: &str, source: SourceId, now: u64)

Drops holder’s lease on source.

fn reschedule(&mut self, source: SourceId, now: u64)

The leases changed, so the interval may have: a source that already ran is next due one (new) interval after that run, sooner or later than it was planned, and a pending run isn’t kept for a viewer that has gone.

fn spec(&self, id: SourceId) -> &SourceSpec

fn live(&self, source: SourceId, now: u64) -> impl Iterator<Item = &Lease>

pub fn effective_interval_ms(&self, source: SourceId, now: u64) -> Option<u64>

Between runs now: the shortest live lease, floored at the source’s minimum, times its stretch. None with no live lease.

pub fn due(&mut self, now: u64) -> Vec<SourceId>

The sources to run now, dependencies first, each once. A source with no live lease isn’t run, and starts at once when it gets one.

pub fn next_wakeup(&self, now: u64) -> Option<u64>

When to call Self::due next; None when nothing is leased.

pub fn finished(&mut self, id: SourceId, started: u64, took_ms: u64)

A run of id that started at started took took_ms. Schedules its next run from its start, never sooner than its end, and never to make up for a late one: a source that fell behind is counted as having skipped.

pub fn status(&self, now: u64) -> Vec<SourceStatus>