use std::collections::BTreeMap;
use std::path::PathBuf;
use shep_core::config::ResolvedApp;
use shep_core::config::template;
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(|| DEFAULT_PATH.to_string());
env.insert("PATH".to_string(), path);
for key in INHERITED {
if let Ok(value) = std::env::var(key) {
env.insert(key.to_string(), value);
}
}
env
}
#[cfg(unix)]
const DEFAULT_PATH: &str = "/usr/local/bin:/usr/bin:/bin";
#[cfg(windows)]
const DEFAULT_PATH: &str = r"C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem";
#[cfg(unix)]
const INHERITED: &[&str] = &["HOME", "USER", "LANG", "TZ"];
#[cfg(windows)]
const INHERITED: &[&str] = &[
"SystemRoot",
"windir",
"SystemDrive",
"COMSPEC",
"PATHEXT",
"TEMP",
"TMP",
"USERPROFILE",
"HOMEDRIVE",
"HOMEPATH",
"APPDATA",
"LOCALAPPDATA",
"PROCESSOR_ARCHITECTURE",
"NUMBER_OF_PROCESSORS",
"OS",
"LANG",
"TZ",
];
#[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 rendered_args: Vec<String> = config
.args
.iter()
.map(|value| template::render(value, &name, instance))
.collect();
let (program, args) = match &config.interpreter {
None => (config.script.clone(), rendered_args),
Some(interp) if interp == "none" => (config.script.clone(), rendered_args),
Some(interp) => {
let mut interp_args = vec![config.script.clone()];
interp_args.extend(rendered_args);
(interp.clone(), interp_args)
}
};
let mut env = base_env();
env.extend(
config
.env
.iter()
.map(|(key, value)| (key.clone(), template::render(value, &name, instance))),
);
env.insert("SHEP_INSTANCE".to_string(), instance.to_string());
env.insert("SHEP_NAME".to_string(), name.clone());
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(template::render(explicit, &name, instance))
} else {
paths.logs.join(format!("{}out.log", log_stem))
};
let err_file = if let Some(ref explicit) = config.err_file {
PathBuf::from(template::render(explicit, &name, instance))
} 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/ada/.shep"),
daemon_config: PathBuf::from("/home/ada/.shep/shep.toml"),
dogs_config: PathBuf::from("/home/ada/.shep/dogs.toml"),
snapshot: PathBuf::from("/home/ada/.shep/flock.json"),
logs: PathBuf::from("/home/ada/.shep/logs"),
pids: PathBuf::from("/home/ada/.shep/pids"),
run: PathBuf::from("/home/ada/.shep/run"),
socket: PathBuf::from("/home/ada/.shep/run/shep.sock"),
barks: PathBuf::from("/home/ada/.shep/barks.jsonl"),
kv: PathBuf::from("/home/ada/.shep/kv.json"),
overrides: PathBuf::from("/home/ada/.shep/overrides.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 every_child_learns_its_slot_and_its_name() {
let app = normalize(AppConfig {
name: "worker".to_string(),
script: "bin/worker".to_string(),
..Default::default()
})
.unwrap();
let spec = assemble(&app, 3, &test_paths(), None);
assert_eq!(spec.env.get("SHEP_INSTANCE").map(String::as_str), Some("3"));
assert_eq!(
spec.env.get("SHEP_NAME").map(String::as_str),
Some("worker")
);
}
#[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/ada/.shep/logs/web-2-out.log")
);
assert_eq!(
spec.err_file,
PathBuf::from("/home/ada/.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/ada/.shep/logs/api-out.log")
);
assert_eq!(
spec.err_file,
PathBuf::from("/home/ada/.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/ada/.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 templates_render_per_instance_in_env_and_args() {
let mut config = AppConfig {
name: "z-worker".to_string(),
script: "bin/worker".to_string(),
instances: 4,
args: vec!["--metrics-port".to_string(), "91{{instance}}".to_string()],
..Default::default()
};
config
.env
.insert("Z_WORKER_ID".to_string(), "z-{{instance}}".to_string());
config.env.insert(
"Z_DEVICE_ID".to_string(),
"{{name}}-{{instance}}d".to_string(),
);
let app = normalize(config).unwrap();
let spec = assemble(&app, 2, &test_paths(), None);
assert_eq!(spec.env.get("Z_WORKER_ID").map(String::as_str), Some("z-2"));
assert_eq!(
spec.env.get("Z_DEVICE_ID").map(String::as_str),
Some("z-worker-2d")
);
assert!(spec.args.contains(&"912".to_string()), "{:?}", spec.args);
}
#[test]
fn a_templated_log_path_renders_per_instance() {
let app = normalize(AppConfig {
name: "web".to_string(),
script: "./srv".to_string(),
instances: 3,
out_file: Some("/var/log/web-{{instance}}.log".to_string()),
..Default::default()
})
.unwrap();
let spec = assemble(&app, 2, &test_paths(), None);
assert_eq!(spec.out_file, PathBuf::from("/var/log/web-2.log"));
}
#[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);
}
}