Struct GlobalClientActor 

pub struct GlobalClientActor { /* private fields */ }

Process-global “root client” actor.

This actor lives on the local_proc of the singleton Host created by context(), symmetric with Python’s RootClientActor on bootstrap_host()’s local proc.

It acts as a monitor for routing failures observed at the process boundary: undeliverable messages are treated as signals to be reported via mesh supervision (when a sink is installed), not as fatal errors.

The actor is driven by run(), which select!s over:

• work_rx: the primary dispatch queue for bound handler work items (including Undeliverable<MessageEnvelope> and MeshFailure>),
• supervision_rx: supervision events delivered to this actor, and
• signal_rx: control signals (currently minimal handling).

Trait Implementations

impl Actor for GlobalClientActor

Handle a returned (undeliverable) message observed by the process-global root client.

The global root client is a monitor, not a participant: it must not crash or propagate failures just because a routed message could not be delivered.

Instead, we translate the undeliverable into an ActorSupervisionEvent and forward it to the active ProcMesh via the process-global supervision sink (“last sink wins”). If no sink has been installed yet (e.g., before the first ProcMesh allocation completes), we log and drop the event.

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,

The global root client is the root of the supervision tree: there is no parent to escalate to. Child-actor failures (e.g. ActorMeshControllers detecting dead procs after mesh teardown) are expected and must not crash the process.

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.

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

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

fn bind(ports: &Ports<Self>)

Bind ports in this actor.

impl Debug for GlobalClientActor

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

Formats the value using the given formatter.

impl Handler<MeshFailure> for GlobalClientActor

MeshFailure is a terminal supervision signal for an ActorMesh.

The process-global root client should never be a consumer of mesh-level supervision failures during normal operation: those events are expected to be observed and handled by the owning mesh/controller, not by the global client.

In processes that create and destroy multiple meshes (e.g., benchmarks), MeshFailure events may arrive here during or after mesh teardown. Log loudly but do not crash — the global client is a monitor and must preserve forward progress.

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, _cx: &'life1 Context<'_, Self>, message: MeshFailure, ) -> 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 Named for GlobalClientActor

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<IntrospectMessage> for GlobalClientActor

impl Accepts<MeshFailure> for GlobalClientActor

impl Accepts<Signal> for GlobalClientActor

impl Referable for GlobalClientActor

impl RemoteHandles<IntrospectMessage> for GlobalClientActor

impl RemoteHandles<MeshFailure> for GlobalClientActor

impl RemoteHandles<Signal> for GlobalClientActor