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 has no graceful shutdown control plane or exit monitor. It retains access to the manager’s child registry so terminate() and kill() can remove, kill, and reap the process when a host spawn fails.

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_addr(&self) -> &ProcAddr

The proc’s logical address on this host.

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

The proc’s address (the one callers bind into the host router). May return None before ready() completes. Guaranteed to return Some after ready() succeeds.

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

The agent actor reference hosted in the proc. May return None before ready() completes. Guaranteed to return Some after ready() succeeds.

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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().