Struct InputTracker 

pub struct InputTracker { /* private fields */ }

Tracks the health state and last known value of each input.

Use this helper to implement graceful degradation when upstream nodes time out (via input_timeout). It caches the last received ArrowData per input so your node can fall back to stale data instead of crashing.

The cache is bounded by the number of distinct input IDs declared in the dataflow YAML. Since input IDs are fixed at dataflow compile time, the cache cannot grow unboundedly.

Example

let mut tracker = InputTracker::new();
while let Some(event) = events.recv().await {
    tracker.process_event(&event);
    match event {
        Event::Input { id, data, .. } => { /* use fresh data */ }
        Event::InputClosed { id } => {
            if let Some(stale) = tracker.last_value(&id) {
                /* degrade gracefully using cached value */
            }
        }
        _ => {}
    }
}

Implementations

impl InputTracker

pub fn new() -> Self

Create a new, empty tracker.

Without a source map, NodeRestarted events are acknowledged (return true from process_event) but do not mutate state, because the tracker cannot determine which inputs a given node feeds. If you use fault-tolerance restart policies, prefer InputTracker::with_source_map so closed inputs recover automatically when the upstream comes back up.

pub fn with_source_map(source_map: HashMap<DataId, NodeId>) -> Self

Create a tracker that knows which input is fed by which upstream node. With this map populated, NodeRestarted { id } events transition any Closed inputs sourced from id back to Healthy.

The map can be built from the dataflow’s input_config at initialization time — for each user input (data_id, source_node) insert the pair here.

pub fn process_event(&mut self, event: &Event) -> bool

Update tracker state from an event. Returns true if the event was relevant to input tracking (Input, InputClosed, InputRecovered, or NodeRestarted).

pub fn state(&self, id: &DataId) -> Option<InputState>

Get the current state of an input, if tracked.

pub fn is_closed(&self, id: &DataId) -> bool

Check if an input is currently closed (timed out or upstream exited).

pub fn last_value(&self, id: &DataId) -> Option<&ArrowData>

Get the last received value for an input. Available even when closed.

pub fn closed_inputs(&self) -> Vec<&DataId>

Return all inputs that are currently closed.

pub fn any_closed(&self) -> bool

Check if any tracked input is currently closed.

Trait Implementations

impl Default for InputTracker

fn default() -> Self

Returns the “default value” for a type.