Struct ProcMeshRef 

pub struct ProcMeshRef { /* private fields */ }

A reference to a ProcMesh, consisting of a set of ranked ProcRefs, arranged into a region. ProcMeshes are named, uniquely identifying the ProcMesh from which the reference was derived.

ProcMeshes can be sliced to create new ProcMeshes with a subset of the original ranks.

Implementations

impl ProcMeshRef

pub fn new_singleton(id: ProcMeshId, proc_ref: ProcRef) -> Self

Create a singleton ProcMeshRef, given the provided ProcRef and id. This is used to support creating local singleton proc meshes to support this_proc() in python client actors.

pub fn id(&self) -> &ProcMeshId

pub fn host_mesh_id(&self) -> Option<&HostMeshId>

pub fn hosts(&self) -> Option<&HostMeshRef>

Returns the HostMeshRef that owns this ProcMeshRef, if any.

pub async fn actor_states( &self, cx: &impl Actor, id: ActorMeshId, ) -> Result<ValueMesh<State<ActorState>>>

Query the state of all actors in this mesh matching the given id.

pub async fn proc_states( &self, cx: &impl Actor, keepalive: Option<SystemTime>, ) -> Result<Option<ValueMesh<State<ProcState>>>>

pub async fn spawn<A: RemoteSpawn, C: Actor>( &self, cx: &C, name: &str, params: &A::Params, ) -> Result<ActorMesh<A>>

where A::Params: RemoteMessage, C::A: Handler<MeshFailure>,

Spawn an actor on all of the procs in this mesh, returning a new ActorMesh.

Bounds:

• A: Actor - the actor actually runs inside each proc.
• A: Referable - so we can return typed ActorRef<A>s inside the ActorMesh.
• A::Params: RemoteMessage - spawn parameters must be serializable and routable.

pub async fn spawn_service<A: RemoteSpawn, C: Actor>( &self, cx: &C, name: &str, params: &A::Params, ) -> Result<ActorMesh<A>>

where A::Params: RemoteMessage, C::A: Handler<MeshFailure>,

Spawn a ‘service’ actor. Service actors are singletons, using reserved names. The provided name is used verbatim as the actor’s name, and thus it may be persistently looked up by constructing the appropriate name.

Note: avoid using service actors if possible; the mechanism will be replaced by an actor registry.

pub async fn spawn_with_name<A: RemoteSpawn, C: Actor>( &self, cx: &C, name: ActorMeshId, params: &A::Params, supervision_display_name: Option<String>, is_system_actor: bool, ) -> Result<ActorMesh<A>>

where A::Params: RemoteMessage, C::A: Handler<MeshFailure>,

Spawn an actor on all procs in this mesh under the given ActorMeshId, returning a new ActorMesh.

This is the underlying implementation used by [spawn]; it differs only in that the actor mesh id is passed explicitly rather than as a &str.

Bounds:

• A: Actor - the actor actually runs inside each proc.
• A: Referable - so we can return typed ActorRef<A>s inside the ActorMesh.
• A::Params: RemoteMessage - spawn parameters must be serializable and routable.
• C::A: Handler<MeshFailure> - in order to spawn actors, the actor must accept messages of type MeshFailure. This is delivered when the actors spawned in the mesh have a failure that isn’t handled.

Trait Implementations

impl Clone for ProcMeshRef

fn clone(&self) -> ProcMeshRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Controlled for ProcMeshRef

Controlled implementation for a proc mesh.

type StateInner = ProcState

Inner payload carried in resource::State<Self::StateInner>.

fn stall_counter() -> &'static Counter<u64>

Counter bumped when the supervision loop detects a stall.

fn id(&self) -> &ResourceId

The mesh’s resource identifier.

fn region(&self) -> &Region

The region of ranks in this mesh.

fn subscribe_to_stream( &self, cx: &impl Actor, subscriber: PortRef<State<Self::StateInner>>, ) -> Result<()>

Subscribe the given port to StreamState<StateInner> updates from the underlying agents.

fn forward_wait_rank_status( &self, cx: &impl Actor, msg: WaitRankStatus, ) -> Result<()>

Forward a WaitRankStatus message to the underlying agents.

fn poll_states<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor), supervision_display_name: &'life2 str, health_state: &'life3 mut HealthState, ) -> Pin<Box<dyn Future<Output = PollResult> + Send + 'async_trait>>

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

Mesh-specific polling step for the supervision loop. Implementations may do pre-checks (such as the actor mesh’s proc-aliveness check) before querying rank states; updates to health_state happen in-place. supervision_display_name is used for synthesised supervision events (e.g., when a proc dies).

fn process_state( &self, cx: &impl Actor, state: State<Self::StateInner>, health_state: &mut HealthState, ) -> bool

Process a single streamed or polled state. Updates the health state and notifies owner/subscribers as appropriate. Returns true if a notification was emitted (used to suppress heartbeats).

fn handle_stop_request<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor), _supervision_display_name: &'life2 str, reason: String, health_state: &'life3 mut HealthState, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Perform the mesh-specific stop: issue stop messages to the underlying agents and, where appropriate, update health_state and notify subscribers. The caller has already taken the monitor and logged.

fn cleanup_stop<'life0, 'life1, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor), reason: String, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Stop this mesh on controller cleanup (when Stop was not received but the actor is shutting down).

impl Debug for ProcMeshRef

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProcMeshRef

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ProcMeshRef

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

Formats the value using the given formatter.

impl Hash for ProcMeshRef

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Named for ProcMeshRef

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 ProcMeshRef

fn eq(&self, other: &ProcMeshRef) -> 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 Ranked for ProcMeshRef

type Item = ProcRef

The type of item in this view.

fn region(&self) -> &Region

The ranks contained in this view.

fn get(&self, rank: usize) -> Option<&Self::Item>

Return the item at rank

impl RankedSliceable for ProcMeshRef

fn sliced(&self, region: Region) -> Self

Construct a new Ranked containing the ranks in this view that are part of region. The caller guarantees that region.is_subset(self.region()).

impl Serialize for ProcMeshRef

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ProcMeshRef

impl StructuralPartialEq for ProcMeshRef