Struct ProcSupervisionCoordinator

pub struct ProcSupervisionCoordinator(/* private fields */);

Used to create a proc supervison coordinator for testing purposes. Normally you should not use this struct. It is only required in the following cases:

1. The tests’ logic involves actor failures;
2. A supervison coordinator is not already set for the proc (e.g. the ProcActor scenario which will be explained later.)

This is because hyperactor’s supervision logic requires actor failures in a proc to be bubbled up to through the supervision chain:

grandchild actor -> child actor -> root actor -> proc supervison coordinator

If the the proc supervison coordinator is not set, supervision will crash the process because it cannot find the coordinator during the “bubbling up”.

Note that if you are using hyperactor_multiprocess’ ProcActor bootstrap, the ProcActor will be set as the coordinator by the bootstrap. As a result, you do not need to set the supervior again with this struct.

Implementations

impl ProcSupervisionCoordinator

pub async fn set(proc: &Proc) -> Result<ReportedEvent, Error>

Spawn a coordinator actor and set it as the coordinator for the given proc.

Trait Implementations

impl Actor for ProcSupervisionCoordinator

type Params = ReportedEvent

The type of initialization parameters accepted by this actor.

fn new<'async_trait>( param: ReportedEvent, ) -> Pin<Box<dyn Future<Output = Result<Self, Error>> + Send + 'async_trait>>

where Self: 'async_trait,

Creates a new actor instance given its instantiation parameters.

fn init<'life0, 'life1, 'async_trait>( &'life0 mut self, _this: &'life1 Instance<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Initialize the actor, after the runtime has been fully initialized. Init thus provides a mechanism by which an actor can reliably and always receive some initial event that can be used to kick off further (potentially delayed) processing.

fn spawn<'life0, 'async_trait>( cap: &'life0 (impl 'async_trait + CanSpawn), params: Self::Params, ) -> Pin<Box<dyn Future<Output = Result<ActorHandle<Self>>> + Send + 'async_trait>>

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

Spawn a child actor, given a spawning capability (usually given by Instance). The spawned actor will be supervised by the parent (spawning) actor.

fn spawn_detached<'async_trait>( params: Self::Params, ) -> Pin<Box<dyn Future<Output = Result<ActorHandle<Self>, Error>> + Send + 'async_trait>>

where Self: 'async_trait,

Spawns this actor in a detached state, handling its messages in a background task. The returned handle is used to control the actor’s lifecycle and to interact with it.

fn spawn_server_task<F>(future: F) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

This method is used by the runtime to spawn the actor server. It can be used by actors that require customized runtime setups (e.g., dedicated actor threads), or want to use a custom tokio runtime.

fn handle_supervision_event<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _this: &'life1 Instance<Self>, _event: &'life2 ActorSupervisionEvent, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

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

Handle actor supervision event. Return `Ok(true)`` if the event is handled here.

fn handle_undeliverable_message<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Instance<Self>, __arg2: Undeliverable<MessageEnvelope>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Default undeliverable message handling behavior.

impl Debug for ProcSupervisionCoordinator

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

Formats the value using the given formatter.

impl Handler<ActorSupervisionEvent> for ProcSupervisionCoordinator

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, _cx: &'life1 Context<'_, Self>, msg: ActorSupervisionEvent, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Handle the next M-typed message.