1use serde::{Deserialize, Serialize};
10use std::path::PathBuf;
11
12use crate::runtime::AdmissionConfig;
13
14fn default_backend() -> String {
19 "auto".to_owned()
20}
21
22#[derive(Debug, Clone, Serialize, Deserialize)]
24#[serde(default)]
25pub struct WorkerConfig {
26 #[serde(default = "default_backend")]
38 pub backend: String,
39
40 pub pool: PoolConfig,
42
43 pub images: ImageConfig,
45
46 pub workflow: WorkflowConfig,
48
49 pub events: EventConfig,
51
52 #[serde(default)]
54 pub quic_port: Option<u16>,
55}
56
57impl Default for WorkerConfig {
58 fn default() -> Self {
59 Self {
60 backend: default_backend(),
61 pool: PoolConfig::default(),
62 images: ImageConfig::default(),
63 workflow: WorkflowConfig::default(),
64 events: EventConfig::default(),
65 quic_port: None,
66 }
67 }
68}
69
70#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
72#[serde(rename_all = "kebab-case")]
73pub enum HypervisorType {
74 #[default]
76 CloudHypervisor,
77 #[cfg(feature = "dragonball")]
79 Dragonball,
80}
81
82impl std::fmt::Display for HypervisorType {
83 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
84 match self {
85 Self::CloudHypervisor => write!(f, "cloud-hypervisor"),
86 #[cfg(feature = "dragonball")]
87 Self::Dragonball => write!(f, "dragonball"),
88 }
89 }
90}
91
92#[derive(Debug, Clone, Serialize, Deserialize)]
94#[serde(default)]
95pub struct PoolConfig {
96 pub hypervisor: HypervisorType,
98
99 pub hypervisor_path: PathBuf,
102
103 pub max_sandboxes: usize,
105
106 pub warm_pool_size: usize,
108
109 pub vm_image: PathBuf,
111
112 pub kernel_path: PathBuf,
114
115 pub cloud_init_dir: PathBuf,
117
118 pub runtime_dir: PathBuf,
120
121 pub vm_memory_mb: u64,
123
124 pub vm_cpus: u32,
126
127 pub create_timeout_secs: u64,
129
130 pub stop_timeout_secs: u64,
132
133 pub admission: AdmissionConfig,
142}
143
144impl Default for PoolConfig {
145 fn default() -> Self {
146 Self {
147 hypervisor: HypervisorType::default(),
148 hypervisor_path: PathBuf::new(), max_sandboxes: 10,
150 warm_pool_size: 2,
151 vm_image: PathBuf::from("/var/lib/hyprstream/vm/rootfs.img"),
152 kernel_path: PathBuf::from("/var/lib/hyprstream/vm/vmlinux"),
153 cloud_init_dir: PathBuf::from("/var/lib/hyprstream/cloud-init"),
154 runtime_dir: crate::paths::sandboxes_dir(),
155 vm_memory_mb: 2048,
156 vm_cpus: 2,
157 create_timeout_secs: 60,
158 stop_timeout_secs: 30,
159 admission: AdmissionConfig::default(),
160 }
161 }
162}
163
164#[derive(Debug, Clone, Serialize, Deserialize)]
166#[serde(default)]
167pub struct ImageConfig {
168 pub blobs_dir: PathBuf,
170
171 pub bootstrap_dir: PathBuf,
173
174 pub refs_dir: PathBuf,
176
177 pub cache_dir: PathBuf,
179
180 pub runtime_dir: PathBuf,
182
183 #[serde(default)]
186 pub dragonfly_peer: Option<String>,
187
188 pub fuse_threads: usize,
190
191 pub chunk_size: usize,
193
194 pub lazy_loading: bool,
196
197 pub cache_size_bytes: u64,
199}
200
201impl Default for ImageConfig {
202 fn default() -> Self {
203 Self {
204 blobs_dir: PathBuf::from("/var/lib/hyprstream/images/blobs"),
205 bootstrap_dir: PathBuf::from("/var/lib/hyprstream/images/bootstrap"),
206 refs_dir: PathBuf::from("/var/lib/hyprstream/images/refs"),
207 cache_dir: PathBuf::from("/var/lib/hyprstream/images/cache"),
208 runtime_dir: crate::paths::nydus_dir(),
209 dragonfly_peer: None,
210 fuse_threads: 4,
211 chunk_size: 1024 * 1024, lazy_loading: true,
213 cache_size_bytes: 10 * 1024 * 1024 * 1024, }
215 }
216}
217
218#[derive(Debug, Clone, Serialize, Deserialize)]
220#[serde(default)]
221pub struct WorkflowConfig {
222 pub logs_dir: PathBuf,
224
225 pub max_concurrent_runs: usize,
227
228 pub job_timeout_secs: u64,
230
231 pub step_timeout_secs: u64,
233
234 pub auto_discover: bool,
236
237 pub enabled: bool,
244}
245
246impl Default for WorkflowConfig {
247 fn default() -> Self {
248 Self {
249 logs_dir: PathBuf::from("/var/lib/hyprstream/workflows/logs"),
250 max_concurrent_runs: 10,
251 job_timeout_secs: 3600, step_timeout_secs: 600, auto_discover: true,
254 enabled: false,
257 }
258 }
259}
260
261#[derive(Debug, Clone, Default, Serialize, Deserialize)]
270#[serde(default)]
271pub struct EventConfig {
272 pub log_events: bool,
274}
275
276#[cfg(test)]
277mod tests {
278 use super::*;
279
280 #[test]
281 fn test_default_config() {
282 let config = WorkerConfig::default();
283 assert_eq!(config.pool.max_sandboxes, 10);
284 assert_eq!(config.pool.warm_pool_size, 2);
285 assert!(config.images.lazy_loading);
286 assert!(config.workflow.auto_discover);
287 }
288
289 #[test]
290 fn test_config_serialization() -> Result<(), Box<dyn std::error::Error>> {
291 let config = WorkerConfig::default();
292 let yaml = serde_yaml::to_string(&config)?;
293 let parsed: WorkerConfig = serde_yaml::from_str(&yaml)?;
294 assert_eq!(parsed.pool.max_sandboxes, config.pool.max_sandboxes);
295 Ok(())
296 }
297
298 #[test]
299 fn test_worker_config_toml_roundtrips_at_defaults() -> Result<(), Box<dyn std::error::Error>> {
300 let config = WorkerConfig::default();
307 let toml_str = toml::to_string_pretty(&config)?;
308 assert!(
310 !toml_str.contains("max_per_subject"),
311 "unlimited per-subject quota must serialize as absent, got:\n{toml_str}"
312 );
313 assert!(!toml_str.contains("max_per_group"));
314 let parsed: WorkerConfig = toml::from_str(&toml_str)?;
315 assert_eq!(parsed.pool.admission.max_per_subject, None);
316 assert_eq!(parsed.pool.admission.max_per_group, None);
317 assert_eq!(parsed.pool.max_sandboxes, config.pool.max_sandboxes);
318 Ok(())
319 }
320
321 #[test]
322 fn test_worker_config_toml_roundtrips_with_explicit_quotas(
323 ) -> Result<(), Box<dyn std::error::Error>> {
324 let mut config = WorkerConfig::default();
326 config.pool.admission.max_per_subject = Some(4);
327 config.pool.admission.max_per_group = Some(16);
328 let toml_str = toml::to_string_pretty(&config)?;
329 let parsed: WorkerConfig = toml::from_str(&toml_str)?;
330 assert_eq!(parsed.pool.admission.max_per_subject, Some(4));
331 assert_eq!(parsed.pool.admission.max_per_group, Some(16));
332 Ok(())
333 }
334
335 #[test]
336 fn test_hypervisor_type_serialization() -> Result<(), Box<dyn std::error::Error>> {
337 let config = PoolConfig::default();
339 assert_eq!(config.hypervisor, HypervisorType::CloudHypervisor);
340
341 let yaml = serde_yaml::to_string(&config)?;
343 assert!(
344 yaml.contains("cloud-hypervisor"),
345 "YAML should contain kebab-case hypervisor"
346 );
347 let parsed: PoolConfig = serde_yaml::from_str(&yaml)?;
348 assert_eq!(parsed.hypervisor, HypervisorType::CloudHypervisor);
349
350 let yaml_str = "hypervisor: cloud-hypervisor\nmax_sandboxes: 5";
352 let parsed: PoolConfig = serde_yaml::from_str(yaml_str)?;
353 assert_eq!(parsed.hypervisor, HypervisorType::CloudHypervisor);
354 assert_eq!(parsed.max_sandboxes, 5);
355 Ok(())
356 }
357
358 #[test]
359 fn test_hypervisor_type_display() {
360 assert_eq!(
361 HypervisorType::CloudHypervisor.to_string(),
362 "cloud-hypervisor"
363 );
364 #[cfg(feature = "dragonball")]
365 assert_eq!(HypervisorType::Dragonball.to_string(), "dragonball");
366 }
367
368 #[test]
369 fn test_backend_default_is_auto() {
370 assert_eq!(WorkerConfig::default().backend, "auto");
373 }
374
375 #[test]
376 fn test_backend_string_parses_verbatim() -> Result<(), Box<dyn std::error::Error>> {
377 for name in ["auto", "kata", "nspawn", "anything"] {
380 let yaml = format!("backend: {name}\n");
381 let config: WorkerConfig = serde_yaml::from_str(&yaml)?;
382 assert_eq!(config.backend, name);
383 }
384 Ok(())
385 }
386
387 #[test]
388 fn test_backend_absent_defaults_to_auto() -> Result<(), Box<dyn std::error::Error>> {
389 let config: WorkerConfig = serde_yaml::from_str("pool:\n max_sandboxes: 5\n")?;
391 assert_eq!(config.backend, "auto");
392 Ok(())
393 }
394}