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.

Trait Implementations

impl<S> BulkTerminate for LocalProcManager<S>

where S: Send + Sync,

fn terminate_all<'life0, 'async_trait>( &'life0 self, timeout: Duration, max_in_flight: usize, ) -> Pin<Box<dyn Future<Output = TerminateSummary> + Send + 'async_trait>>

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