Struct FnWorker 

pub struct FnWorker { /* private fields */ }

A Supervisable worker built from a plain future.

This is the ordinary kind of supervised child: a piece of asynchronous work that runs until it reaches its own terminal condition – an input channel closing, a loop finishing, a request completing.

Shutdown

An FnWorker is never handed a shutdown signal, and reports as much through wants_shutdown_signal. Shutdown of a subtree is a trigger, not an enforcement: the workers within it keep running until their terminal conditions are reached, which is what lets a set of tasks connected by channels drain in dependency order without any of them having to know that order. The supervisor’s shutdown budget is the backstop for work that takes too long, and ShutdownStrategy::Brutal is the answer for work that has no terminal condition at all.

A worker that genuinely needs to observe shutdown – to run cleanup, or because it has no other way to know it should stop – should implement Supervisable directly, which does receive the signal.

This worker cannot be restarted, as the future is consumed during initialization.

Implementations

impl FnWorker

pub fn new<N, Fut>(name: N, fut: Fut) -> Self

where N: Into<String>, Fut: Future + Send + 'static, Fut::Output: IntoWorkerResult,

Creates a worker that runs fut to completion.

Workers may return either () or Result<(), GenericError>.

Prefer worker and its counterparts on SupervisorHandle, which wrap this up with the defaults appropriate to a dynamically spawned child.

Examples

let worker = FnWorker::new("queue_drainer", drain_queue());

Trait Implementations

impl Supervisable for FnWorker

fn name(&self) -> &str

Returns the name of the process.

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.

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.