Struct ProcMesh 

pub struct ProcMesh { /* private fields */ }

A mesh of processes.

Implementations

impl ProcMesh

pub async fn allocate<C: Actor>( cx: &C, alloc: Box<dyn Alloc + Send + Sync + 'static>, name: &str, ) -> Result<Self>

where C::A: Handler<MeshFailure>,

Allocate a new ProcMesh from the provided alloc. Allocate does not require an owning actor because references are not owned.

pub async fn stop(&mut self, cx: &impl Actor) -> Result<()>

Stop this mesh gracefully.

Methods from Deref<Target = ProcMeshRef>

pub fn name(&self) -> &Name

pub fn host_mesh_name(&self) -> Option<&Name>

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

Returns the HostMeshRef that this ProcMeshRef might be backed by. Returns None if this ProcMeshRef is backed by an Alloc instead of a host mesh.

pub async fn status(&self, cx: &impl Actor) -> Result<ValueMesh<bool>>

The current statuses of procs in this mesh.

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

The supervision events of procs in this mesh.

pub async fn proc_states( &self, cx: &impl Actor, ) -> 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: Name, 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 Name, returning a new ActorMesh.

This is the underlying implementation used by [spawn]; it differs only in that the actor name 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 Debug for ProcMesh

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

Formats the value using the given formatter.

impl Deref for ProcMesh

type Target = ProcMeshRef

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for ProcMesh

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

Formats the value using the given formatter.

impl Drop for ProcMesh

fn drop(&mut self)

Executes the destructor for this type.