use std::{
cell::RefCell,
iter,
os::fd::{AsFd, OwnedFd},
};
use rustix::{
io::{read, write},
process::{Resource, getrlimit, setrlimit},
};
use super::*;
use crate::{
test_utils::{in_own_process, pipe, read_byte},
testing::{self, Manager},
};
#[test]
fn round_trip() {
let mut manager = Manager::new().unwrap();
manager.add_socket("test.socket", pipe().1);
let (read_a, write_a) = pipe();
let (read_b, write_b) = pipe();
let many: Vec<_> = iter::repeat_with(|| pipe().1).take(MAX_FDS + 10).collect();
let bytes = b"bytes only".to_vec();
let many = Item::new(b"many", many);
let twice = vec![write_a.try_clone().unwrap(), write_a.try_clone().unwrap()];
let twice = Item::new(b"", twice);
let items: [(u64, &dyn Save); 4] = [(1, &bytes), (2, &write_a), (3, &many), (u64::MAX, &twice)];
let state = Item::new(b"state", vec![write_b]);
let stored = store(&manager).hand_over(state, items).unwrap();
assert_eq!(stored.items(), 4);
assert_eq!(stored.fds(), 1 + 1 + MAX_FDS + 10 + 2);
assert_eq!(manager.stored_names(), ["test/state", "test/fds"]);
let mut passed = manager.passed().unwrap();
let mut second = store(&manager);
let mut restored = second.take_over(&mut passed).unwrap().unwrap();
manager.barrier(WAIT).unwrap();
assert_eq!(manager.take_removed(), ["test/fds", "test/state"]);
let names: Vec<_> = passed.iter().map(|(name, _)| name).collect();
assert_eq!(names, ["test.socket"]);
assert_eq!(restored.state(), b"state");
let [fd] = <[OwnedFd; 1]>::try_from(restored.take_state_fds()).unwrap();
write(&fd, b"b").unwrap();
assert_eq!(read_byte(&read_b), b'b');
assert!(restored.take_state_fds().is_empty());
let mut items = restored.take_items();
let item = items.next().unwrap();
assert_eq!(item.id, 1);
assert_eq!(item.restore::<Vec<u8>>().unwrap(), b"bytes only");
let item = items.next().unwrap();
assert_eq!(item.id, 2);
let fd = item.restore::<OwnedFd>().unwrap();
write(&fd, b"a").unwrap();
assert_eq!(read_byte(&read_a), b'a');
let item = items.next().unwrap();
assert_eq!(
(item.id, item.record, item.fds.len()),
(3, &b"many"[..], MAX_FDS + 10)
);
let item = items.next().unwrap();
assert_eq!(item.id, u64::MAX);
assert_eq!(item.fds.len(), 2);
for fd in &item.fds {
write(fd, b"t").unwrap();
assert_eq!(read_byte(&read_a), b't');
}
assert!(items.next().is_none());
drop(items);
assert_eq!(restored.take_items().count(), 0);
}
#[test]
fn nothing_to_take_over() {
let mut manager = Manager::new().unwrap();
manager.add_socket("test.socket", pipe().1);
let mut passed = manager.passed().unwrap();
assert!(store(&manager).take_over(&mut passed).unwrap().is_none());
assert_eq!(passed.len(), 1);
let queue = Queue::new().unwrap().into_socket();
manager.replace_store(vec![("test/fds".to_owned(), queue)]);
let mut passed = manager.passed().unwrap();
let mut store = store(&manager);
assert!(store.take_over(&mut passed).unwrap().is_none());
manager.barrier(WAIT).unwrap();
assert_eq!(manager.take_removed(), ["test/fds"]);
assert_eq!(passed.len(), 1);
}
#[test]
fn no_take_over_of_garbage() {
let manager = Manager::new().unwrap();
let garbage = memfd::sealed("test", b"not a hand-over").unwrap();
manager.replace_store(vec![
("test/state".to_owned(), garbage),
("test/other".to_owned(), pipe().1),
("other/state".to_owned(), pipe().1),
]);
let mut passed = manager.passed().unwrap();
let mut store = store(&manager);
let error = store.take_over(&mut passed).unwrap_err();
assert!(matches!(error, Error::InvalidHandover(_)), "{error:?}");
manager.barrier(WAIT).unwrap();
assert_eq!(manager.take_removed(), ["test/other", "test/state"]);
let names: Vec<_> = passed.iter().map(|(name, _)| name).collect();
assert_eq!(names, ["other/state"]);
}
#[test]
fn taking_over_tells_that_the_service_started() {
let manager = Manager::new().unwrap();
let mut passed = manager.passed().unwrap();
let mut first = store(&manager);
assert!(first.take_over(&mut passed).unwrap().is_none());
manager.barrier(WAIT).unwrap();
assert_eq!(manager.take_notifications(), ["READY=1", "BARRIER=1"]);
first.hand_over(b"state".to_vec(), NO_ITEMS).unwrap();
manager.take_notifications();
let garbage = memfd::sealed("test", b"not a hand-over").unwrap();
for taken_over in [true, false] {
if !taken_over {
manager.replace_store(vec![(
"test/state".to_owned(),
garbage.try_clone().unwrap(),
)]);
}
let mut passed = manager.passed().unwrap();
let mut next = store(&manager);
assert_eq!(next.take_over(&mut passed).is_ok(), taken_over);
manager.barrier(WAIT).unwrap();
assert_eq!(
manager.take_notifications(),
["FDSTOREREMOVE=1\nFDNAME=test/state", "READY=1", "BARRIER=1"],
"taken over: {taken_over}"
);
}
}
#[test]
fn unsaved_items_fail_the_hand_over() {
for (unsaved, failed) in [
(Box::new(Unsaved) as Box<dyn Save>, false),
(Box::new(Failing(pipe().1)), true),
] {
let manager = Manager::new().unwrap();
let items: [(u64, Box<dyn Save>); 3] = [
(1, Box::new(Item::new(b"one", vec![pipe().1]))),
(2, unsaved),
(3, Box::new(Item::new(b"three", vec![pipe().1]))),
];
let error = store(&manager).hand_over(&[][..], items).unwrap_err();
let Error::Unsaved {
item: Some(2),
source,
} = &error
else {
panic!("{error:?}");
};
assert_eq!(source.is_some(), failed, "{error:?}");
assert!(error.to_string().contains("item 2 "), "{error}");
let mut passed = manager.passed().unwrap();
assert!(store(&manager).take_over(&mut passed).unwrap().is_none());
}
}
#[test]
fn missing_fds_fail_the_take_over() {
let manager = Manager::new().unwrap();
let items = [
(1, Item::new(b"one", vec![pipe().1])),
(2, Item::new(b"two", vec![pipe().1, pipe().1])),
(3, Item::new(b"three", vec![pipe().1])),
];
store(&manager).hand_over(&[][..], items).unwrap();
let mut stored = manager.stored().unwrap();
let queue = Queue::new().unwrap();
queue::take(stored[1].1.as_fd(), |index, fds, _| {
for (index, fd) in (index..).zip(fds) {
if index != 1 {
assert!(queue.push(index, &[fd.as_fd()]).unwrap());
}
}
})
.unwrap();
stored[1].1 = queue.into_socket();
manager.replace_store(stored);
let mut passed = manager.passed().unwrap();
let mut store = store(&manager);
let error = store.take_over(&mut passed).unwrap_err();
assert!(matches!(error, Error::InvalidHandover(_)), "{error:?}");
assert!(error.to_string().contains("item 2 "), "{error}");
manager.barrier(WAIT).unwrap();
assert_eq!(manager.take_removed(), ["test/fds", "test/state"]);
}
#[test]
fn take_over_over_the_fd_limit() {
let test = "store::tests::take_over_over_the_fd_limit";
if !in_own_process(test, "ZOTER_TEST_LOW_NOFILE=1") {
return;
}
let manager = Manager::new().unwrap();
let (_read, write) = pipe();
let fds = iter::repeat_with(|| write.try_clone().unwrap())
.take(32)
.collect();
let items = [(1, Item::new(b"many", fds))];
store(&manager).hand_over(&[][..], items).unwrap();
let mut passed = manager.passed().unwrap();
let mut store = store(&manager);
let open = std::fs::read_dir("/proc/self/fd").unwrap().count() as u64;
let mut limit = getrlimit(Resource::Nofile);
limit.current = Some(open + 2);
setrlimit(Resource::Nofile, limit).unwrap();
let error = store.take_over(&mut passed).unwrap_err();
assert!(
matches!(&error, Error::Io(e) if e.raw_os_error() == Some(Errno::MFILE.raw_os_error())),
"{error:?}"
);
}
#[test]
fn unsaved_state() {
for (state, failed) in [
(Box::new(Unsaved) as Box<dyn Save>, false),
(Box::new(Failing(pipe().1)), true),
] {
let manager = Manager::new().unwrap();
let error = store(&manager).hand_over(state, NO_ITEMS).unwrap_err();
let Error::Unsaved { item: None, source } = &error else {
panic!("{error:?}");
};
assert_eq!(source.is_some(), failed, "{error:?}");
}
}
#[test]
fn no_store_without_room() {
let manager = Manager::new().unwrap();
for max in [0, 1] {
let error = testing::store(manager.notify_socket(), KEY, max).unwrap_err();
assert!(
matches!(error, Error::StoreTooSmall { max: too_few } if too_few == max),
"{max}: {error:?}"
);
assert!(
error.to_string().contains("`FileDescriptorStoreMax=`"),
"{error}"
);
}
testing::store(manager.notify_socket(), KEY, MIN_STORE).unwrap();
}
#[test]
fn borrowed_state_and_items() {
let manager = Manager::new().unwrap();
let store = store(&manager);
let clients = [(4, pipe().1), (2, pipe().1)];
let state = b"state".to_vec();
let items = clients.iter().map(|(id, client)| (*id, client));
let stored = store.hand_over(&state, items).unwrap();
assert_eq!((stored.items(), stored.fds()), (2, 2));
assert_eq!(ids(take_over(&manager)), [4, 2]);
}
#[test]
fn store_is_send() {
fn send<T: Send>() {}
send::<Store>();
}
#[test]
fn keys() {
let manager = Manager::new().unwrap();
let longest = "a".repeat(MAX_KEY_LEN);
for key in ["busd", "with spaces", "a.b-c_d", &longest] {
testing::store(manager.notify_socket(), key, 2).unwrap();
}
let too_long = "a".repeat(MAX_KEY_LEN + 1);
for key in ["", "a/b", "a:b", "a\nb", "é", &too_long] {
let error = testing::store(manager.notify_socket(), key, 2).unwrap_err();
assert!(matches!(error, Error::InvalidName(_)), "{key:?}: {error:?}");
}
}
#[test]
fn queued_fds_come_back_by_their_index() {
let pipes: Vec<_> = (0..3).map(|_| pipe()).collect();
let mut fds: Vec<_> = pipes.iter().map(|(_, write)| write.as_fd()).collect();
fds.push(fds[0]);
let stored = RefCell::new(Vec::new());
let (first, last) = fds.split_at(2);
let (mut first, mut last) = (Some(first), Some(last));
let chunks = iter::from_fn(|| match stored.borrow().is_empty() {
true => Some(first.take().unwrap_or_default()),
false => last.take(),
});
queue_fds(chunks, 3, |socket| {
stored.borrow_mut().push(socket);
Ok(())
})
.unwrap();
let mut stored = stored.into_inner();
assert_eq!(
stored.len(),
2,
"the file descriptors went in other than two sockets"
);
stored.reverse();
let mut taken = take_queued(stored).unwrap();
for (index, pipe) in [(0, 0), (1, 1), (2, 2), (3, 0)] {
let fd = taken.remove(&index).unwrap();
let byte = [index as u8];
assert_eq!(write(&fd, &byte).unwrap(), 1);
let mut read_byte = [0];
assert_eq!(read(&pipes[pipe].0, &mut read_byte).unwrap(), 1);
assert_eq!(read_byte, byte);
}
assert!(taken.is_empty(), "{taken:?}");
}
#[test]
fn queued_fds_that_overflow_the_store() {
let fd = pipe().1;
let fds = [fd.as_fd()];
let mut stored = Vec::new();
let chunks = iter::once(&fds[..]).chain(iter::repeat(&fds[..0]));
let error = queue_fds(chunks, 1, |socket| {
stored.push(socket);
Ok(())
})
.unwrap_err();
assert!(matches!(error, Error::StoreFull), "{error:?}");
assert!(
error.to_string().contains("`FileDescriptorStoreMax=`"),
"{error}"
);
assert_eq!(stored.len(), 1);
let taken = take_queued(stored).unwrap();
assert_eq!(taken.into_keys().collect::<Vec<_>>(), [0]);
let error = queue_fds([&fds[..]], 0, |_| unreachable!()).unwrap_err();
assert!(matches!(error, Error::StoreFull), "{error:?}");
queue_fds([], 0, |_| unreachable!()).unwrap();
}
#[test]
fn items_take_their_fds() {
let mut fds: HashMap<u64, OwnedFd> = [0, 1, 2, 4].map(|index| (index, pipe().1)).into();
assert_eq!(take_fds(&mut fds, 0..2).unwrap().len(), 2);
assert!(take_fds(&mut fds, 2..4).is_none(), "{fds:?}");
assert!(!fds.contains_key(&2), "{fds:?}");
assert!(take_fds(&mut fds, 4..u64::MAX).is_none());
assert!(fds.is_empty(), "{fds:?}");
assert_eq!(take_fds(&mut fds, 5..5).unwrap().len(), 0);
}
#[test]
fn from_the_environment() {
let exports = "NOTIFY_SOCKET=/run/systemd/notify FDSTORE=16";
if !in_own_process("store::tests::from_the_environment", exports) {
return;
}
let passed = passed(&["web"]);
let store = Store::from_env(KEY, &passed).unwrap();
assert_eq!(store.max, 16);
for max in [0, 1] {
unsafe { env::set_var("FDSTORE", max.to_string()) };
let error = Store::from_env(KEY, &passed).unwrap_err();
assert!(
matches!(error, Error::StoreTooSmall { max: too_few } if too_few == max),
"{max}: {error:?}"
);
}
for value in ["", "-1", "x", "1.5", " 1", "99999999999999999999"] {
unsafe { env::set_var("FDSTORE", value) };
let error = Store::from_env(KEY, &passed).unwrap_err();
assert!(
matches!(error, Error::NoStore),
"$FDSTORE={value:?}: {error:?}"
);
}
unsafe { env::remove_var("FDSTORE") };
let error = Store::from_env(KEY, &passed).unwrap_err();
assert!(matches!(error, Error::NoStore), "{error:?}");
assert!(
error.to_string().contains("`FileDescriptorStoreMax=`"),
"{error}"
);
for fd_store in [None, Some("16")] {
for socket in [Some(""), None] {
unsafe {
match fd_store {
Some(fd_store) => env::set_var("FDSTORE", fd_store),
None => env::remove_var("FDSTORE"),
}
match socket {
Some(socket) => env::set_var("NOTIFY_SOCKET", socket),
None => env::remove_var("NOTIFY_SOCKET"),
}
}
let error = Store::from_env(KEY, &passed).unwrap_err();
assert!(
matches!(error, Error::NoManager),
"$NOTIFY_SOCKET={socket:?} $FDSTORE={fd_store:?}: {error:?}"
);
}
}
}
#[test]
fn no_store_without_a_socket() {
let exports = "NOTIFY_SOCKET=/run/systemd/notify FDSTORE=16";
if !in_own_process("store::tests::no_store_without_a_socket", exports) {
return;
}
let state = format!("{KEY}/state");
let fds = format!("{KEY}/fds");
let no_socket = |names: &[&str]| {
let error = Store::from_env(KEY, &passed(names)).unwrap_err();
assert!(matches!(error, Error::NoSocket), "{names:?}: {error:?}");
assert!(error.to_string().contains("`Requires=`"), "{error}");
assert_eq!(io::Error::from(error).kind(), io::ErrorKind::Unsupported);
};
no_socket(&[]);
no_socket(&[&state, &fds]);
no_socket(&[&fds, &fds, &state]);
assert_eq!(Store::from_env(KEY, &passed(&["web"])).unwrap().max, 16);
assert!(Store::from_env(KEY, &passed(&["web", &state, &fds])).is_ok());
assert!(Store::from_env(KEY, &passed(&[&state, "web"])).is_ok());
assert!(Store::from_env(KEY, &passed(&["test"])).is_ok());
assert!(Store::from_env(KEY, &passed(&[&format!("{KEY}x/state")])).is_ok());
}
#[test]
fn store_with_the_socket_taken_before() {
let exports = "NOTIFY_SOCKET=/run/systemd/notify FDSTORE=16";
if !in_own_process("store::tests::store_with_the_socket_taken_before", exports) {
return;
}
let mut passed = passed(&["web", &format!("{KEY}/state")]);
assert!(passed.take("web").is_some());
assert!(passed.take_prefixed(&format!("{KEY}/")).len() == 1);
assert!(passed.is_empty());
assert!(Store::from_env(KEY, &passed).is_ok());
}
#[test]
fn store_with_a_name_under_another_key() {
let exports = "NOTIFY_SOCKET=/run/systemd/notify FDSTORE=16";
if !in_own_process("store::tests::store_with_a_name_under_another_key", exports) {
return;
}
let passed = passed(&["other/state", "other/fds"]);
assert!(Store::from_env(KEY, &passed).is_ok());
}
#[test]
fn the_checks_of_from_env_come_in_order() {
let exports = "NOTIFY_SOCKET=/run/systemd/notify";
if !in_own_process(
"store::tests::the_checks_of_from_env_come_in_order",
exports,
) {
return;
}
let nothing = passed(&[]);
let error = Store::from_env(KEY, ¬hing).unwrap_err();
assert!(matches!(error, Error::NoStore), "{error:?}");
unsafe { env::set_var("FDSTORE", "1") };
let error = Store::from_env(KEY, ¬hing).unwrap_err();
assert!(
matches!(error, Error::StoreTooSmall { max: 1 }),
"{error:?}"
);
unsafe { env::set_var("FDSTORE", "16") };
let error = Store::from_env("bad/key", ¬hing).unwrap_err();
assert!(matches!(error, Error::InvalidName(_)), "{error:?}");
unsafe { env::remove_var("NOTIFY_SOCKET") };
let error = Store::from_env(KEY, ¬hing).unwrap_err();
assert!(matches!(error, Error::NoManager), "{error:?}");
}
fn passed(names: &[&str]) -> Passed {
Passed::new(
names
.iter()
.map(|name| (name.to_string(), pipe().1))
.collect(),
)
}
fn store(manager: &Manager) -> Store {
testing::store(manager.notify_socket(), KEY, manager.store_max()).unwrap()
}
fn take_over(manager: &Manager) -> Restored {
let mut passed = manager.passed().unwrap();
store(manager).take_over(&mut passed).unwrap().unwrap()
}
fn ids(mut restored: Restored) -> Vec<u64> {
restored.take_items().map(|item| item.id).collect()
}
struct Item {
bytes: Vec<u8>,
fds: Vec<OwnedFd>,
}
impl Item {
fn new(bytes: &[u8], fds: Vec<OwnedFd>) -> Self {
Self {
bytes: bytes.to_vec(),
fds,
}
}
}
impl Save for Item {
fn saved_len(&self) -> Option<usize> {
Some(self.bytes.len())
}
fn save(&self, dest: &mut [u8]) -> Result<()> {
dest.copy_from_slice(&self.bytes);
Ok(())
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
self.fds.iter().map(AsFd::as_fd).collect()
}
}
struct Unsaved;
impl Save for Unsaved {
fn saved_len(&self) -> Option<usize> {
None
}
fn save(&self, _dest: &mut [u8]) -> Result<()> {
unreachable!("an item that can't be saved was saved")
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
Vec::new()
}
}
struct Failing(OwnedFd);
impl Save for Failing {
fn saved_len(&self) -> Option<usize> {
Some(8)
}
fn save(&self, dest: &mut [u8]) -> Result<()> {
dest[0] = 1;
Err(io::Error::other("the record failed").into())
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
vec![self.0.as_fd()]
}
}
const KEY: &str = "test";
const NO_ITEMS: [(u64, &[u8]); 0] = [];
const WAIT: Duration = Duration::from_secs(10);