Struct ProcessProcManager 

pub struct ProcessProcManager<A> { /* private fields */ }

A ProcManager that manages each proc as a separate OS process (test-only toy).

This implementation launches a child via Command and relies on kill_on_drop(true) so that children are SIGKILLed if the manager (or host) drops. There is no proc control plane (no RPC to a proc agent for shutdown) and no exit monitor wired here. Consequently:

• terminate() and kill() return Unsupported.
• wait() is trivial (no lifecycle observation).

It follows a simple protocol:

Each process is launched with the following environment variables:

• HYPERACTOR_HOST_BACKEND_ADDR: the backend address to which all messages are forwarded,
• HYPERACTOR_HOST_PROC_ID: the proc id to assign the launched proc, and
• HYPERACTOR_HOST_CALLBACK_ADDR: the channel address with which to return the proc’s address

The launched proc should also spawn an actor to manage it - the details of this are implementation dependent, and outside the scope of the process manager.

The function [boot_proc] provides a convenient implementation of the protocol.

Implementations

impl<A> ProcessProcManager<A>

pub fn new(program: PathBuf) -> Self

Create a new ProcessProcManager that runs the provided command.

impl<A> ProcessProcManager<A>

where A: Actor + Referable + Binds<A>,

pub async fn boot_proc<S, F>(spawn: S) -> Result<Proc, HostError>

where S: FnOnce(Proc) -> F, F: Future<Output = Result<ActorHandle<A>, Error>>,

Boot a process in a ProcessProcManager. Should be called from processes spawned by the process manager. boot_proc will spawn the provided actor type (with parameters) onto the newly created Proc, and bind its handler. This allows the user to install an agent to manage the proc itself.

Trait Implementations

impl<A> Drop for ProcessProcManager<A>

fn drop(&mut self)

Executes the destructor for this type.

impl<A> ProcManager for ProcessProcManager<A>

where A: Actor + Referable + Sync,

type Handle = ProcessHandle<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: ProcAddr, 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 address. The proc should use forwarder_addr for messages destined outside of itself. The returned handle exposes the address that accepts messages for the proc.

type Config = ()

Additional configuration for the proc, supported by this manager.