Struct Reflector 

pub struct Reflector<P: Processor> { /* private fields */ }

Reflector composes a source of data with a processor that is used to transform the data, and then stores the results and allows for shared access by multiple callers.

Reflectors are a term often found in the context of custom Kubernetes controllers, where they are used to reduce the load on the Kubernetes API server by caching the state of resources in memory. Reflector provides comparable functionality, allowing for a single data source to be consumed, and then shared amongst multiple callers. However,

Reflector utilizes the concept of a “processor”, which dictates both the type of data that can be consumed and data that gets stored. This means that Reflector is more than just a cache of the data source, but also potentially a mapped version of it, allowing for transforming the data in whatever way is necessary.

Implementations

impl<P: Processor> Reflector<P>

pub async fn new<S, I>(source: S, processor: P) -> Self

where S: Stream<Item = I> + Unpin + Send + 'static, I: IntoIterator<Item = P::Input> + Send, P: 'static,

Creates a new reflector with the given data source and processor.

A reflector composes a source of data with a processor that is used to transform the data, and then stores the the processed results. It can be listened to for updates, and cheaply shared. This allows multiple interested components to subscribe to the same data source without having to duplicate the processing or storage of the data.

A task will be spawned that drives consumption of the data source and processes the items, feeding them into the reflector state, which can be queried from the returned Reflector.

Reflector is cheaply cloneable and can either be cloned for each caller or shared between them (e.g., via Arc<T>).

impl<P: Processor> Reflector<P>

pub async fn wait_for_update(&self)

Waits for the next update to the reflector.

When this method completes, callers must query the reflector to acquire the latest state.

pub fn state(&self) -> &P::State

Returns a reference a to the reflector’s state.

Trait Implementations

impl<P: Clone + Processor> Clone for Reflector<P>

fn clone(&self) -> Reflector<P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.