Struct ProcessService 

pub struct ProcessService { /* private fields */ }

Implementations

impl ProcessService

pub fn build_node(&self, node_name: &str, release: bool) -> Result<()>

Build a specific node package. release controls whether to build in release mode.

pub fn build_all(&self, release: bool) -> Result<()>

Build all nodes in the workspace. release controls whether to build in release mode.

impl ProcessService

pub fn get_status(&mut self) -> HashMap<String, String>

Get status of all processes

Returns a HashMap mapping process names to status strings

pub fn stop(&mut self, name: &str) -> Result<()>

Stop a specific process by name. Returns an error if the process is not found. Uses a default 10-second timeout for graceful shutdown; use stop_with_timeout for a custom one.

pub fn stop_with_timeout(&mut self, name: &str, timeout: Duration) -> Result<()>

Stop a process with timeout for graceful shutdown. Tries graceful shutdown (SIGTERM on Unix), then force kills after the timeout.

pub fn force_kill(&mut self, name: &str) -> Result<()>

pub fn cleanup(&mut self)

Stop all processes gracefully in dependency order, delegating to the runtime’s ProcessManager.

pub fn is_running(&mut self, name: &str) -> bool

pub fn restart( &mut self, name: &str, binary_path: &str, args: &[&str], ) -> Result<u32>

Restart a specific process: stops it if running and starts it again.

pub fn restart_all( &mut self, nodes: Vec<(&str, &str, Vec<&str>)>, ) -> Result<HashMap<String, u32>>

Restart all processes. nodes is a list of (name, binary_path, args) tuples.

impl ProcessService

pub fn find_global_binary(node_name: &str) -> Option<PathBuf>

Find globally installed binary for a node. Searches ~/.cargo/bin/{node_name} then ~/.mecha10/bin/{node_name}.

pub fn resolve_node_runner_path() -> String

Resolve path to mecha10-node-runner binary: global installation at ~/.cargo/bin/mecha10-node-runner, else falls back to relying on PATH.

pub fn is_node_runner_available() -> bool

Check if mecha10-node-runner is available

impl ProcessService

pub fn spawn_node( &mut self, name: &str, binary_path: &str, args: &[&str], ) -> Result<u32>

Spawn a node process, tracked under name. Returns an error if the process cannot be spawned.

pub fn spawn_with_output( &mut self, name: &str, binary_path: &str, args: &[&str], ) -> Result<u32>

Spawn a process with output capture, tracked under name.

pub fn spawn_with_env( &mut self, name: &str, binary_path: &str, args: &[&str], env: HashMap<String, String>, ) -> Result<u32>

Spawn a process with custom environment variables, tracked under name.

pub fn spawn_in_dir( &mut self, name: &str, binary_path: &str, args: &[&str], working_dir: impl AsRef<Path>, ) -> Result<u32>

Spawn a process in a specific working directory, tracked under name.

pub fn spawn_nodes( &mut self, nodes: Vec<(&str, &str, Vec<&str>)>, ) -> Result<HashMap<String, u32>>

Spawn multiple node processes from a list of (name, binary_path, args) tuples, returning a HashMap of node names to PIDs.

impl ProcessService

pub fn spawn_node_runner( &mut self, node_identifier: &str, project_name: &str, project_env: Option<HashMap<String, String>>, ) -> Result<u32>

Spawn a node using mecha10-node-runner, which handles binary resolution, model pulling, and env setup. Returns the process ID of the spawned node-runner instance, or an error if it cannot be spawned.

pub fn spawn_node_direct( &mut self, node_identifier: &str, _project_name: &str, project_env: Option<HashMap<String, String>>, ) -> Result<u32>

Spawn a node directly (standalone mode)

This is used when mecha10-node-runner is not available. Handles both framework nodes (via BinaryManager) and local project nodes (built and run directly).

impl ProcessService

pub fn new() -> Self

Create a new process service

pub fn track_dependency(&mut self, node: &str, dependencies: Vec<String>)

Track dependency relationship for a node. dependencies is the list of nodes node depends on.

pub fn get_shutdown_order(&self) -> Vec<String>

Get shutdown order (reverse dependency order): nodes with dependents first, then their dependencies, so we never stop a node while others still depend on it.

pub fn count(&self) -> usize

Get the number of tracked processes

pub fn is_empty(&self) -> bool

Check if any processes are being tracked

pub fn manager(&mut self) -> &mut ProcessManager

Get access to the underlying ProcessManager, for advanced operations.

Trait Implementations

impl Default for ProcessService

fn default() -> Self

Returns the “default value” for a type.

impl Drop for ProcessService

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.