Struct RdmaManagerOwnerActor 

pub struct RdmaManagerOwnerActor { /* private fields */ }

Trait Implementations

impl Accepts<EnsureRdmaManager> for RdmaManagerOwnerActor

where EnsureRdmaManager: RemoteMessage,

impl Accepts<IntrospectMessage> for RdmaManagerOwnerActor

impl Accepts<MeshFailure> for RdmaManagerOwnerActor

where MeshFailure: RemoteMessage,

impl Accepts<Option<MeshFailure>> for RdmaManagerOwnerActor

where Option<MeshFailure>: RemoteMessage,

impl Accepts<ReadyAck> for RdmaManagerOwnerActor

where ReadyAck: RemoteMessage,

impl Actor for RdmaManagerOwnerActor

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 manager-mesh controller is a direct child of the owner, so any terminal status of the controller itself — clean Stopped as well as Failed — is delivered here (RMO-14). It is matched by event.actor_id on this direct parent/child channel (deliberately distinct from MeshFailure attribution). Because a terminating controller’s cleanup can affect per-proc managers shared with other pending views, this conservatively fails every pending view intersecting the source controller’s retained proc view (RMO-17), leaving a terminal source and disjoint pending views unchanged. Non-terminal events are absorbed. Every event returns Ok(true) so no child event terminates this singleton (RMO-1/RMO-4); the owner’s only children are manager controllers.

fn handle_invalid_reference<'life0, 'life1, 'async_trait>( &'life0 mut self, _cx: &'life1 Instance<Self>, invalid: InvalidReference, undeliverable: Undeliverable<MessageEnvelope>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Initialization control traffic — the readiness cast to a manager, or the Subscribe to a controller — can return to the owner as an invalid reference if its target has already died; the default policy would bail! and terminate the owner. Swallow it (RMO-4). The authoritative terminal signal is the controller report (RMO-7) or the controller-child event (RMO-14), never the returned envelope — which is not parsed. handle_undeliverable_message is deliberately left at its default (benign except for an oversized frame).

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 handle_stop<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, this: &'life1 Instance<Self>, mode: StopMode, reason: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Handle a stop request from the runtime.

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_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_delivery_failure_event<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Instance<Self>, undeliverable: Undeliverable<MessageEnvelope>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Default delivery-failure event handling behavior.

fn handle_undeliverable_message<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Instance<Self>, reason: UndeliverableReason, undeliverable: 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 handle_expired_delivery<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Instance<Self>, expired: ExpiredDelivery, undeliverable: Undeliverable<MessageEnvelope>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Default expired-delivery handling behavior.

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

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

impl Binds<RdmaManagerOwnerActor> for RdmaManagerOwnerActor

where EnsureRdmaManager: RemoteMessage, RdmaManagerOwnerActor: Handler<EnsureRdmaManager> + Handler<ReadyAck> + Handler<MeshFailure> + Handler<Option<MeshFailure>>, ReadyAck: RemoteMessage, MeshFailure: RemoteMessage, Option<MeshFailure>: RemoteMessage,

fn bind(ports: &HandlerPorts<Self>)

Bind ports in this actor.

impl Debug for RdmaManagerOwnerActor

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

Formats the value using the given formatter.

impl Handler<EnsureRdmaManager> for RdmaManagerOwnerActor

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

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

Handle the next M-typed message.

fn message_status_reporting() -> MessageStatusReporting

Select which layer reports the message’s terminal telemetry status.

impl Handler<MeshFailure> for RdmaManagerOwnerActor

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

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

Handle the next M-typed message.

fn message_status_reporting() -> MessageStatusReporting

Select which layer reports the message’s terminal telemetry status.

impl Handler<Option<MeshFailure>> for RdmaManagerOwnerActor

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

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

Handle the next M-typed message.

fn message_status_reporting() -> MessageStatusReporting

Select which layer reports the message’s terminal telemetry status.

impl Handler<ReadyAck> for RdmaManagerOwnerActor

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

fn message_status_reporting() -> MessageStatusReporting

Select which layer reports the message’s terminal telemetry status.

impl Named for RdmaManagerOwnerActor

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

A globally unique numeric identifier for this type.

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 ReadyAckHandler for RdmaManagerOwnerActor

fn ready_ack<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, entry: EntryId, ) -> 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: ReadyAck, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Handle the next message.

impl Referable for RdmaManagerOwnerActor

impl RemoteHandles<EnsureRdmaManager> for RdmaManagerOwnerActor

where EnsureRdmaManager: RemoteMessage,

impl RemoteHandles<IntrospectMessage> for RdmaManagerOwnerActor

impl RemoteHandles<MeshFailure> for RdmaManagerOwnerActor

where MeshFailure: RemoteMessage,

impl RemoteHandles<Option<MeshFailure>> for RdmaManagerOwnerActor

where Option<MeshFailure>: RemoteMessage,

impl RemoteHandles<ReadyAck> for RdmaManagerOwnerActor

where ReadyAck: RemoteMessage,

impl RemoteSpawn for RdmaManagerOwnerActor

type Params = ()

The type of parameters used to instantiate the actor remotely.

fn new<'life0, 'async_trait>( _params: (), _environment: &'life0 ActorEnvironment, ) -> Pin<Box<dyn Future<Output = Result<Self, Error>> + Send + 'async_trait>>

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

Creates a new actor instance given its instantiation parameters. The caller shapes environment with any construction context before spawning. The runtime stores the same environment unchanged.

fn gspawn_root_bind( proc: &Proc, uid: Uid, serialized_params: Vec<u8>, environment: ActorEnvironment, ) -> Pin<Box<dyn Future<Output = Result<ActorAddr, Error>> + Send>>

A type-erased entry point to spawn this actor as a root. This is primarily used by hyperactor’s remote actor registration mechanism.

fn gspawn_child( proc: &Proc, parent: InstanceCell, uid: Uid, serialized_params: Vec<u8>, environment: ActorEnvironment, ) -> Pin<Box<dyn Future<Output = Result<AnyActorHandle, Error>> + Send>>

A type-erased entry point to spawn this actor as a child.

fn get_type_id() -> TypeId

The type ID of this actor.