Struct PythonActor 

pub struct PythonActor { /* private fields */ }

An actor for which message handlers are implemented in Python.

Trait Implementations

impl Accepts<IntrospectMessage> for PythonActor

impl Accepts<MeshFailure> for PythonActor

where MeshFailure: RemoteMessage,

impl Accepts<PythonMessage> for PythonActor

where PythonMessage: RemoteMessage,

impl Actor for PythonActor

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

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

Enqueues the message for _handle_undeliverable_message and returns right away, for the same reasons handle_supervision_event does not wait. The verdict comes back later as an UndeliverableOutcome, whose handler applies the default handling if the message was not handled. A message still pending when the actor stops is dropped.

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,

Enqueues the event for __supervise__ and returns Ok(true) right away: true means “accepted”, not “handled”. The verdict comes back later as a SupervisionOutcome, whose handler fails the actor if the event was not handled.

Waiting for the verdict here is only appropriate when supervision is bounded in time and does not need this actor’s loop, as with Rust actors. __supervise__ is arbitrary user code on the actor’s asyncio loop, while this runs on the actor loop, so waiting would stop the actor from handling messages and signals for as long as user code runs, deadlock a __supervise__ that calls its own actor, and keep a stop from cancelling it.

Consequences of not waiting:

• The actor keeps handling messages until an unhandled verdict arrives.
• Supervision still pending when the actor stops is cancelled along with the other asyncio tasks in cleanup. This is intentional: recovering from a child failure (e.g. respawning a mesh) is pointless when the result is about to be stopped with us. It includes the events the run loop drains after a handler error, so the actor fails with its own error rather than theirs.
• The root client’s custom loop must keep running after this returns so that it can deliver the SupervisionOutcome.

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<()>> + Send + 'async_trait>>

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

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

Default invalid-reference 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.

impl Binds<PythonActor> for PythonActor

where PythonMessage: RemoteMessage, PythonActor: Handler<PythonMessage> + Handler<MeshFailure>, MeshFailure: RemoteMessage,

fn bind(ports: &HandlerPorts<Self>)

Bind ports in this actor.

impl Debug for PythonActor

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

Formats the value using the given formatter.

impl Handler<MeshFailure> for PythonActor

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.

fn message_status_reporting() -> MessageStatusReporting

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

impl Handler<PythonMessage> for PythonActor

fn message_status_reporting() -> MessageStatusReporting

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

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, PythonActor>, message: PythonMessage, ) -> 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<SupervisionOutcome> for PythonActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, outcome: SupervisionOutcome, ) -> 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 Handler<UndeliverableOutcome> for PythonActor

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

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 Referable for PythonActor

impl RemoteHandles<IntrospectMessage> for PythonActor

impl RemoteHandles<MeshFailure> for PythonActor

where MeshFailure: RemoteMessage,

impl RemoteHandles<PythonMessage> for PythonActor

where PythonMessage: RemoteMessage,

impl RemoteSpawn for PythonActor

type Params = PythonActorParams

The type of parameters used to instantiate the actor remotely.

fn new<'life0, 'async_trait>( __arg0: PythonActorParams, 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.