Struct ReflectorWorker 

pub struct ReflectorWorker<P: Processor, S> { /* private fields */ }

A worker that drives a Reflector’s data source.

Consumes items from the source and feeds them through the processor into the reflector’s shared state. Until this worker runs, the reflector it was created with reports only the initial state its processor built.

The source is retained across restarts rather than being rebuilt, so a worker that fails and is restarted resumes from wherever the source left off. That matters for a source backed by a subscription: rebuilding it would drop whatever accumulated while the worker was down.

Register this worker as transient rather than with the permanent default of Supervisor::add_worker. An exhausted source is terminal here: the worker returns normally once the source ends, and the retained source means a restart would only feed it the same dead source, exit immediately again, and burn through the supervisor’s restart budget. Transient leaves it stopped instead, which is the intended outcome. A source that cannot end – a subscription held open for the life of the process, say – never reaches this case, but nothing about the type guarantees that.

Trait Implementations

impl<P, S, I> Supervisable for ReflectorWorker<P, S>

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

fn name(&self) -> &str

Returns the name of the process.

fn initialize<'life0, 'async_trait>( &'life0 self, process_shutdown: ShutdownHandle, ) -> Pin<Box<dyn Future<Output = Result<SupervisorFuture, InitializationError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Initializes the process asynchronously.

fn shutdown_strategy(&self) -> ShutdownStrategy

Returns the shutdown strategy for the process.

fn wants_shutdown_signal(&self) -> bool

Returns whether this process observes the shutdown signal it is given.