Struct Supervisor

pub struct Supervisor;

The supervisor actor itself.
Spawns its children in post_start, listens for child failures, and restarts them if needed.
If meltdown occurs, it returns an error to end abnormally (thus skipping post_stop).

Implementations

impl Supervisor

pub async fn spawn_linked<T: Actor>( name: ActorName, handler: T, startup_args: T::Arguments, supervisor: ActorCell, ) -> Result<(ActorRef<T::Msg>, JoinHandle<()>), SpawnErr>

pub async fn spawn( name: ActorName, startup_args: SupervisorArguments, ) -> Result<(ActorRef<SupervisorMsg>, JoinHandle<()>), SpawnErr>

Trait Implementations

impl Actor for Supervisor

fn handle<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, msg: SupervisorMsg, state: &'life1 mut SupervisorState, ) -> Pin<Box<dyn Future<Output = Result<(), ActorProcessingErr>> + Send + 'async_trait>>

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

The main message handler: we respond to “spawn child X” or “inspect state”. Each time we finish, we store final state in a global map (test usage only).

fn handle_supervisor_evt<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, evt: SupervisionEvent, state: &'life1 mut Self::State, ) -> Pin<Box<dyn Future<Output = Result<(), ActorProcessingErr>> + Send + 'async_trait>>

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

Respond to supervision events from child actors.

• ActorTerminated => treat as normal exit
• ActorFailed => treat as abnormal

fn post_stop<'life0, 'life1, 'async_trait>( &'life0 self, _myself: ActorRef<Self::Msg>, _state: &'life1 mut Self::State, ) -> Pin<Box<dyn Future<Output = Result<(), ActorProcessingErr>> + Send + 'async_trait>>

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

Called if the supervisor stops normally (e.g. .stop(None)). For meltdown stops, we skip this, but we still store final state for testing.

type Msg = SupervisorMsg

The message type for this actor

type State = SupervisorState

The type of state this actor manages internally

type Arguments = SupervisorArguments

Initialization arguments

fn pre_start<'life0, 'async_trait>( &'life0 self, _myself: ActorRef<Self::Msg>, args: Self::Arguments, ) -> Pin<Box<dyn Future<Output = Result<Self::State, ActorProcessingErr>> + Send + 'async_trait>>

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

Invoked when an actor is being started by the system.

fn post_start<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, state: &'life1 mut SupervisorState, ) -> Pin<Box<dyn Future<Output = Result<(), ActorProcessingErr>> + Send + 'async_trait>>

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

Invoked after an actor has started.

fn spawn<'async_trait>( name: Option<String>, handler: Self, startup_args: Self::Arguments, ) -> Pin<Box<dyn Future<Output = Result<(ActorRef<Self::Msg>, JoinHandle<()>), SpawnErr>> + Send + 'async_trait>>

where Self: 'async_trait,

Spawn an actor of this type, which is unsupervised, automatically starting

fn spawn_linked<'async_trait>( name: Option<String>, handler: Self, startup_args: Self::Arguments, supervisor: ActorCell, ) -> Pin<Box<dyn Future<Output = Result<(ActorRef<Self::Msg>, JoinHandle<()>), SpawnErr>> + Send + 'async_trait>>

where Self: 'async_trait,

Spawn an actor of this type with a supervisor, automatically starting the actor