Skip to main content

mecha10_cli/services/process/
mod.rs

1#![allow(dead_code)]
2
3//! Process service for managing child processes
4//!
5//! This service provides process lifecycle management for CLI commands,
6//! particularly for the `dev` and `run` commands that need to manage
7//! multiple node processes.
8//!
9//! This is a thin wrapper around mecha10-runtime's ProcessManager,
10//! delegating core process management to the runtime layer.
11//!
12//! The implementation is split across a few focused submodules, all of
13//! which add `impl ProcessService` blocks for the struct defined here:
14//!
15//! - [`resolve`]: binary path resolution (framework dev mode, global installs, node-runner)
16//! - [`spawn`]: plain process spawning primitives (inherited/piped output, env, working dir)
17//! - [`spawn_node`]: node-oriented spawning (node-runner, standalone/direct)
18//! - [`control`]: status, stop/restart, and cleanup of tracked processes
19//! - [`build`]: cargo build helpers used before spawning nodes
20
21mod build;
22mod control;
23mod resolve;
24mod spawn;
25mod spawn_node;
26
27use mecha10_runtime::ProcessManager;
28
29pub struct ProcessService {
30    manager: ProcessManager,
31}
32
33impl ProcessService {
34    /// Create a new process service
35    pub fn new() -> Self {
36        Self {
37            manager: ProcessManager::new(),
38        }
39    }
40
41    /// Track dependency relationship for a node
42    ///
43    /// # Arguments
44    ///
45    /// * `node` - Name of the node
46    /// * `dependencies` - List of nodes this node depends on
47    pub fn track_dependency(&mut self, node: &str, dependencies: Vec<String>) {
48        for dep in dependencies {
49            self.manager.add_dependency(node.to_string(), dep);
50        }
51    }
52
53    /// Get shutdown order (reverse dependency order)
54    ///
55    /// Returns nodes in order they should be stopped:
56    /// - Nodes with dependents first (high-level nodes)
57    /// - Then their dependencies (low-level nodes)
58    ///
59    /// This ensures we don't stop a node while other nodes depend on it.
60    ///
61    /// Delegates to the runtime's ProcessManager.
62    pub fn get_shutdown_order(&self) -> Vec<String> {
63        self.manager.shutdown_order()
64    }
65
66    /// Get the number of tracked processes
67    pub fn count(&self) -> usize {
68        self.manager.len()
69    }
70
71    /// Check if any processes are being tracked
72    pub fn is_empty(&self) -> bool {
73        self.manager.is_empty()
74    }
75
76    /// Get access to the underlying ProcessManager
77    ///
78    /// Useful for advanced operations or when migrating existing code.
79    /// Provides direct access to the runtime's ProcessManager.
80    pub fn manager(&mut self) -> &mut ProcessManager {
81        &mut self.manager
82    }
83}
84
85impl Default for ProcessService {
86    fn default() -> Self {
87        Self::new()
88    }
89}
90
91impl Drop for ProcessService {
92    fn drop(&mut self) {}
93}