Struct ProcAgent 

pub struct ProcAgent { /* private fields */ }

A mesh agent is responsible for managing procs in a [ProcMesh].

Supervision event ingestion (remote)

ProcAgent is the process/rank-local sink for ActorSupervisionEvents produced by the runtime (actor failures, routing failures, undeliverables, etc.).

We export ActorSupervisionEvent as a handler so that other procs—most importantly the process-global root client created by context()—can forward undeliverables as supervision events to the currently active mesh.

Without exporting this handler, ActorSupervisionEvent cannot be addressed via ActorRef/PortRef across processes, and the global-root-client undeliverable → supervision pipeline would degrade to log-only behavior (events become undeliverable again or are dropped).

See GC-1 in global_context module doc.

Trait Implementations

impl Actor for ProcAgent

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 cleanup<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _this: &'life1 Instance<Self>, _err: Option<&'life2 ActorError>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Cleanup things used by this actor before shutting down. Notably this function is async and allows more complex cleanup. Simpler cleanup can be handled by the impl Drop for this Actor. If err is not None, it is the error that this actor is failing with. Any errors returned by this function will be logged and ignored. If err is None, any errors returned by this function will be propagated as an ActorError. This function is not called if there is a panic in the actor, as the actor may be in an indeterminate state. It is also not called if the process is killed, there is no atexit handler or signal handler.

fn spawn(self, cx: &impl Actor) -> Result<ActorHandle<Self>, Error>

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_with_name( self, cx: &impl Actor, name: &str, ) -> Result<ActorHandle<Self>, Error>

Spawn a named child actor. Same supervision semantics as spawn, but the child gets name in its ActorId.

fn spawn_detached(self) -> Result<ActorHandle<Self>, Error>

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 as Future>::Output>

where F: Future + Send + 'static, <F as Future>::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 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: '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>, envelope: Undeliverable<MessageEnvelope>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Default undeliverable message handling behavior.

fn display_name(&self) -> Option<String>

If overridden, we will use this name in place of the ActorId for talking about this actor in supervision error messages.

impl Binds<ProcAgent> for ProcAgent

fn bind(ports: &Ports<Self>)

Bind ports in this actor.

impl Handler<ActorSupervisionEvent> for ProcAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, event: 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.

impl Handler<CreateOrUpdate<ActorSpec>> for ProcAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, create_or_update: CreateOrUpdate<ActorSpec>, ) -> 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.

impl Handler<GetProc> for ProcAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, __arg2: GetProc, ) -> 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.

impl Handler<GetRankStatus> for ProcAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, get_rank_status: GetRankStatus, ) -> 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.

impl Handler<GetState<ActorState>> for ProcAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, get_state: GetState<ActorState>, ) -> 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.

impl Handler<KeepaliveGetState<ActorState>> for ProcAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, message: KeepaliveGetState<ActorState>, ) -> 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.

impl Handler<NewClientInstance> for ProcAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, __arg2: NewClientInstance, ) -> 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.

impl Handler<Stop> for ProcAgent

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, message: Stop, ) -> 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.

impl Handler<StopAll> for ProcAgent

Handles StopAll by coordinating an orderly stop of child actors and then exiting the process. This handler never returns to the caller: it calls std::process::exit(0/1) after shutdown. Any sender must not expect a reply or send any further message, and should watch ProcStatus instead.

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, message: StopAll, ) -> 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.

impl MeshAgentMessageHandler for ProcAgent

fn configure<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, rank: usize, forwarder: ChannelAddr, supervisor: Option<PortRef<ActorSupervisionEvent>>, address_book: HashMap<ProcId, ChannelAddr>, configured: PortRef<usize>, record_supervision_events: bool, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

The generated handler method for this enum variant.

fn gspawn<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, actor_type: String, actor_name: String, params_data: Data, status_port: PortRef<GspawnResult>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

The generated handler method for this enum variant.

fn stop_actor<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, actor_id: ActorId, timeout_ms: u64, reason: String, ) -> Pin<Box<dyn Future<Output = Result<StopActorResult, Error>> + Send + 'async_trait>>

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

The generated handler method for this enum variant.

fn status<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, status_port: PortRef<(usize, bool)>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

The generated handler method for this enum variant.

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

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

Handle the next message.

impl Named for ProcAgent

fn typename() -> &'static str

The globally unique type name for the type. This should typically be the fully qualified Rust name of the type.

fn typehash() -> u64

A globally unique hash for this type. TODO: actually enforce perfect hashing

fn typeid() -> TypeId

The TypeId for this type. TypeIds are unique only within a binary, and should not be used for global identification.

fn port() -> u64

The globally unique port for this type. Typed ports are in the range of 1<<63..1<<64-1.

fn arm(&self) -> Option<&'static str>

If the named type is an enum, this returns the name of the arm of the value self.

unsafe fn arm_unchecked(self_: *const ()) -> Option<&'static str>

An unsafe version of ‘arm’, accepting a pointer to the value, for use in type-erased settings.

impl Accepts<ActorSupervisionEvent> for ProcAgent

impl Accepts<CreateOrUpdate<ActorSpec>> for ProcAgent

impl Accepts<GetRankStatus> for ProcAgent

impl Accepts<GetState<ActorState>> for ProcAgent

impl Accepts<IndexedErasedUnbound<CreateOrUpdate<ActorSpec>>> for ProcAgent

impl Accepts<IndexedErasedUnbound<GetRankStatus>> for ProcAgent

impl Accepts<IndexedErasedUnbound<GetState<ActorState>>> for ProcAgent

impl Accepts<IndexedErasedUnbound<KeepaliveGetState<ActorState>>> for ProcAgent

impl Accepts<IndexedErasedUnbound<RepublishIntrospect>> for ProcAgent

impl Accepts<IndexedErasedUnbound<Stop>> for ProcAgent

impl Accepts<IndexedErasedUnbound<StopAll>> for ProcAgent

impl Accepts<IntrospectMessage> for ProcAgent

impl Accepts<KeepaliveGetState<ActorState>> for ProcAgent

impl Accepts<Signal> for ProcAgent

impl Accepts<Stop> for ProcAgent

impl Accepts<StopAll> for ProcAgent

impl Referable for ProcAgent

impl RemoteHandles<ActorSupervisionEvent> for ProcAgent

impl RemoteHandles<CreateOrUpdate<ActorSpec>> for ProcAgent

impl RemoteHandles<GetRankStatus> for ProcAgent

impl RemoteHandles<GetState<ActorState>> for ProcAgent

impl RemoteHandles<IndexedErasedUnbound<CreateOrUpdate<ActorSpec>>> for ProcAgent

impl RemoteHandles<IndexedErasedUnbound<GetRankStatus>> for ProcAgent

impl RemoteHandles<IndexedErasedUnbound<GetState<ActorState>>> for ProcAgent

impl RemoteHandles<IndexedErasedUnbound<KeepaliveGetState<ActorState>>> for ProcAgent

impl RemoteHandles<IndexedErasedUnbound<RepublishIntrospect>> for ProcAgent

impl RemoteHandles<IndexedErasedUnbound<Stop>> for ProcAgent

impl RemoteHandles<IndexedErasedUnbound<StopAll>> for ProcAgent

impl RemoteHandles<IntrospectMessage> for ProcAgent

impl RemoteHandles<KeepaliveGetState<ActorState>> for ProcAgent

impl RemoteHandles<Signal> for ProcAgent

impl RemoteHandles<Stop> for ProcAgent

impl RemoteHandles<StopAll> for ProcAgent