Struct MeshFailure 

pub struct MeshFailure {
    pub actor_mesh_name: Option<String>,
    pub rank: Option<usize>,
    pub event: ActorSupervisionEvent,
}

Message about a supervision failure on a mesh of actors instead of a single actor.

Fields

actor_mesh_name: Option<String>

Name of the mesh which the event originated from.

rank: Option<usize>

Rank of the mesh from which the event originated. TODO: Point instead?

event: ActorSupervisionEvent

The supervision event on an actor located at mesh + rank.

Implementations

impl MeshFailure

pub fn default_handler(&self, cx: &impl Actor) -> Result<(), Error>

Helper function to handle a message to an actor that just wants to forward it to the next owner.

Trait Implementations

impl Bind for MeshFailure

fn bind(&mut self, bindings: &mut Bindings) -> Result<()>

Remove parameters from bindings, and use them to update itself.

impl Clone for MeshFailure

fn clone(&self) -> MeshFailure

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MeshFailure

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MeshFailure

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MeshFailure

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 Handler<MeshFailure> for WrapperActor

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

impl Named for MeshFailure

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 PartialEq for MeshFailure

fn eq(&self, other: &MeshFailure) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MeshFailure

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Unbind for MeshFailure

fn unbind(&self, bindings: &mut Bindings) -> Result<()>

Extract parameters from itself and store them in bindings.

impl Accepts<MeshFailure> for GlobalClientActor

impl Accepts<MeshFailure> for WrapperActor

impl RemoteHandles<MeshFailure> for GlobalClientActor

impl RemoteHandles<MeshFailure> for WrapperActor

impl StructuralPartialEq for MeshFailure