Struct apalis::prelude::Monitor

pub struct Monitor<E> { /* private fields */ }

A monitor for coordinating and managing a collection of workers.

Implementations

impl<E> Monitor<E>

where E: Executor + Clone + Send + 'static + Sync,

pub fn register<J, S, P>(self, worker: Worker<Ready<S, P>>) -> Monitor<E>

where J: Send + Sync + 'static, S: Service<Request<J>> + Send + 'static + Clone, P: Backend<Request<J>> + 'static, <S as Service<Request<J>>>::Future: Send, <S as Service<Request<J>>>::Response: 'static, <S as Service<Request<J>>>::Error: Send + Sync + 'static + Into<Box<dyn Error + Sync + Send>>, <P as Backend<Request<J>>>::Stream: Unpin + Send + 'static,

Registers a single instance of a Worker

pub fn register_with_count<J, S, P>( self, count: usize, worker: Worker<Ready<S, P>> ) -> Monitor<E>

where J: Send + Sync + 'static, S: Service<Request<J>> + Send + 'static + Clone, P: Backend<Request<J>> + 'static, <S as Service<Request<J>>>::Future: Send, <S as Service<Request<J>>>::Response: 'static, <S as Service<Request<J>>>::Error: Send + Sync + 'static + Into<Box<dyn Error + Sync + Send>>, <P as Backend<Request<J>>>::Stream: Unpin + Send + 'static,

Registers multiple workers with the monitor.

Arguments

• count - The number of workers to register.
• worker - A Worker that is ready for running.

Returns

The monitor instance, with all workers added to the collection.

pub async fn run_with_signal<S>(self, signal: S) -> Result<(), Error>

where S: Future<Output = Result<(), Error>>, E: Executor + Clone + Send + 'static,

Runs the monitor and all its registered workers until they have all completed or a shutdown signal is received.

Arguments

• signal - A Future that resolves when a shutdown signal is received.

Errors

If the monitor fails to shutdown gracefully, an std::io::Error will be returned.

pub async fn run(self) -> Result<(), Error>

where E: Executor + Clone + Send + 'static,

Runs the monitor and all its registered workers until they have all completed.

Errors

If the monitor fails to shutdown gracefully, an std::io::Error will be returned.

Remarks

If a timeout has been set using the shutdown_timeout method, the monitor will wait for all workers to complete up to the timeout duration before exiting. If the timeout is reached and workers have not completed, the monitor will exit forcefully.

pub fn on_event<F>(self, f: F) -> Monitor<E>

where F: Fn(Worker<Event>) + Send + Sync + 'static,

Handles events emitted

pub fn executor(&self) -> &E

Get the current executor

impl<E> Monitor<E>

pub fn new() -> Monitor<E>

where E: Default,

Creates a new monitor instance.

Returns

A new monitor instance, with an empty collection of workers.

pub fn new_with_executor(executor: E) -> Monitor<E>

Creates a new monitor instance with an executor

Returns

A new monitor instance, with an empty collection of workers.

pub fn set_executor<NE>(self, executor: NE) -> Monitor<NE>

where NE: Executor,

Sets a custom executor for the monitor, allowing the usage of another runtime apart from Tokio. The executor must implement the Executor trait.

pub fn shutdown_timeout(self, duration: Duration) -> Monitor<E>

Sets a timeout duration for the monitor’s shutdown process.

Arguments

• duration - The timeout duration.

Returns

The monitor instance, with the shutdown timeout duration set.

pub fn with_terminator( self, fut: impl Future<Output = ()> + Send + 'static ) -> Monitor<E>

Sets a future that will start being polled when the monitor’s shutdown process starts.

After shutdown has been initiated, the terminator future will be run, and if it completes before all tasks are completed the shutdown process will complete, thus finishing the shutdown even if there are outstanding tasks. This can be useful for using a timeout or signal (or combination) to force a full shutdown even if one or more tasks are taking longer than expected to finish.

Trait Implementations

impl<E> Debug for Monitor<E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<E> Default for Monitor<E>

where E: Default,

fn default() -> Monitor<E>

Returns the “default value” for a type.