Struct ActorProcLauncher 

pub struct ActorProcLauncher { /* private fields */ }

A ProcLauncher implemented by delegating proc lifecycle operations to a Python actor.

The spawner actor must implement the ProcLauncher ABC from monarch._src.actor.proc_launcher, and is responsible for actually spawning and controlling OS processes (Docker, VMs, etc.). Rust retains the lifecycle wiring expected by [BootstrapProcManager]: it initiates launch/terminate/kill requests and exposes an [oneshot::Receiver] (exit_rx) that resolves when the spawner reports exit.

Semantics

• PID is optional: the Python spawner may not expose a real PID, so LaunchResult::pid is None.
• Exit reporting is required: the spawner must send exactly one exit result on the provided exit port. If the port is closed or the payload cannot be decoded, the receiver resolves to a ProcExitKind::Failed result.
• Termination is best-effort: terminate and kill are forwarded to the spawner; success only means the request was delivered.

Context requirement

ProcLauncher methods don’t take a context parameter, but sending actor messages does. This launcher stores an Instance<()> (“client-only” actor) to use as the send context. The instance is created via [Proc::instance()] and must remain valid for the lifetime of the launcher.

Implementations

impl ActorProcLauncher

pub fn new( spawner: ActorHandle<PythonActor>, mailbox: Mailbox, instance: Instance<()>, ) -> Self

Create a new actor-based proc launcher.

Arguments

• spawner - Handle to the Python actor implementing the ProcLauncher ABC.
• mailbox - Mailbox used to create one-shot exit ports.
• instance - Send context for ActorHandle::send (typically from Proc::instance()). Any valid instance granting send capability is sufficient; it need not be Instance<PythonActor>. Must remain valid for the launcher’s lifetime.

Trait Implementations

impl Debug for ActorProcLauncher

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

Formats the value using the given formatter.

impl ProcLauncher for ActorProcLauncher

fn launch<'life0, 'life1, 'async_trait>( &'life0 self, proc_id: &'life1 ProcId, opts: LaunchOptions, ) -> Pin<Box<dyn Future<Output = Result<LaunchResult, ProcLauncherError>> + Send + 'async_trait>>

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

Spawn a proc by delegating to the Python spawner actor.

This method:

1. opens a one-shot mailbox port used for the spawner’s exit notification,
2. serializes (proc_id, LaunchOptions) with cloudpickle,
3. sends a CallMethod { launch, ExplicitPort(..) } message to the spawner,
4. returns immediately with a LaunchResult whose exit_rx completes once the spawner reports process termination (or the port closes).

Notes

• pid is always None: the Rust side does not assume an OS PID exists.
• Exit is observed asynchronously via exit_rx; termination/kill are best-effort requests to the spawner actor rather than direct OS signals.
• If decoding the exit payload fails, the returned exit_rx resolves to ProcExitKind::Failed with a decode error reason.

fn terminate<'life0, 'life1, 'async_trait>( &'life0 self, proc_id: &'life1 ProcId, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), ProcLauncherError>> + Send + 'async_trait>>

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

Request graceful termination of a proc, with a best-effort timeout.

This delegates to the Python spawner actor’s terminate(proc_id, timeout_secs) method. The request is sent fire-and-forget: we do not wait for an acknowledgment, and there is no guarantee the proc will actually exit within timeout.

Errors

Returns ProcLauncherError::Terminate if we fail to:

• import/serialize the request via cloudpickle, or
• send the message to the spawner actor.

fn kill<'life0, 'life1, 'async_trait>( &'life0 self, proc_id: &'life1 ProcId, ) -> Pin<Box<dyn Future<Output = Result<(), ProcLauncherError>> + Send + 'async_trait>>

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

Forcefully kill a proc.

This delegates to the Python spawner actor’s kill(proc_id) method. Like terminate, this is best-effort and fire-and-forget: success here means the request was serialized and delivered to the spawner actor, not that the process is already dead.

Errors

Returns ProcLauncherError::Kill if we fail to:

• import/serialize the request via cloudpickle, or
• send the message to the spawner actor.