Struct ProcessHandle

pub struct ProcessHandle<A: Actor + Referable> { /* private fields */ }

A ProcHandle implementation for procs managed as separate OS processes via ProcessProcManager.

This handle records the logical identity and connectivity of an external child process:

• its ProcId (unique identity on the host),
• the proc’s ChannelAddr (address registered in the host router),
• and the ActorRef of the agent actor spawned inside the proc.

Unlike LocalHandle, this corresponds to a real OS process launched by the manager. In this toy implementation the handle does not own/monitor the Child and there is no shutdown control plane. It is a stable, clonable surface exposing the proc’s identity, address, and agent reference so host code can interact uniformly with local/external procs. terminate()/kill() are intentionally Unsupported here; process cleanup relies on cmd.kill_on_drop(true) when launching the child (the OS will SIGKILL it if the handle is dropped).

The type bound A: Actor + Referable comes from the ProcHandle::Agent requirement: Actor because the agent actually runs inside the proc, and Referable because it must be referenceable via ActorRef<A> (i.e., safe to carry as a typed remote reference).

Trait Implementations

impl<A: Actor + Referable> Clone for ProcessHandle<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Actor + Referable> Debug for ProcessHandle<A>

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

Formats the value using the given formatter.

impl<A: Actor + Referable> ProcHandle for ProcessHandle<A>

type Agent = A

Agent must be both an Actor (runs in the proc) and a Referable (so it can be referenced via ActorRef<A>).

fn ready<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ReadyError<Self::TerminalStatus>>> + Send + 'async_trait>>

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

Resolves immediately. ProcessProcManager::spawn returns this handle only after the child has called back with (addr, agent), i.e. after readiness.

fn wait<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Self::TerminalStatus, WaitError>> + Send + 'async_trait>>

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

Resolves immediately with (). This handle does not track child lifecycle; there is no watcher in this implementation.

type TerminalStatus = ()

The type of terminal status produced when the proc exits.

fn proc_id(&self) -> &ProcId

The proc’s logical identity on this host.

fn addr(&self) -> Option<ChannelAddr>

The proc’s address (the one callers bind into the host router).

fn agent_ref(&self) -> Option<ActorRef<Self::Agent>>

The agent actor reference hosted in the proc.

fn terminate<'life0, 'async_trait>( &'life0 self, _deadline: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), TerminateError<Self::TerminalStatus>>> + Send + 'async_trait>>

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

Politely stop the proc before the deadline; managers that own a child OS process may escalate to a forced kill at the deadline. Idempotent and race-safe: concurrent callers coalesce; the first terminal outcome wins and all callers observe it via wait().

fn kill<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), TerminateError<Self::TerminalStatus>>> + Send + 'async_trait>>

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

Force the proc down immediately. For in-process managers this may abort actor tasks; for external managers this typically sends SIGKILL. Also idempotent/race-safe; the terminal outcome is the one observed by wait().