Struct MeshMonitor 

pub struct MeshMonitor { /* private fields */ }

A liveness monitor over a set of ranked actors.

A MeshMonitor logically monitors one actor per rank in a region. Monitoring runs until the MeshMonitor is dropped. A monitor from MeshMonitor::spawn_persistent is persistent and polls throughout; one from MeshMonitor::spawn_dormant starts dormant and polls only while active. Awaiting a &MeshMonitor resolves with the first rank failure, reported as a MeshFailure that names the rank; use MeshMonitor::guard to run a future until it completes or a rank fails.

Implementations

impl MeshMonitor

pub fn spawn_persistent(cx: &impl Actor, actors: ValueMesh<ActorAddr>) -> Self

Spawn one persistent ActorMonitor per rank as a child of cx.

actors holds the actor addresses in the mesh’s region, so the resulting monitors share that region: each rank reports failures under the same rank it holds in the mesh.

pub fn spawn_dormant(cx: &impl Actor, actors: ValueMesh<ActorAddr>) -> Self

Spawn one ActorMonitor per rank as a child of cx, starting dormant.

Each rank observes terminal-status notifications in either state, but polls status only while active: while a MeshMonitorActivation from Self::activate is live.

pub fn activate(&self, cx: &impl Actor) -> MeshMonitorActivation

Keep every rank active until the returned activation is dropped.

See ActorMonitor::activate.

pub fn region(&self) -> &Region

Return the monitored region.

pub fn status(&self, rank: usize) -> Option<ActorStatus>

Return the latest observed status for rank.

pub async fn guard<F>(&self, fut: F) -> Result<F::Output, MeshFailure>

where F: Future,

Run fut until it completes or any monitored rank fails.

pub async fn cast_and_collect<A, M, R>( &self, actor_mesh: &ActorMeshRef<A>, cx: &impl Actor, message: M, receiver: &mut PortReceiver<R>, ) -> Result<Result<Vec<R>, MeshFailure>>

where A: Referable + RemoteHandles<M>, M: RemoteMessage + Clone, R: Message,

Cast message and collect one response per rank unless a rank fails.

receiver must receive exactly one response from each actor in actor_mesh. Responses are returned in arrival order. The outer result reports cast or mailbox errors; the inner result distinguishes all-rank completion from a monitored rank failure. This monitor must have been created from actor_mesh.

Trait Implementations

impl<'a> IntoFuture for &'a MeshMonitor

Awaiting a &MeshMonitor resolves with the first rank failure. The borrow keeps the monitors alive for the duration of the await.

type Output = MeshFailure

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = MeshFailure> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.