Struct DynamicSupervisor

pub struct DynamicSupervisor;

Implementations

impl DynamicSupervisor

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

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_child( sup_ref: ActorRef<DynamicSupervisorMsg>, spec: ChildSpec, ) -> Result<(), ActorProcessingErr>

pub async fn terminate_child( sup_ref: ActorRef<DynamicSupervisorMsg>, child_id: String, ) -> Result<(), ActorProcessingErr>

Trait Implementations

impl Actor for DynamicSupervisor

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 = DynamicSupervisorMsg

The message type for this actor

type State = DynamicSupervisorState

The type of state this actor manages internally

type Arguments = DynamicSupervisorOptions

Initialization arguments

fn pre_start<'life0, 'async_trait>( &'life0 self, _myself: ActorRef<Self::Msg>, options: 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 handle<'life0, 'life1, 'async_trait>( &'life0 self, myself: ActorRef<Self::Msg>, msg: 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,

Handle the incoming message from the event processing loop. Unhandled panickes will be captured and sent to the supervisor(s)

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,

Handle the incoming supervision event. Unhandled panics will be captured and sent the the supervisor(s). The default supervision behavior is to exit the supervisor on any child exit. To override this behavior, implement this function.

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

where 'life0: 'async_trait, 'life1: 'async_trait, Self: '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