Struct Proc

pub struct Proc { /* private fields */ }

A proc instance is the runtime managing a single proc in Hyperactor. It is responsible for spawning actors in the proc, multiplexing messages to/within actors in the proc, and providing fallback routing to external procs.

Procs are also responsible for maintaining the local supervision hierarchy.

Implementations

impl Proc

pub fn new(proc_id: ProcId, forwarder: BoxedMailboxSender) -> Self

Create a new proc with the given proc id and forwarder.

pub fn new_with_clock( proc_id: ProcId, forwarder: BoxedMailboxSender, clock: ClockKind, ) -> Self

Create a new proc with the given proc id, forwarder and clock kind.

pub fn set_supervision_coordinator( &self, port: PortHandle<ActorSupervisionEvent>, ) -> Result<(), Error>

Set the supervision coordinator’s port for this proc. Return Err if it is already set.

pub fn local() -> Self

Create a new local-only proc. This proc is not allowed to forward messages outside of the proc itself.

pub fn proc_id(&self) -> &ProcId

The proc’s ID.

pub fn forwarder(&self) -> &BoxedMailboxSender

Shared sender used by the proc to forward messages to remote destinations.

pub fn clock(&self) -> &ClockKind

The proc’s clock.

pub fn ledger_snapshot(&self) -> ActorLedgerSnapshot

Get the snapshot of the ledger.

pub fn attach(&self, name: &str) -> Result<Mailbox, Error>

Attach a mailbox to the proc with the provided root name.

pub fn attach_child(&self, parent_id: &ActorId) -> Result<Mailbox, Error>

Attach a mailbox to the proc as a child actor.

pub fn attach_actor<R, M>( &self, name: &str, ) -> Result<(Mailbox, ActorRef<R>, PortReceiver<M>), Error>

where M: RemoteMessage, R: RemoteActor + RemoteHandles<M>,

Attach a mailbox to the proc with the provided root name, and bind an ActorRef. This is intended only for testing, and will be replaced by simpled utilities.

pub async fn spawn<A: Actor>( &self, name: &str, params: A::Params, ) -> Result<ActorHandle<A>, Error>

Spawn a named (root) actor on this proc. The name of the actor must be unique.

pub fn instance( &self, name: &str, ) -> Result<(Instance<()>, ActorHandle<()>), Error>

Create and return an actor instance and its corresponding handle. This allows actors to be “inverted”: the caller can use the returned Instance to send and receive messages, launch child actors, etc. The actor itself does not handle any messages, and supervision events are always forwarded to the proc. Otherwise the instance acts as a normal actor, and can be referenced and stopped.

pub fn abort_root_actor(&self, root: &ActorId) -> Option<ActorId>

Call abort on the JoinHandle associated with the given root actor. If successful return Some(root.clone()) else None.

pub fn stop_actor(&self, actor_id: &ActorId) -> Option<Receiver<ActorStatus>>

Signals to a root actor to stop, returning a status observer if successful.

pub async fn destroy_and_wait( &mut self, timeout: Duration, skip_waiting: Option<&ActorId>, ) -> Result<(Vec<ActorId>, Vec<ActorId>), Error>

Stop the proc. Returns a pair of:

• the actors observed to stop;
• the actors not observed to stop when timeout.

The “skip_waiting” actor, if it is Some, is always not observed to stop.

Trait Implementations

impl Clone for Proc

fn clone(&self) -> Proc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Proc

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

Formats the value using the given formatter.

impl MailboxSender for Proc

fn post( &self, envelope: MessageEnvelope, return_handle: PortHandle<Undeliverable<MessageEnvelope>>, )

TODO: consider making this publicly inaccessible. While the trait itself needs to be public, its only purpose for the end-user API is to provide the typed messaging APIs from (Once)PortRef and ActorRef.