use std::ffi::{CStr, OsStr};
use std::os::unix::ffi::OsStrExt;
use std::path::{Path, PathBuf};
use std::process::{Command, ExitStatus, Stdio};
use std::time::Duration;
use anyhow::{Context, Result};
use crate::daemon::{self, Action, Caller, ServiceRecord};
pub const DEFAULT_LABEL: &str = "second-brain.api";
pub(crate) const DAEMONS_DIR: &str = "/Library/LaunchDaemons";
const BOOTSTRAP_ATTEMPTS: u32 = 5;
const BOOTSTRAP_PAUSE: Duration = Duration::from_secs(1);
const BOOTSTRAP_REFUSED: i32 = 5;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Account {
pub name: String,
pub home: PathBuf,
}
impl Account {
pub fn from_uid(uid: u32) -> Result<Self> {
let mut pwd: libc::passwd = unsafe { std::mem::zeroed() };
let mut buf = vec![0 as libc::c_char; 1024];
let mut found: *mut libc::passwd = std::ptr::null_mut();
loop {
let rc =
unsafe { libc::getpwuid_r(uid, &mut pwd, buf.as_mut_ptr(), buf.len(), &mut found) };
match rc {
0 => break,
libc::ERANGE => buf.resize(buf.len() * 2, 0),
rc => {
return Err(std::io::Error::from_raw_os_error(rc))
.with_context(|| format!("looking up uid {uid}"));
}
}
}
anyhow::ensure!(!found.is_null(), "no passwd entry for uid {uid}");
let name = unsafe { CStr::from_ptr(pwd.pw_name) }
.to_str()
.with_context(|| format!("user name of uid {uid} is not UTF-8"))?
.to_string();
let home = PathBuf::from(OsStr::from_bytes(
unsafe { CStr::from_ptr(pwd.pw_dir) }.to_bytes(),
));
Ok(Self { name, home })
}
pub fn log_dir(&self) -> PathBuf {
log_dir_in(&self.home)
}
}
pub(crate) fn log_dir_in(home: &Path) -> PathBuf {
home.join("Library/Logs/second-brain")
}
pub struct Daemon {
pub label: String,
pub plist: PathBuf,
}
impl Daemon {
pub fn new(label: &str) -> Self {
Self::in_dir(label, Path::new(DAEMONS_DIR))
}
pub(crate) fn in_dir(label: &str, dir: &Path) -> Self {
Self {
label: label.to_string(),
plist: dir.join(format!("{label}.plist")),
}
}
fn target(&self) -> String {
format!("system/{}", self.label)
}
pub fn record(&self) -> ServiceRecord {
ServiceRecord::launchd(&self.label)
}
}
pub struct PlistSpec<'a> {
pub label: &'a str,
pub program: &'a Path,
pub account: &'a Account,
pub db: &'a Path,
pub bind: &'a str,
}
pub fn render_plist(spec: &PlistSpec) -> Result<String> {
let home = absolute(&spec.account.home)?;
let log_dir = spec.account.log_dir();
let launchd_log = log_dir.join("launchd.log");
let program = absolute(spec.program)?;
let db = absolute(spec.db)?;
let log_dir = absolute(&log_dir)?;
let launchd_log = absolute(&launchd_log)?;
let env = [
("HOME", home),
("SECOND_BRAIN_DB", db),
("SECOND_BRAIN_BIND", spec.bind),
("RUST_LOG", "info,tower_http=warn"),
("SECOND_BRAIN_LOG_DIR", log_dir),
];
let env: String = env
.iter()
.map(|(k, v)| format!("\t\t<key>{k}</key>\n\t\t<string>{}</string>\n", escape(v)))
.collect();
Ok(format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>{label}</string>
<key>ProgramArguments</key>
<array>
<string>{program}</string>
</array>
<key>UserName</key>
<string>{user}</string>
<key>WorkingDirectory</key>
<string>{home}</string>
<key>EnvironmentVariables</key>
<dict>
{env} </dict>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>ThrottleInterval</key>
<integer>30</integer>
<key>StandardOutPath</key>
<string>{log}</string>
<key>StandardErrorPath</key>
<string>{log}</string>
</dict>
</plist>
"#,
label = escape(spec.label),
program = escape(program),
user = escape(&spec.account.name),
home = escape(home),
log = escape(launchd_log),
))
}
pub(crate) fn plist_program(plist: &str) -> Option<PathBuf> {
let (_, after) = plist.split_once("<key>ProgramArguments</key>")?;
let first = after
.trim_start()
.strip_prefix("<array>")?
.trim_start()
.strip_prefix("<string>")?;
let (program, _) = first.split_once("</string>")?;
Some(PathBuf::from(unescape(program)))
}
fn absolute(path: &Path) -> Result<&str> {
anyhow::ensure!(
path.is_absolute(),
"launchd needs absolute paths, got {}",
path.display()
);
path.to_str()
.with_context(|| format!("{} is not UTF-8", path.display()))
}
fn escape(text: &str) -> String {
let mut out = String::with_capacity(text.len());
for c in text.chars() {
match c {
'&' => out.push_str("&"),
'<' => out.push_str("<"),
'>' => out.push_str(">"),
'"' => out.push_str("""),
'\'' => out.push_str("'"),
c => out.push(c),
}
}
out
}
fn unescape(text: &str) -> String {
text.replace("<", "<")
.replace(">", ">")
.replace(""", "\"")
.replace("'", "'")
.replace("&", "&")
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Step {
Bootout,
Bootstrap,
Kickstart,
KickstartKill,
}
fn steps(action: Action, loaded: bool) -> Vec<Step> {
match (action, loaded) {
(Action::Start, true) => vec![Step::Kickstart],
(Action::Restart, true) => vec![Step::KickstartKill],
(Action::Stop, true) => vec![Step::Bootout],
(Action::Start | Action::Restart, false) => vec![Step::Bootstrap],
(Action::Stop, false) => vec![],
}
}
fn install_steps(loaded: bool) -> Vec<Step> {
if loaded {
vec![Step::Bootout, Step::Bootstrap]
} else {
vec![Step::Bootstrap]
}
}
fn probe_command(daemon: &Daemon) -> Command {
let mut cmd = Command::new("launchctl");
cmd.args(["print", &daemon.target()])
.stdout(Stdio::null())
.stderr(Stdio::null());
cmd
}
fn step_command(step: Step, daemon: &Daemon, caller: &Caller) -> Command {
let mut cmd = privileged("launchctl", caller);
match step {
Step::Bootout => cmd.args(["bootout", &daemon.target()]),
Step::Bootstrap => cmd.args(["bootstrap", "system"]).arg(&daemon.plist),
Step::Kickstart => cmd.args(["kickstart", &daemon.target()]),
Step::KickstartKill => cmd.args(["kickstart", "-k", &daemon.target()]),
};
cmd
}
fn install_command(source: &Path, daemon: &Daemon, caller: &Caller) -> Command {
let mut cmd = privileged("install", caller);
cmd.args(["-m", "0644", "-o", "root", "-g", "wheel"])
.arg(source)
.arg(&daemon.plist);
cmd
}
fn backup_command(daemon: &Daemon, backup: &Path, caller: &Caller) -> Command {
let mut cmd = privileged("cp", caller);
cmd.arg("-p").arg(&daemon.plist).arg(backup);
cmd
}
fn remove_command(daemon: &Daemon, caller: &Caller) -> Command {
let mut cmd = privileged("rm", caller);
cmd.arg("-f").arg(&daemon.plist);
cmd
}
fn privileged(program: &str, caller: &Caller) -> Command {
if caller.uid == 0 {
Command::new(program)
} else {
let mut sudo = Command::new("sudo");
sudo.arg(program);
sudo
}
}
pub trait Runner {
fn status(&mut self, cmd: Command) -> Result<ExitStatus>;
fn pause(&mut self, duration: Duration);
}
pub struct System;
impl Runner for System {
fn status(&mut self, mut cmd: Command) -> Result<ExitStatus> {
cmd.status()
.with_context(|| format!("failed to run {}", daemon::render(&cmd)))
}
fn pause(&mut self, duration: Duration) {
std::thread::sleep(duration);
}
}
pub fn control(
action: Action,
daemon: &Daemon,
caller: &Caller,
runner: &mut dyn Runner,
) -> Result<()> {
if action != Action::Stop && !daemon.plist.exists() {
anyhow::bail!(
"{} is missing; install the daemon with `sb setup`",
daemon.plist.display()
);
}
let loaded = is_loaded(daemon, runner)?;
run_steps(&steps(action, loaded), daemon, caller, runner)
}
pub fn is_loaded(daemon: &Daemon, runner: &mut dyn Runner) -> Result<bool> {
Ok(runner.status(probe_command(daemon))?.success())
}
fn run(runner: &mut dyn Runner, cmd: Command) -> Result<()> {
let shown = daemon::render(&cmd);
let status = runner.status(cmd)?;
anyhow::ensure!(status.success(), "{shown} failed ({status})");
Ok(())
}
fn run_steps(
steps: &[Step],
daemon: &Daemon,
caller: &Caller,
runner: &mut dyn Runner,
) -> Result<()> {
for &step in steps {
match step {
Step::Bootstrap => bootstrap(daemon, caller, runner)?,
step => run(runner, step_command(step, daemon, caller))?,
}
}
Ok(())
}
fn bootstrap(daemon: &Daemon, caller: &Caller, runner: &mut dyn Runner) -> Result<()> {
for _ in 1..BOOTSTRAP_ATTEMPTS {
let cmd = step_command(Step::Bootstrap, daemon, caller);
let shown = daemon::render(&cmd);
let status = runner.status(cmd)?;
match status.code() {
Some(0) => return Ok(()),
Some(BOOTSTRAP_REFUSED) => runner.pause(BOOTSTRAP_PAUSE),
_ => anyhow::bail!("{shown} failed ({status})"),
}
}
run(runner, step_command(Step::Bootstrap, daemon, caller))
}
pub struct Install<'a> {
pub daemon: &'a Daemon,
pub plist: &'a str,
pub staged: &'a Path,
pub backup: &'a Path,
pub log_dir: &'a Path,
pub record_path: &'a Path,
}
pub fn install(install: &Install, caller: &Caller, runner: &mut dyn Runner) -> Result<()> {
let loaded = is_loaded(install.daemon, runner)?;
let previous = install
.daemon
.plist
.try_exists()
.with_context(|| format!("checking {}", install.daemon.plist.display()))?;
std::fs::create_dir_all(install.log_dir)
.with_context(|| format!("creating {}", install.log_dir.display()))?;
std::fs::write(install.staged, install.plist)
.with_context(|| format!("writing {}", install.staged.display()))?;
let placed = place(install, previous, caller, runner);
let removed = std::fs::remove_file(install.staged)
.with_context(|| format!("removing {}", install.staged.display()));
if let Err(error) = placed {
return Err(match removed {
Ok(()) => error,
Err(e) => error.context(format!("the plist was not installed, but {e:#}")),
});
}
let loading = removed
.map_err(|error| Interrupted {
error,
booted_out: false,
})
.and_then(|()| load(install.daemon, loaded, caller, runner));
if let Err(Interrupted { error, booted_out }) = loading {
return Err(if previous {
restore_previous(install, booted_out, error, caller, runner)
} else {
remove_new(install.daemon, error, caller, runner)
});
}
daemon::save_record(install.record_path, &install.daemon.record())?;
if previous && let Err(e) = discard(install.backup) {
eprintln!(" warning: the daemon is installed, but {e:#}");
}
Ok(())
}
fn place(
install: &Install,
previous: bool,
caller: &Caller,
runner: &mut dyn Runner,
) -> Result<()> {
let backed_up = if previous {
run(
runner,
backup_command(install.daemon, install.backup, caller),
)
} else {
Ok(())
};
let placed = backed_up.and_then(|()| {
run(
runner,
install_command(install.staged, install.daemon, caller),
)
});
match placed {
Err(error) if previous => match discard(install.backup) {
Ok(()) => Err(error),
Err(e) => Err(error.context(format!("the plist was not installed, but {e:#}"))),
},
placed => placed,
}
}
struct Interrupted {
error: anyhow::Error,
booted_out: bool,
}
fn load(
daemon: &Daemon,
loaded: bool,
caller: &Caller,
runner: &mut dyn Runner,
) -> std::result::Result<(), Interrupted> {
let mut booted_out = false;
for step in install_steps(loaded) {
let done = match step {
Step::Bootstrap => bootstrap(daemon, caller, runner),
step => run(runner, step_command(step, daemon, caller)),
};
done.map_err(|error| Interrupted { error, booted_out })?;
booted_out |= step == Step::Bootout;
}
Ok(())
}
fn remove_new(
target: &Daemon,
error: anyhow::Error,
caller: &Caller,
runner: &mut dyn Runner,
) -> anyhow::Error {
match run(runner, remove_command(target, caller)) {
Ok(()) => error,
Err(e) => error.context(format!(
"removing the new plist also failed ({e:#}); run `{}` so launchd does not load it at the next boot",
daemon::render(&remove_command(target, caller))
)),
}
}
fn restore_previous(
install: &Install,
reload: bool,
error: anyhow::Error,
caller: &Caller,
runner: &mut dyn Runner,
) -> anyhow::Error {
let target = install.daemon;
let mut restored = run(runner, install_command(install.backup, target, caller));
if restored.is_ok() && reload {
restored = bootstrap(target, caller, runner);
}
if let Err(e) = restored {
let mut recover = vec![install_command(install.backup, target, caller)];
if reload {
recover.push(step_command(Step::Bootstrap, target, caller));
}
let recover: Vec<String> = recover
.iter()
.map(|c| format!("`{}`", daemon::render(c)))
.collect();
return error.context(format!(
"restoring the previous daemon also failed ({e:#}); recover with {}",
recover.join(" then ")
));
}
match discard(install.backup) {
Ok(()) => error,
Err(e) => error.context(format!("the previous daemon is restored, but {e:#}")),
}
}
fn discard(backup: &Path) -> Result<()> {
match std::fs::remove_file(backup) {
Err(e) if e.kind() != std::io::ErrorKind::NotFound => {
Err(e).with_context(|| format!("removing {}", backup.display()))
}
_ => Ok(()),
}
}
#[cfg(test)]
mod tests {
use std::os::unix::process::ExitStatusExt;
use super::*;
type Respond = Box<dyn FnMut(&[String]) -> i32>;
struct Fake {
calls: Vec<Vec<String>>,
pauses: Vec<Duration>,
respond: Respond,
}
impl Fake {
fn new(respond: impl FnMut(&[String]) -> i32 + 'static) -> Self {
Self {
calls: Vec::new(),
pauses: Vec::new(),
respond: Box::new(respond),
}
}
fn loaded(loaded: bool) -> Self {
Self::new(move |argv| match verb(argv) {
"print" => i32::from(!loaded),
_ => 0,
})
}
}
impl Runner for Fake {
fn status(&mut self, cmd: Command) -> Result<ExitStatus> {
let argv = argv(&cmd);
let code = (self.respond)(&argv);
self.calls.push(argv);
Ok(ExitStatus::from_raw(code << 8))
}
fn pause(&mut self, duration: Duration) {
self.pauses.push(duration);
}
}
fn verb(argv: &[String]) -> &str {
let program = usize::from(argv[0] == "sudo");
match argv[program].as_str() {
"launchctl" => &argv[program + 1],
other => other,
}
}
fn argv(cmd: &Command) -> Vec<String> {
std::iter::once(cmd.get_program())
.chain(cmd.get_args())
.map(|a| a.to_string_lossy().into_owned())
.collect()
}
const USER: u32 = 501;
fn daemon() -> Daemon {
Daemon::new("custom-brain.api")
}
fn daemon_with_plist(dir: &Path) -> Daemon {
let plist = dir.join("custom-brain.api.plist");
std::fs::write(&plist, "<plist/>").unwrap();
Daemon { plist, ..daemon() }
}
fn action_argv(action: Action, loaded: bool, uid: u32) -> Vec<Vec<String>> {
steps(action, loaded)
.into_iter()
.map(|s| argv(&step_command(s, &daemon(), &Caller::with_uid(uid))))
.collect()
}
fn sudo(args: &[&str]) -> Vec<String> {
std::iter::once("sudo")
.chain(args.iter().copied())
.map(String::from)
.collect()
}
fn plain(args: &[&str]) -> Vec<String> {
args.iter().map(|a| a.to_string()).collect()
}
const BOOTOUT: &[&str] = &["launchctl", "bootout", "system/custom-brain.api"];
const BOOTSTRAP: &[&str] = &[
"launchctl",
"bootstrap",
"system",
"/Library/LaunchDaemons/custom-brain.api.plist",
];
const KICKSTART: &[&str] = &["launchctl", "kickstart", "system/custom-brain.api"];
const KICKSTART_KILL: &[&str] = &["launchctl", "kickstart", "-k", "system/custom-brain.api"];
const PRINT: &[&str] = &["launchctl", "print", "system/custom-brain.api"];
#[test]
fn plist_path_comes_from_the_label() {
assert_eq!(
Daemon::new(DEFAULT_LABEL).plist,
PathBuf::from("/Library/LaunchDaemons/second-brain.api.plist")
);
assert_eq!(
daemon().record(),
ServiceRecord::launchd("custom-brain.api")
);
}
#[test]
fn plist_runs_the_daemon_as_the_account_with_escaped_absolute_paths() {
let account = Account {
name: "o'neil&co".to_string(),
home: PathBuf::from("/Users/a<b>"),
};
let plist = render_plist(&PlistSpec {
label: "second-brain.api",
program: Path::new("/opt/sb & co/second-brain-api"),
account: &account,
db: &account.home.join(".second-brain/brain.db"),
bind: "127.0.0.1:7200",
})
.unwrap();
assert_eq!(
plist,
r#"<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>second-brain.api</string>
<key>ProgramArguments</key>
<array>
<string>/opt/sb & co/second-brain-api</string>
</array>
<key>UserName</key>
<string>o'neil&co</string>
<key>WorkingDirectory</key>
<string>/Users/a<b></string>
<key>EnvironmentVariables</key>
<dict>
<key>HOME</key>
<string>/Users/a<b></string>
<key>SECOND_BRAIN_DB</key>
<string>/Users/a<b>/.second-brain/brain.db</string>
<key>SECOND_BRAIN_BIND</key>
<string>127.0.0.1:7200</string>
<key>RUST_LOG</key>
<string>info,tower_http=warn</string>
<key>SECOND_BRAIN_LOG_DIR</key>
<string>/Users/a<b>/Library/Logs/second-brain</string>
</dict>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>ThrottleInterval</key>
<integer>30</integer>
<key>StandardOutPath</key>
<string>/Users/a<b>/Library/Logs/second-brain/launchd.log</string>
<key>StandardErrorPath</key>
<string>/Users/a<b>/Library/Logs/second-brain/launchd.log</string>
</dict>
</plist>
"#
);
}
#[test]
fn plist_program_reads_back_the_escaped_program_path() {
let account = Account {
name: "alice".to_string(),
home: PathBuf::from("/Users/alice"),
};
let program = Path::new("/Users/a&b/it's <bin>/second-brain-api");
let plist = render_plist(&PlistSpec {
label: DEFAULT_LABEL,
program,
account: &account,
db: Path::new("/Users/alice/.second-brain/brain.db"),
bind: daemon::DEFAULT_BIND,
})
.unwrap();
assert_eq!(plist_program(&plist), Some(program.to_path_buf()));
assert_eq!(plist_program("<plist><dict/></plist>"), None);
}
#[test]
fn plist_refuses_relative_paths() {
let render = |program: &str, home: &str| {
let account = Account {
name: "u".to_string(),
home: PathBuf::from(home),
};
render_plist(&PlistSpec {
label: DEFAULT_LABEL,
program: Path::new(program),
account: &account,
db: &account.home.join(".second-brain/brain.db"),
bind: "127.0.0.1:7200",
})
};
assert!(render("bin/second-brain-api", "/Users/u").is_err());
assert!(render("/bin/second-brain-api", "Users/u").is_err());
assert!(render("/bin/second-brain-api", "/Users/u").is_ok());
}
#[test]
fn name_and_home_come_from_one_passwd_entry() {
let root = Account::from_uid(0).unwrap();
assert_eq!(root.name, "root");
assert!(root.home.is_absolute(), "{root:?}");
let me = Account::from_uid(unsafe { libc::getuid() }).unwrap();
assert!(!me.name.is_empty());
assert!(me.home.is_absolute(), "{me:?}");
}
#[test]
fn loaded_check_never_uses_sudo() {
assert_eq!(argv(&probe_command(&daemon())), plain(PRINT));
}
#[test]
fn actions_on_a_loaded_daemon() {
assert_eq!(action_argv(Action::Start, true, USER), [sudo(KICKSTART)]);
assert_eq!(action_argv(Action::Stop, true, USER), [sudo(BOOTOUT)]);
assert_eq!(
action_argv(Action::Restart, true, USER),
[sudo(KICKSTART_KILL)]
);
assert_eq!(action_argv(Action::Start, true, 0), [plain(KICKSTART)]);
assert_eq!(action_argv(Action::Stop, true, 0), [plain(BOOTOUT)]);
assert_eq!(
action_argv(Action::Restart, true, 0),
[plain(KICKSTART_KILL)]
);
}
#[test]
fn actions_on_an_unloaded_daemon() {
assert_eq!(action_argv(Action::Start, false, USER), [sudo(BOOTSTRAP)]);
assert!(action_argv(Action::Stop, false, USER).is_empty());
assert_eq!(action_argv(Action::Restart, false, USER), [sudo(BOOTSTRAP)]);
assert_eq!(action_argv(Action::Start, false, 0), [plain(BOOTSTRAP)]);
assert!(action_argv(Action::Stop, false, 0).is_empty());
assert_eq!(action_argv(Action::Restart, false, 0), [plain(BOOTSTRAP)]);
}
#[test]
fn install_reloads_a_loaded_daemon() {
let caller = Caller::with_uid(USER);
let run = |loaded| -> Vec<Vec<String>> {
install_steps(loaded)
.into_iter()
.map(|s| argv(&step_command(s, &daemon(), &caller)))
.collect()
};
assert_eq!(run(true), [sudo(BOOTOUT), sudo(BOOTSTRAP)]);
assert_eq!(run(false), [sudo(BOOTSTRAP)]);
}
#[test]
fn plist_install_is_root_owned_and_world_readable() {
let staged = Path::new("/Users/u/.second-brain/custom-brain.api.plist");
let expected = [
"install",
"-m",
"0644",
"-o",
"root",
"-g",
"wheel",
"/Users/u/.second-brain/custom-brain.api.plist",
"/Library/LaunchDaemons/custom-brain.api.plist",
];
assert_eq!(
argv(&install_command(staged, &daemon(), &Caller::with_uid(USER))),
sudo(&expected)
);
assert_eq!(
argv(&install_command(staged, &daemon(), &Caller::with_uid(0))),
plain(&expected)
);
}
#[test]
fn stop_on_an_unloaded_daemon_only_probes() {
let dir = tempfile::tempdir().unwrap();
let mut fake = Fake::loaded(false);
control(
Action::Stop,
&daemon_with_plist(dir.path()),
&Caller::with_uid(USER),
&mut fake,
)
.unwrap();
assert_eq!(fake.calls, [plain(PRINT)]);
}
#[test]
fn stop_without_a_plist_still_succeeds() {
let mut fake = Fake::loaded(false);
control(Action::Stop, &daemon(), &Caller::with_uid(USER), &mut fake).unwrap();
assert_eq!(fake.calls, [plain(PRINT)]);
}
#[test]
fn start_and_restart_without_a_plist_point_at_setup() {
for action in [Action::Start, Action::Restart] {
let mut fake = Fake::loaded(true);
let err = control(action, &daemon(), &Caller::with_uid(USER), &mut fake)
.unwrap_err()
.to_string();
assert!(
err.contains("/Library/LaunchDaemons/custom-brain.api.plist"),
"{err}"
);
assert!(err.contains("sb setup"), "{err}");
assert!(fake.calls.is_empty(), "{:?}", fake.calls);
}
}
#[test]
fn control_runs_the_steps_for_the_probed_state() {
let dir = tempfile::tempdir().unwrap();
let daemon = daemon_with_plist(dir.path());
let bootstrap = sudo(&[
"launchctl",
"bootstrap",
"system",
daemon.plist.to_str().unwrap(),
]);
let cases = [
(Action::Start, false, bootstrap.clone()),
(Action::Start, true, sudo(KICKSTART)),
(Action::Restart, false, bootstrap),
(Action::Restart, true, sudo(KICKSTART_KILL)),
(Action::Stop, true, sudo(BOOTOUT)),
];
for (action, loaded, expected) in cases {
let mut fake = Fake::loaded(loaded);
control(action, &daemon, &Caller::with_uid(USER), &mut fake).unwrap();
assert_eq!(fake.calls, [plain(PRINT), expected], "{action:?} {loaded}");
}
}
#[test]
fn failed_step_names_the_command() {
let dir = tempfile::tempdir().unwrap();
let mut fake = Fake::new(|argv| i32::from(argv.iter().any(|a| a == "kickstart")));
let err = control(
Action::Start,
&daemon_with_plist(dir.path()),
&Caller::with_uid(USER),
&mut fake,
)
.unwrap_err()
.to_string();
assert!(err.contains("kickstart system/custom-brain.api"), "{err}");
}
#[test]
fn bootstrap_retries_while_launchd_refuses_with_error_5() {
let dir = tempfile::tempdir().unwrap();
let mut refusals = 2;
let mut fake = Fake::new(move |argv| match verb(argv) {
"print" => 1,
"bootstrap" if refusals > 0 => {
refusals -= 1;
5
}
_ => 0,
});
control(
Action::Start,
&daemon_with_plist(dir.path()),
&Caller::with_uid(USER),
&mut fake,
)
.unwrap();
let bootstraps = fake.calls.iter().filter(|c| verb(c) == "bootstrap").count();
assert_eq!(bootstraps, 3);
assert_eq!(fake.pauses, [BOOTSTRAP_PAUSE, BOOTSTRAP_PAUSE]);
}
#[test]
fn bootstrap_gives_up_after_its_attempts() {
let dir = tempfile::tempdir().unwrap();
let mut fake = Fake::new(|argv| match verb(argv) {
"print" => 1,
_ => 5,
});
let err = control(
Action::Start,
&daemon_with_plist(dir.path()),
&Caller::with_uid(USER),
&mut fake,
)
.unwrap_err()
.to_string();
assert!(err.contains("bootstrap"), "{err}");
let bootstraps = fake.calls.iter().filter(|c| verb(c) == "bootstrap").count();
assert_eq!(bootstraps, BOOTSTRAP_ATTEMPTS as usize);
assert_eq!(fake.pauses.len(), BOOTSTRAP_ATTEMPTS as usize - 1);
}
#[test]
fn bootstrap_does_not_retry_other_failures() {
let dir = tempfile::tempdir().unwrap();
let mut fake = Fake::new(|argv| match verb(argv) {
"print" => 1,
_ => 1,
});
control(
Action::Start,
&daemon_with_plist(dir.path()),
&Caller::with_uid(USER),
&mut fake,
)
.unwrap_err();
let bootstraps = fake.calls.iter().filter(|c| verb(c) == "bootstrap").count();
assert_eq!(bootstraps, 1);
assert!(fake.pauses.is_empty());
}
struct InstallDirs {
root: tempfile::TempDir,
staged: PathBuf,
backup: PathBuf,
log_dir: PathBuf,
record: PathBuf,
}
fn install_dirs() -> InstallDirs {
let root = tempfile::tempdir().unwrap();
let data = root.path().join(".second-brain");
std::fs::create_dir_all(&data).unwrap();
InstallDirs {
staged: data.join("custom-brain.api.plist"),
backup: data.join("custom-brain.api.plist.previous"),
log_dir: root.path().join("Library/Logs/second-brain"),
record: data.join("service.json"),
root,
}
}
fn run_install(dirs: &InstallDirs, fake: &mut Fake) -> Result<()> {
install_daemon(dirs, &daemon(), fake)
}
fn install_daemon(dirs: &InstallDirs, daemon: &Daemon, fake: &mut Fake) -> Result<()> {
install(
&Install {
daemon,
plist: "<plist/>",
staged: &dirs.staged,
backup: &dirs.backup,
log_dir: &dirs.log_dir,
record_path: &dirs.record,
},
&Caller::with_uid(USER),
fake,
)
}
fn installed_daemon(dirs: &InstallDirs) -> Daemon {
let daemon = fresh_daemon(dirs);
std::fs::write(&daemon.plist, "<old/>").unwrap();
daemon
}
fn fresh_daemon(dirs: &InstallDirs) -> Daemon {
let plist = dirs
.root
.path()
.join("LaunchDaemons/custom-brain.api.plist");
std::fs::create_dir_all(plist.parent().unwrap()).unwrap();
Daemon { plist, ..daemon() }
}
fn machine(mut code: impl FnMut(&str) -> i32 + 'static) -> Fake {
Fake::new(move |argv| {
let verb = verb(argv);
let code = code(verb);
if code == 0 {
let path = |i: usize| PathBuf::from(&argv[argv.len() - i]);
match verb {
"install" | "cp" => {
std::fs::copy(path(2), path(1)).unwrap();
}
"rm" => std::fs::remove_file(path(1)).unwrap(),
_ => {}
}
}
code
})
}
fn calls_for(daemon: &Daemon, dirs: &InstallDirs, steps: &[&str]) -> Vec<Vec<String>> {
let caller = Caller::with_uid(USER);
steps
.iter()
.map(|step| match *step {
"print" => argv(&probe_command(daemon)),
"backup" => argv(&backup_command(daemon, &dirs.backup, &caller)),
"install" => argv(&install_command(&dirs.staged, daemon, &caller)),
"restore" => argv(&install_command(&dirs.backup, daemon, &caller)),
"remove" => argv(&remove_command(daemon, &caller)),
"bootout" => argv(&step_command(Step::Bootout, daemon, &caller)),
"bootstrap" => argv(&step_command(Step::Bootstrap, daemon, &caller)),
other => panic!("unknown step {other}"),
})
.collect()
}
fn bootstrap_failure(daemon: &Daemon) -> String {
format!(
"{} failed (exit status: 1)",
daemon::render(&step_command(
Step::Bootstrap,
daemon,
&Caller::with_uid(USER)
))
)
}
#[test]
fn setup_installs_then_bootstraps_and_records_launchd() {
for loaded in [false, true] {
let dirs = install_dirs();
let staged = dirs.staged.clone();
let log_dir = dirs.log_dir.clone();
let mut fake = Fake::new(move |argv| match verb(argv) {
"print" => i32::from(!loaded),
"bootstrap" => {
assert!(log_dir.is_dir(), "log dir missing at bootstrap");
0
}
"install" => {
assert_eq!(std::fs::read_to_string(&staged).unwrap(), "<plist/>");
0
}
_ => 0,
});
run_install(&dirs, &mut fake).unwrap();
let mut expected = vec![
plain(PRINT),
sudo(&[
"install",
"-m",
"0644",
"-o",
"root",
"-g",
"wheel",
dirs.staged.to_str().unwrap(),
"/Library/LaunchDaemons/custom-brain.api.plist",
]),
];
if loaded {
expected.push(sudo(BOOTOUT));
}
expected.push(sudo(BOOTSTRAP));
assert_eq!(fake.calls, expected, "loaded={loaded}");
let json: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&dirs.record).unwrap()).unwrap();
assert_eq!(
json,
serde_json::json!({"manager": "launchd", "unit": "custom-brain.api", "scope": "system"})
);
assert!(!dirs.staged.exists());
}
}
#[test]
fn failed_plist_install_stops_before_launchctl_and_records_nothing() {
let dirs = install_dirs();
let mut fake = Fake::new(|argv| match verb(argv) {
"print" => 1,
"install" => 1,
_ => 0,
});
let err = run_install(&dirs, &mut fake).unwrap_err().to_string();
assert!(err.contains("install"), "{err}");
assert_eq!(fake.calls.len(), 2, "{:?}", fake.calls);
assert!(!dirs.record.exists());
assert!(!dirs.staged.exists());
}
#[test]
fn backup_and_removal_go_through_sudo() {
let backup = Path::new("/Users/u/.second-brain/custom-brain.api.plist.previous");
assert_eq!(
argv(&backup_command(&daemon(), backup, &Caller::with_uid(USER))),
sudo(&[
"cp",
"-p",
"/Library/LaunchDaemons/custom-brain.api.plist",
"/Users/u/.second-brain/custom-brain.api.plist.previous",
])
);
assert_eq!(
argv(&remove_command(&daemon(), &Caller::with_uid(USER))),
sudo(&["rm", "-f", "/Library/LaunchDaemons/custom-brain.api.plist"])
);
assert_eq!(
argv(&remove_command(&daemon(), &Caller::with_uid(0))),
plain(&["rm", "-f", "/Library/LaunchDaemons/custom-brain.api.plist"])
);
}
#[test]
fn failed_install_over_a_previous_plist_changes_nothing() {
let dirs = install_dirs();
let daemon = installed_daemon(&dirs);
let mut fake = machine(|verb| match verb {
"print" => 0,
"install" => 1,
_ => 0,
});
let err = install_daemon(&dirs, &daemon, &mut fake).unwrap_err();
assert_eq!(
format!("{err:#}"),
format!(
"{} failed (exit status: 1)",
daemon::render(&install_command(
&dirs.staged,
&daemon,
&Caller::with_uid(USER)
))
)
);
assert_eq!(
fake.calls,
calls_for(&daemon, &dirs, &["print", "backup", "install"])
);
assert_eq!(std::fs::read_to_string(&daemon.plist).unwrap(), "<old/>");
assert!(!dirs.staged.exists());
assert!(!dirs.backup.exists());
assert!(!dirs.record.exists());
}
#[test]
fn failed_backup_stops_before_the_install() {
let dirs = install_dirs();
let daemon = installed_daemon(&dirs);
let mut fake = machine(|verb| match verb {
"print" => 0,
"cp" => 1,
_ => 0,
});
let err = install_daemon(&dirs, &daemon, &mut fake).unwrap_err();
assert!(format!("{err:#}").contains("cp -p"), "{err:#}");
assert_eq!(fake.calls, calls_for(&daemon, &dirs, &["print", "backup"]));
assert_eq!(std::fs::read_to_string(&daemon.plist).unwrap(), "<old/>");
assert!(!dirs.staged.exists());
assert!(!dirs.backup.exists());
assert!(!dirs.record.exists());
}
#[test]
fn fresh_install_removes_its_plist_when_bootstrap_fails() {
for loaded in [false, true] {
let dirs = install_dirs();
let daemon = fresh_daemon(&dirs);
let mut fake = machine(move |verb| match verb {
"print" => i32::from(!loaded),
"bootstrap" => 1,
_ => 0,
});
let err = install_daemon(&dirs, &daemon, &mut fake).unwrap_err();
assert_eq!(format!("{err:#}"), bootstrap_failure(&daemon));
let mut steps = vec!["print", "install"];
if loaded {
steps.push("bootout");
}
steps.extend(["bootstrap", "remove"]);
assert_eq!(
fake.calls,
calls_for(&daemon, &dirs, &steps),
"loaded={loaded}"
);
assert!(!daemon.plist.exists());
assert!(!dirs.staged.exists());
assert!(!dirs.record.exists());
}
}
#[test]
fn failed_cleanup_is_attached_to_the_bootstrap_error() {
let dirs = install_dirs();
let daemon = fresh_daemon(&dirs);
let mut fake = machine(|verb| match verb {
"print" => 1,
"bootstrap" | "rm" => 1,
_ => 0,
});
let err = install_daemon(&dirs, &daemon, &mut fake).unwrap_err();
assert_eq!(err.root_cause().to_string(), bootstrap_failure(&daemon));
let remove = daemon::render(&remove_command(&daemon, &Caller::with_uid(USER)));
let shown = format!("{err:#}");
assert!(shown.contains(&format!("{remove} failed")), "{shown}");
assert!(shown.contains(&format!("`{remove}`")), "{shown}");
assert!(daemon.plist.exists());
assert!(!dirs.record.exists());
}
#[test]
fn reinstall_restores_and_reloads_the_previous_daemon_when_bootstrap_fails() {
let dirs = install_dirs();
let daemon = installed_daemon(&dirs);
std::fs::write(&dirs.record, "previous record").unwrap();
let mut bootstraps = 0;
let mut fake = machine(move |verb| match verb {
"print" => 0,
"bootstrap" => {
bootstraps += 1;
i32::from(bootstraps == 1)
}
_ => 0,
});
let err = install_daemon(&dirs, &daemon, &mut fake).unwrap_err();
assert_eq!(format!("{err:#}"), bootstrap_failure(&daemon));
assert_eq!(
fake.calls,
calls_for(
&daemon,
&dirs,
&[
"print",
"backup",
"install",
"bootout",
"bootstrap",
"restore",
"bootstrap"
]
)
);
assert_eq!(std::fs::read_to_string(&daemon.plist).unwrap(), "<old/>");
assert_eq!(
std::fs::read_to_string(&dirs.record).unwrap(),
"previous record"
);
assert!(!dirs.backup.exists());
assert!(!dirs.staged.exists());
}
#[test]
fn reinstall_leaves_a_stopped_daemon_stopped_when_bootstrap_fails() {
let dirs = install_dirs();
let daemon = installed_daemon(&dirs);
let mut fake = machine(|verb| match verb {
"print" => 1,
"bootstrap" => 1,
_ => 0,
});
let err = install_daemon(&dirs, &daemon, &mut fake).unwrap_err();
assert_eq!(format!("{err:#}"), bootstrap_failure(&daemon));
assert_eq!(
fake.calls,
calls_for(
&daemon,
&dirs,
&["print", "backup", "install", "bootstrap", "restore"]
)
);
assert_eq!(std::fs::read_to_string(&daemon.plist).unwrap(), "<old/>");
assert!(!dirs.backup.exists());
assert!(!dirs.record.exists());
}
#[test]
fn failed_bootout_restores_the_previous_plist_without_a_bootstrap() {
let dirs = install_dirs();
let daemon = installed_daemon(&dirs);
let mut fake = machine(|verb| match verb {
"print" => 0,
"bootout" => 1,
_ => 0,
});
let err = install_daemon(&dirs, &daemon, &mut fake).unwrap_err();
assert_eq!(
format!("{err:#}"),
format!(
"{} failed (exit status: 1)",
daemon::render(&step_command(
Step::Bootout,
&daemon,
&Caller::with_uid(USER)
))
)
);
assert_eq!(
fake.calls,
calls_for(
&daemon,
&dirs,
&["print", "backup", "install", "bootout", "restore"]
)
);
assert_eq!(std::fs::read_to_string(&daemon.plist).unwrap(), "<old/>");
assert!(!dirs.backup.exists());
assert!(!dirs.record.exists());
}
#[test]
fn failed_restore_keeps_the_backup_and_names_the_recovery_commands() {
let dirs = install_dirs();
let daemon = installed_daemon(&dirs);
let mut installs = 0;
let mut fake = machine(move |verb| match verb {
"print" => 0,
"bootstrap" => 1,
"install" => {
installs += 1;
i32::from(installs == 2)
}
_ => 0,
});
let err = install_daemon(&dirs, &daemon, &mut fake).unwrap_err();
assert_eq!(err.root_cause().to_string(), bootstrap_failure(&daemon));
let caller = Caller::with_uid(USER);
let shown = format!("{err:#}");
for recover in [
install_command(&dirs.backup, &daemon, &caller),
step_command(Step::Bootstrap, &daemon, &caller),
] {
let recover = format!("`{}`", daemon::render(&recover));
assert!(shown.contains(&recover), "{shown}");
}
assert_eq!(std::fs::read_to_string(&dirs.backup).unwrap(), "<old/>");
assert!(!dirs.record.exists());
}
#[test]
fn reinstall_discards_the_backup_and_records_launchd() {
let dirs = install_dirs();
let daemon = installed_daemon(&dirs);
let mut fake = machine(|_| 0);
install_daemon(&dirs, &daemon, &mut fake).unwrap();
assert_eq!(
fake.calls,
calls_for(
&daemon,
&dirs,
&["print", "backup", "install", "bootout", "bootstrap"]
)
);
assert_eq!(std::fs::read_to_string(&daemon.plist).unwrap(), "<plist/>");
assert!(!dirs.backup.exists());
assert!(!dirs.staged.exists());
assert!(dirs.record.exists());
}
#[test]
fn failed_staged_removal_restores_the_previous_plist_before_any_bootout() {
let dirs = install_dirs();
let daemon = installed_daemon(&dirs);
let staged = dirs.staged.clone();
let mut fake = Fake::new(move |argv| {
let path = |i: usize| PathBuf::from(&argv[argv.len() - i]);
if matches!(verb(argv), "cp" | "install") {
std::fs::copy(path(2), path(1)).unwrap();
if path(2) == staged {
std::fs::remove_file(&staged).unwrap();
}
}
0
});
let err = install_daemon(&dirs, &daemon, &mut fake).unwrap_err();
assert!(
format!("{err:#}").starts_with(&format!("removing {}", dirs.staged.display())),
"{err:#}"
);
assert_eq!(
fake.calls,
calls_for(&daemon, &dirs, &["print", "backup", "install", "restore"])
);
assert_eq!(std::fs::read_to_string(&daemon.plist).unwrap(), "<old/>");
assert!(!dirs.backup.exists());
assert!(!dirs.record.exists());
}
}