use std::collections::BTreeMap;
use std::path::PathBuf;
use shep_core::config::ResolvedApp;
use shep_core::paths::ShepPaths;
use crate::privilege::Credentials;
use crate::runner::SpawnSpec;
#[must_use]
pub fn instance_slots(existing: &[u32], count: u32) -> Vec<u32> {
let mut result = Vec::with_capacity(count as usize);
let mut candidate = 0u32;
for _ in 0..count {
while existing.contains(&candidate) || result.contains(&candidate) {
candidate += 1;
}
result.push(candidate);
candidate += 1;
}
result
}
fn base_env() -> BTreeMap<String, String> {
let mut env = BTreeMap::new();
let path = std::env::var("PATH")
.ok()
.filter(|value| !value.is_empty())
.unwrap_or_else(|| "/usr/local/bin:/usr/bin:/bin".to_string());
env.insert("PATH".to_string(), path);
for key in ["HOME", "USER", "LANG", "TZ"] {
if let Ok(value) = std::env::var(key) {
env.insert(key.to_string(), value);
}
}
env
}
#[must_use]
pub fn assemble(
app: &ResolvedApp,
instance: u32,
paths: &ShepPaths,
credentials: Option<Credentials>,
) -> SpawnSpec {
let config = app.config();
let name = config.name.clone();
let (program, args) = match &config.interpreter {
None => {
(config.script.clone(), config.args.clone())
}
Some(interp) if interp == "none" => {
(config.script.clone(), config.args.clone())
}
Some(interp) => {
let mut interp_args = vec![config.script.clone()];
interp_args.extend(config.args.iter().cloned());
(interp.clone(), interp_args)
}
};
let mut env = base_env();
env.extend(config.env.clone());
let slot_var = config.increment_var.as_deref().unwrap_or("SHEP_INSTANCE");
env.insert(slot_var.to_string(), instance.to_string());
let cwd = config.cwd.as_ref().map(PathBuf::from);
let log_stem = if config.merge_logs {
format!("{}-", name)
} else {
format!("{}-{}-", name, instance)
};
let out_file = if let Some(ref explicit) = config.out_file {
PathBuf::from(explicit)
} else {
paths.logs.join(format!("{}out.log", log_stem))
};
let err_file = if let Some(ref explicit) = config.err_file {
PathBuf::from(explicit)
} else {
paths.logs.join(format!("{}err.log", log_stem))
};
let channel = config.channel || config.wait_ready || config.shutdown_with_message;
SpawnSpec {
name,
program,
args,
cwd,
env,
out_file,
err_file,
channel,
stdin: config.stdin,
credentials,
}
}
#[cfg(test)]
mod tests {
use super::*;
use shep_core::config::{AppConfig, normalize};
fn test_paths() -> ShepPaths {
ShepPaths {
home: PathBuf::from("/home/rin/.shep"),
daemon_config: PathBuf::from("/home/rin/.shep/shep.toml"),
snapshot: PathBuf::from("/home/rin/.shep/flock.json"),
logs: PathBuf::from("/home/rin/.shep/logs"),
pids: PathBuf::from("/home/rin/.shep/pids"),
run: PathBuf::from("/home/rin/.shep/run"),
socket: PathBuf::from("/home/rin/.shep/run/shep.sock"),
barks: PathBuf::from("/home/rin/.shep/barks.jsonl"),
kv: PathBuf::from("/home/rin/.shep/kv.json"),
}
}
#[test]
fn slots_empty_request() {
let result = instance_slots(&[], 3);
assert_eq!(result, vec![0, 1, 2]);
}
#[test]
fn slots_skip_occupied() {
let result = instance_slots(&[0, 2], 2);
assert_eq!(result, vec![1, 3]);
}
#[test]
fn env_adds_shep_instance() {
let app_config = AppConfig {
name: "web".to_string(),
script: "/usr/bin/python3".to_string(),
args: vec!["app.py".to_string()],
interpreter: Some("none".to_string()),
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 1, &paths, None);
assert!(spec.env.contains_key("SHEP_INSTANCE"));
assert_eq!(spec.env.get("SHEP_INSTANCE").map(|s| s.as_str()), Some("1"));
}
#[test]
fn env_custom_increment_var() {
let mut app_config = AppConfig {
name: "worker".to_string(),
script: "bin/worker".to_string(),
args: vec![],
..Default::default()
};
app_config.increment_var = Some("WORKER_ID".to_string());
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 5, &paths, None);
assert!(!spec.env.contains_key("SHEP_INSTANCE"));
assert_eq!(spec.env.get("WORKER_ID").map(|s| s.as_str()), Some("5"));
}
#[test]
fn interpreter_none_runs_script_directly() {
let app_config = AppConfig {
name: "app".to_string(),
script: "/opt/bin/server".to_string(),
args: vec!["--port".to_string(), "8080".to_string()],
interpreter: None,
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 0, &paths, None);
assert_eq!(spec.program, "/opt/bin/server");
assert_eq!(spec.args, vec!["--port", "8080"]);
}
#[test]
fn interpreter_explicit_none_runs_script_directly() {
let app_config = AppConfig {
name: "app".to_string(),
script: "server.py".to_string(),
args: vec!["--verbose".to_string()],
interpreter: Some("none".to_string()),
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 0, &paths, None);
assert_eq!(spec.program, "server.py");
assert_eq!(spec.args, vec!["--verbose"]);
}
#[test]
fn interpreter_path_prepends_script() {
let app_config = AppConfig {
name: "app".to_string(),
script: "app.js".to_string(),
args: vec!["--debug".to_string(), "true".to_string()],
interpreter: Some("node".to_string()),
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 0, &paths, None);
assert_eq!(spec.program, "node");
assert_eq!(spec.args, vec!["app.js", "--debug", "true"]);
}
#[test]
fn merge_logs_false_uses_instance_suffix() {
let app_config = AppConfig {
name: "web".to_string(),
script: "app".to_string(),
args: vec![],
merge_logs: false,
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 2, &paths, None);
assert_eq!(
spec.out_file,
PathBuf::from("/home/rin/.shep/logs/web-2-out.log")
);
assert_eq!(
spec.err_file,
PathBuf::from("/home/rin/.shep/logs/web-2-err.log")
);
}
#[test]
fn merge_logs_true_omits_instance_suffix() {
let app_config = AppConfig {
name: "api".to_string(),
script: "api".to_string(),
args: vec![],
merge_logs: true,
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 1, &paths, None);
assert_eq!(
spec.out_file,
PathBuf::from("/home/rin/.shep/logs/api-out.log")
);
assert_eq!(
spec.err_file,
PathBuf::from("/home/rin/.shep/logs/api-err.log")
);
}
#[test]
fn explicit_out_file_wins() {
let app_config = AppConfig {
name: "app".to_string(),
script: "app".to_string(),
args: vec![],
merge_logs: false,
out_file: Some("/var/log/myapp.log".to_string()),
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 0, &paths, None);
assert_eq!(spec.out_file, PathBuf::from("/var/log/myapp.log"));
assert_eq!(
spec.err_file,
PathBuf::from("/home/rin/.shep/logs/app-0-err.log")
);
}
#[test]
fn channel_enabled_by_its_own_field() {
let app_config = AppConfig {
name: "app".to_string(),
script: "app".to_string(),
args: vec![],
channel: true,
wait_ready: false,
shutdown_with_message: false,
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 0, &paths, None);
assert!(spec.channel);
}
#[test]
fn channel_enabled_by_wait_ready() {
let app_config = AppConfig {
name: "app".to_string(),
script: "app".to_string(),
args: vec![],
channel: false,
wait_ready: true,
shutdown_with_message: false,
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 0, &paths, None);
assert!(spec.channel);
}
#[test]
fn channel_enabled_by_shutdown_with_message() {
let app_config = AppConfig {
name: "app".to_string(),
script: "app".to_string(),
args: vec![],
channel: false,
wait_ready: false,
shutdown_with_message: true,
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 0, &paths, None);
assert!(spec.channel);
}
#[test]
fn channel_disabled_when_all_three_flags_are_false() {
let app_config = AppConfig {
name: "app".to_string(),
script: "app".to_string(),
args: vec![],
channel: false,
wait_ready: false,
shutdown_with_message: false,
..Default::default()
};
let app = normalize(app_config).unwrap();
let paths = test_paths();
let spec = assemble(&app, 0, &paths, None);
assert!(!spec.channel);
}
#[test]
fn assembled_env_always_carries_a_path() {
let app_config = AppConfig {
name: "web".to_string(),
script: "app.js".to_string(),
args: vec![],
interpreter: Some("node".to_string()),
..Default::default()
};
let app = normalize(app_config).unwrap();
let spec = assemble(&app, 0, &test_paths(), None);
let path = spec
.env
.get("PATH")
.expect("PATH must survive env_clear()+envs(&spec.env)");
assert!(
!path.is_empty(),
"an empty PATH is exactly the ENOENT failure mode"
);
}
#[test]
fn an_explicit_app_path_overrides_the_seeded_default() {
let mut app_config = AppConfig {
name: "web".to_string(),
script: "app.js".to_string(),
args: vec![],
interpreter: Some("node".to_string()),
..Default::default()
};
app_config
.env
.insert("PATH".to_string(), "/opt/custom/bin".to_string());
let app = normalize(app_config).unwrap();
let spec = assemble(&app, 0, &test_paths(), None);
assert_eq!(
spec.env.get("PATH").map(String::as_str),
Some("/opt/custom/bin")
);
}
#[test]
fn the_stdin_flag_reaches_the_spawn_spec() {
let mut app = AppConfig::minimal("repl", "./repl");
app.stdin = true;
let spec = assemble(&normalize(app).unwrap(), 0, &test_paths(), None);
assert!(spec.stdin);
}
#[test]
fn nothing_else_turns_stdin_on() {
let mut app = AppConfig::minimal("web", "./srv");
app.channel = true;
app.wait_ready = true;
app.shutdown_with_message = true;
let spec = assemble(&normalize(app).unwrap(), 0, &test_paths(), None);
assert!(spec.channel, "the fixture should still open a channel");
assert!(!spec.stdin);
}
}