Struct LocalProcManager 

pub struct LocalProcManager<S> { /* private fields */ }

A ProcManager that spawns in-process procs (test-only).

The proc runs inside this same OS process; there is no child process to signal. Lifecycle is purely proc-level:

• terminate(timeout): delegates to Proc::destroy_and_wait(timeout, None), which drains and, at the deadline, aborts remaining actors.

• kill(): uses a zero deadline to emulate a forced stop via destroy_and_wait(Duration::ZERO, None).

• wait(): trivial (no external lifecycle to observe).

  No OS signals are sent or required.

Implementations

impl<S> LocalProcManager<S>

pub fn new(spawn: S) -> Self

Create a new in-process proc manager with the given agent params.

pub async fn request_stop(&self, proc: &ProcId, timeout: Duration, reason: &str)

Non-blocking stop: remove the proc and spawn a background task that tears it down.

Status transitions through Stopping -> Stopped and is observable via [local_proc_status]. Idempotent: no-ops if the proc is already stopping or stopped.

pub async fn local_proc_status(&self, proc: &ProcId) -> Option<LocalProcStatus>

Query the lifecycle status of a proc that was stopped via [request_stop].

Returns None if the proc was never stopped through this path.

Trait Implementations

impl<S> BulkTerminate for LocalProcManager<S>

where S: Send + Sync,

fn terminate_all<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _cx: &'life1 (impl 'async_trait + Actor), timeout: Duration, max_in_flight: usize, reason: &'life2 str, ) -> Pin<Box<dyn Future<Output = TerminateSummary> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Gracefully terminate all known children.

impl<A, S, F> ProcManager for LocalProcManager<S>

where A: Actor + Referable + Binds<A>, F: Future<Output = Result<ActorHandle<A>>> + Send, S: Fn(Proc) -> F + Sync,

Local, in-process ProcManager.

Type bounds:

• A: Actor + Referable + Binds<A>
  • Actor: the agent actually runs inside the proc.
  • Referable: callers hold ActorRef<A> to the agent; this bound is required for typed remote refs.
  • Binds<A>: lets the runtime wire the agent’s message ports.
• F: Future<Output = anyhow::Result<ActorHandle<A>>> + Send: the spawn closure returns a Send future (we tokio::spawn it).
• S: Fn(Proc) -> F + Sync: the factory can be called from concurrent contexts.

Result handle is LocalHandle<A> (whose Agent = A via ProcHandle).

type Handle = LocalHandle<A>

Concrete handle type this manager returns.

fn transport(&self) -> ChannelTransport

The preferred transport for this ProcManager. In practice this will be ChannelTransport::Local for testing, and ChannelTransport::Unix for external processes.

fn spawn<'life0, 'async_trait>( &'life0 self, proc_id: ProcId, forwarder_addr: ChannelAddr, _config: (), ) -> Pin<Box<dyn Future<Output = Result<Self::Handle, HostError>> + Send + 'async_trait>>

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

Spawn a new proc with the provided proc id. The proc should use the provided forwarder address for messages destined outside of the proc. The returned address accepts messages destined for the proc.

type Config = ()

Additional configuration for the proc, supported by this manager.

impl<S> SingleTerminate for LocalProcManager<S>

where S: Send + Sync,

fn terminate_proc<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _cx: &'life1 (impl 'async_trait + Actor), proc: &'life2 ProcId, timeout: Duration, reason: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(Vec<ActorId>, Vec<ActorId>), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Gracefully terminate the given proc.