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}