Struct srvzio::manager::ServiceManager

pub struct ServiceManager { /* fields omitted */ }

Manages an internal collection of Services

This implements a simple Composite Pattern that allows to manages a group of Service in a coordinated fashion.

Services are start()ed in the order they are registered, and stop()ped in the reverse order. Also, a ServiceManager is also a Service, so further composition is possible.

The design implies that in your application, you would hand over all the instances of Service to a ServiceManager, that will then orchestrate their starting and stopping.

Thanks to the use of Composite Pattern, it can contain further instances of ServiceManager, allowing for the creation of complex DAG diagrams of services, with expressive relationship between them.

Methods

impl ServiceManager

pub fn new() -> Self

Constructor

pub fn register(&mut self, service_box: Box<dyn Service>)

Register an instance of Service.

The order of registration is important: Services are started in order, and stopped in reverse order.

Parameters

• service_box: a Box containing an instance of implementation of the Service trait

pub fn wait_termination_signal_then_stop(&mut self)

Wait for the Process to receive a termination signal, then stop this ServiceManager.

It's strongly advised to use this method only onces, for the root ServiceManager, at the end of the main() thread.

Trait Implementations

impl Service for ServiceManager

fn start(&mut self)

Start all registered Services, in order of registration

fn await_started(&mut self)

Wait for all registered Services to be started, in order of registration

fn start_and_await(&mut self)

Start and then wait for all registered Service, in order of registration

This is different then calling start() and then await_started(), because this method will wait for a Service to be started, before moving to the next one.

This can be used to implement a gracefull start.

fn stop(&mut self)

Stop all registered Services, in reverse order of registration

fn await_stopped(&mut self)

Wait for all registered Services to be stopped, in reverse order of registration

fn stop_and_await(&mut self)

Stop and then wait for all registered Service, in reverse order of registration

This is different then calling stop() and then await_stopped(), because this method will wait for a Service to be stopped, before moving to the next one.

This can be used to implement a gracefull stop.