138 lines
4.5 KiB
Rust
138 lines
4.5 KiB
Rust
//! `bxcore::instance`: the lock that keeps a daemon to one instance (M5b spec, section 9a). Two
|
|
//! opens of the same file in one process are two holders, as two processes are. Do not edit.
|
|
|
|
#[path = "support/tmp.rs"]
|
|
mod tmp;
|
|
|
|
use std::os::unix::fs::PermissionsExt;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
use bxcore::instance::{LockError, RUNBOOK, lock};
|
|
use tmp::TempDir;
|
|
|
|
/// Gives a directory back its owner's permissions when dropped, so the `TempDir` declared before
|
|
/// it can be removed even when an assertion fails (tip T44).
|
|
struct Restore(PathBuf);
|
|
|
|
impl Drop for Restore {
|
|
fn drop(&mut self) {
|
|
let _ = std::fs::set_permissions(&self.0, std::fs::Permissions::from_mode(0o700));
|
|
}
|
|
}
|
|
|
|
fn mode(path: &Path) -> u32 {
|
|
std::fs::metadata(path).unwrap().permissions().mode() & 0o777
|
|
}
|
|
|
|
#[test]
|
|
fn a_second_lock_is_held_while_the_first_lives() {
|
|
let dir = TempDir::new("lock-held");
|
|
let path = dir.path().join("run").join("loopd.lock");
|
|
let first = lock(&path).expect("the first lock");
|
|
for _ in 0..3 {
|
|
match lock(&path) {
|
|
Err(LockError::Held) => {}
|
|
other => panic!("a second lock while the first lives: {other:?}"),
|
|
}
|
|
}
|
|
drop(first);
|
|
}
|
|
|
|
#[test]
|
|
fn the_lock_is_free_again_once_the_first_is_dropped() {
|
|
let dir = TempDir::new("lock-free");
|
|
let path = dir.path().join("run").join("loopd.lock");
|
|
let first = lock(&path).expect("the first lock");
|
|
drop(first);
|
|
let second = lock(&path).expect("the lock after the first was dropped");
|
|
assert!(
|
|
matches!(lock(&path), Err(LockError::Held)),
|
|
"the second holds it now"
|
|
);
|
|
drop(second);
|
|
assert!(path.exists(), "the lock file is left in place");
|
|
}
|
|
|
|
#[test]
|
|
fn a_lock_file_left_behind_is_taken() {
|
|
// A killed daemon leaves its lock file, unlocked; the next start takes it and keeps its bytes.
|
|
let dir = TempDir::new("lock-left");
|
|
let path = dir.write("run/memoryd.lock", "left\n");
|
|
let held = lock(&path).expect("a lock file nobody holds");
|
|
assert_eq!(std::fs::read_to_string(&path).unwrap(), "left\n");
|
|
drop(held);
|
|
}
|
|
|
|
#[test]
|
|
fn the_lock_file_is_created_with_mode_0600_and_its_directory_0700() {
|
|
let dir = TempDir::new("lock-mode");
|
|
let run = dir.path().join("home").join("run");
|
|
let path = run.join("brokerd.lock");
|
|
let held = lock(&path).expect("a lock in a directory that does not exist yet");
|
|
assert_eq!(mode(&path), 0o600, "the lock file");
|
|
assert_eq!(mode(&run), 0o700, "the directory it made");
|
|
assert_eq!(mode(&dir.path().join("home")), 0o700, "and the one above");
|
|
assert_eq!(
|
|
std::fs::metadata(&path).unwrap().len(),
|
|
0,
|
|
"nothing is written"
|
|
);
|
|
drop(held);
|
|
}
|
|
|
|
#[test]
|
|
fn a_directory_that_cannot_be_written_is_an_io_error() {
|
|
let dir = TempDir::new("lock-ro");
|
|
let run = dir.path().join("run");
|
|
std::fs::create_dir(&run).unwrap();
|
|
let _restore = Restore(run.clone());
|
|
std::fs::set_permissions(&run, std::fs::Permissions::from_mode(0o500)).unwrap();
|
|
match lock(&run.join("gatewayd.lock")) {
|
|
Err(LockError::Io(e)) => {
|
|
assert_eq!(e.kind(), std::io::ErrorKind::PermissionDenied, "{e}");
|
|
}
|
|
other => panic!("a lock in a read-only directory: {other:?}"),
|
|
}
|
|
assert!(!run.join("gatewayd.lock").exists());
|
|
}
|
|
|
|
#[test]
|
|
fn a_path_through_a_file_is_an_io_error() {
|
|
let dir = TempDir::new("lock-file");
|
|
let file = dir.write("run", "not a directory\n");
|
|
match lock(&file.join("loopd.lock")) {
|
|
Err(LockError::Io(_)) => {}
|
|
other => panic!("a lock under a file: {other:?}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn the_lines_a_daemon_prints() {
|
|
let path = Path::new("/home/bx/run/loopd.lock");
|
|
assert_eq!(
|
|
LockError::Held.line("loopd", path),
|
|
"loopd: another loopd is running (it holds /home/bx/run/loopd.lock); \
|
|
see docs/runbook.md#already-running"
|
|
);
|
|
let io = LockError::Io(std::io::Error::other("the disk is on fire"));
|
|
assert_eq!(
|
|
io.line("inferproxy", Path::new("/run/bx/infer.sock.lock")),
|
|
"inferproxy: cannot take the lock /run/bx/infer.sock.lock: the disk is on fire; \
|
|
see docs/runbook.md#already-running"
|
|
);
|
|
assert_eq!(RUNBOOK, "see docs/runbook.md#already-running");
|
|
}
|
|
|
|
#[test]
|
|
fn the_error_displays_and_has_a_source() {
|
|
use std::error::Error;
|
|
assert_eq!(
|
|
LockError::Held.to_string(),
|
|
"another instance holds the lock"
|
|
);
|
|
assert!(LockError::Held.source().is_none());
|
|
let io = LockError::Io(std::io::Error::other("no room"));
|
|
assert_eq!(io.to_string(), "no room");
|
|
assert!(io.source().is_some());
|
|
}
|