Skip to main content

hyprstream_workers/runtime/spawner/
mod.rs

1//! Worker spawner abstraction for process management
2//!
3//! This module re-exports the spawner infrastructure from `hyprstream-rpc`
4//! and provides compatibility aliases for backward compatibility.
5//!
6//! # Architecture
7//!
8//! ```text
9//! ProcessSpawner (wrapper with auto-detection)
10//!     ├── StandaloneBackend
11//!     │   └── tokio::process::Command
12//!     │       └── .kill_on_drop(true) for cleanup
13//!     │
14//!     └── SystemdBackend
15//!         └── systemd-run --user (or system)
16//!             └── Spawns as transient unit in hyprstream-workers.slice
17//! ```
18//!
19//! # Usage
20//!
21//! ```ignore
22//! use hyprstream_workers::runtime::spawner::{ProcessSpawner, ProcessConfig};
23//!
24//! // Auto-detect best backend (systemd if available)
25//! let spawner = ProcessSpawner::new();
26//!
27//! // Spawn a daemon
28//! let config = ProcessConfig::new("nydusd", "/usr/bin/nydusd")
29//!     .args(["--config", "/etc/nydusd.json"])
30//!     .working_dir("/var/run/hyprstream");
31//!
32//! let process = spawner.spawn(config).await?;
33//! println!("Spawned: {:?}", process.id());
34//!
35//! // Later, stop the daemon
36//! spawner.stop(&process).await?;
37//! ```
38
39// Re-export all spawner types from hyprstream-service
40pub use hyprstream_service::{
41    ProcessBackend,
42    ProcessConfig,
43    ProcessKind,
44    ProcessSpawner,
45    // ServiceSpawner types
46    ServiceKind,
47    ServiceMode,
48    ServiceSpawner,
49    Spawnable,
50    SpawnedProcess,
51    SpawnedService,
52    SpawnerBackend,
53    // Core types
54    StandaloneBackend,
55    SystemdBackend,
56};
57
58// Compatibility aliases for legacy code
59// (These match the original hyprstream-workers naming)
60
61/// Alias for `ProcessConfig` (backward compatibility)
62pub type DaemonConfig = ProcessConfig;
63
64/// Alias for `SpawnerBackend` (backward compatibility)
65pub trait WorkerSpawner: SpawnerBackend {
66    /// Spawn a daemon process (alias for `spawn`)
67    fn spawn_daemon(
68        &self,
69        config: ProcessConfig,
70    ) -> impl std::future::Future<Output = hyprstream_rpc::Result<SpawnedProcess>> + Send {
71        self.spawn(config)
72    }
73
74    /// Check if systemd is available
75    fn is_systemd_available(&self) -> bool {
76        self.backend_type() == "systemd"
77    }
78
79    /// Get the spawner type name
80    fn spawner_type(&self) -> &'static str {
81        self.backend_type()
82    }
83}
84
85// Blanket implementation for all SpawnerBackend implementations
86impl<T: SpawnerBackend> WorkerSpawner for T {}
87
88/// Create the appropriate spawner based on system capabilities.
89///
90/// Returns `ProcessSpawner` with auto-detected backend
91/// (systemd if available, otherwise direct).
92pub fn create_spawner() -> ProcessSpawner {
93    ProcessSpawner::new()
94}
95
96/// Create a spawner with explicit type selection.
97pub fn create_spawner_of_type(use_systemd: bool) -> ProcessSpawner {
98    if use_systemd {
99        ProcessSpawner::systemd()
100    } else {
101        ProcessSpawner::standalone()
102    }
103}
104
105#[cfg(test)]
106mod tests {
107    use super::*;
108
109    #[test]
110    fn test_daemon_config_alias() {
111        // DaemonConfig should work as alias for ProcessConfig
112        let config = DaemonConfig::new("test", "/usr/bin/test")
113            .args(["--foo", "bar"])
114            .working_dir("/tmp")
115            .env("KEY", "VALUE")
116            .memory_limit("1G")
117            .cpu_quota(200)
118            .restart_on_failure();
119
120        assert_eq!(config.name, "test");
121        assert_eq!(config.executable.to_str(), Some("/usr/bin/test"));
122        assert_eq!(config.args, vec!["--foo", "bar"]);
123    }
124
125    #[test]
126    fn test_create_spawner() {
127        let spawner = create_spawner();
128        let backend_type = spawner.backend_type();
129        // Should be either Standalone or Systemd
130        match backend_type {
131            ProcessBackend::Standalone | ProcessBackend::Systemd { .. } => {}
132        }
133    }
134
135    #[test]
136    fn test_spawned_process() {
137        let direct = SpawnedProcess::new("test-1", ProcessKind::Direct(1234));
138        assert!(direct.is_direct());
139        assert!(!direct.is_systemd());
140        assert_eq!(direct.pid(), Some(1234));
141        assert_eq!(direct.unit_name(), None);
142
143        let systemd = SpawnedProcess::new(
144            "test-2",
145            ProcessKind::SystemdUnit("test.service".to_owned()),
146        );
147        assert!(!systemd.is_direct());
148        assert!(systemd.is_systemd());
149        assert_eq!(systemd.pid(), None);
150        assert_eq!(systemd.unit_name(), Some("test.service"));
151    }
152}