#![allow(non_upper_case_globals, dead_code)]
use crate::paths::{absolute_path, reported_path};
use crate::{
Config, Error, ErrorKind, EventHandler, EventKindMask, RecursiveMode, Result, Sender,
WatchedPath, Watcher, unbounded,
};
use crate::{PathOp, event::*};
use objc2_core_foundation as cf;
use objc2_core_services as fs;
use std::collections::{BTreeSet, HashMap};
use std::ffi::{CStr, OsStr};
use std::fmt;
use std::ops::Bound;
use std::os::unix::ffi::OsStrExt;
use std::os::unix::fs::MetadataExt;
use std::path::{Path, PathBuf};
use std::ptr::{self, NonNull};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::thread;
bitflags::bitflags! {
#[repr(C)]
#[derive(Debug)]
struct StreamFlags: u32 {
const NONE = fs::kFSEventStreamEventFlagNone;
const MUST_SCAN_SUBDIRS = fs::kFSEventStreamEventFlagMustScanSubDirs;
const USER_DROPPED = fs::kFSEventStreamEventFlagUserDropped;
const KERNEL_DROPPED = fs::kFSEventStreamEventFlagKernelDropped;
const IDS_WRAPPED = fs::kFSEventStreamEventFlagEventIdsWrapped;
const HISTORY_DONE = fs::kFSEventStreamEventFlagHistoryDone;
const ROOT_CHANGED = fs::kFSEventStreamEventFlagRootChanged;
const MOUNT = fs::kFSEventStreamEventFlagMount;
const UNMOUNT = fs::kFSEventStreamEventFlagUnmount;
const ITEM_CREATED = fs::kFSEventStreamEventFlagItemCreated;
const ITEM_REMOVED = fs::kFSEventStreamEventFlagItemRemoved;
const INODE_META_MOD = fs::kFSEventStreamEventFlagItemInodeMetaMod;
const ITEM_RENAMED = fs::kFSEventStreamEventFlagItemRenamed;
const ITEM_MODIFIED = fs::kFSEventStreamEventFlagItemModified;
const FINDER_INFO_MOD = fs::kFSEventStreamEventFlagItemFinderInfoMod;
const ITEM_CHANGE_OWNER = fs::kFSEventStreamEventFlagItemChangeOwner;
const ITEM_XATTR_MOD = fs::kFSEventStreamEventFlagItemXattrMod;
const IS_FILE = fs::kFSEventStreamEventFlagItemIsFile;
const IS_DIR = fs::kFSEventStreamEventFlagItemIsDir;
const IS_SYMLINK = fs::kFSEventStreamEventFlagItemIsSymlink;
const OWN_EVENT = fs::kFSEventStreamEventFlagOwnEvent;
const IS_HARDLINK = fs::kFSEventStreamEventFlagItemIsHardlink;
const IS_LAST_HARDLINK = fs::kFSEventStreamEventFlagItemIsLastHardlink;
const ITEM_CLONED = fs::kFSEventStreamEventFlagItemCloned;
}
}
const RUNLOOP_STOP_RECHECK_SECONDS: cf::CFTimeInterval = 0.5;
pub struct FsEventWatcher {
since_when: Option<fs::FSEventStreamEventId>,
latency: cf::CFTimeInterval,
flags: fs::FSEventStreamCreateFlags,
event_handler: Arc<Mutex<dyn EventHandler>>,
runloop: Option<RunLoopHandle>,
watches: HashMap<PathBuf, WatchEntry>,
watch_paths: BTreeSet<PathBuf>,
event_kinds: EventKindMask,
path_reservation: FseventsPathReservation,
}
#[derive(Debug)]
struct WatchEntry {
info: WatchInfo,
cf_path: cf::CFRetained<cf::CFString>,
device: u64,
inode: u64,
}
#[derive(Clone, Debug)]
struct WatchInfo {
is_recursive: bool,
reported_path: PathBuf,
user_data: Option<u64>,
since: fs::FSEventStreamEventId,
deep_since: fs::FSEventStreamEventId,
}
static ACTIVE_FSEVENTS_PATHS: AtomicUsize = AtomicUsize::new(0);
#[derive(Debug)]
struct FseventsPathReservation {
active_paths: &'static AtomicUsize,
path_count: usize,
}
impl FseventsPathReservation {
fn new(active_paths: &'static AtomicUsize) -> Self {
Self {
active_paths,
path_count: 0,
}
}
fn reserve(&mut self, path_count: usize, budget: usize) -> std::result::Result<(), usize> {
let held = self.path_count;
#[allow(deprecated, reason = "try_update requires Rust 1.95; our MSRV is 1.91")]
self.active_paths.fetch_update(
Ordering::Relaxed,
Ordering::Relaxed,
|active_path_count| {
let combined_path_count = (active_path_count - held).checked_add(path_count)?;
(combined_path_count <= budget)
.then_some(active_path_count.max(combined_path_count))
},
)?;
self.path_count = held.max(path_count);
Ok(())
}
fn shrink_to(&mut self, path_count: usize) {
let surplus = self.path_count.saturating_sub(path_count);
let previous = self.active_paths.fetch_sub(surplus, Ordering::Relaxed);
debug_assert!(previous >= surplus);
self.path_count -= surplus;
}
}
impl Drop for FseventsPathReservation {
fn drop(&mut self) {
self.shrink_to(0);
}
}
#[derive(Debug)]
struct RunLoopHandle {
runloop: cf::CFRetained<cf::CFRunLoop>,
stop_flag: Arc<AtomicBool>,
thread_handle: thread::JoinHandle<fs::FSEventStreamEventId>,
recursive_info: Arc<Mutex<HashMap<PathBuf, WatchInfo>>>,
}
impl fmt::Debug for FsEventWatcher {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("FsEventWatcher")
.field("since_when", &self.since_when)
.field("latency", &self.latency)
.field("flags", &self.flags)
.field("event_handler", &Arc::as_ptr(&self.event_handler))
.field("runloop", &self.runloop)
.field("watches", &self.watches)
.finish()
}
}
unsafe impl Send for FsEventWatcher {}
unsafe impl Sync for FsEventWatcher {}
fn translate_flags(flags: StreamFlags, precise: bool) -> Vec<Event> {
let mut evs = Vec::new();
translate_flags_with(flags, precise, |ev| evs.push(ev));
evs
}
fn translated_event_count(flags: &StreamFlags, precise: bool) -> usize {
if flags.contains(StreamFlags::HISTORY_DONE) {
return 0;
}
let mut count = usize::from(flags.contains(StreamFlags::MUST_SCAN_SUBDIRS));
if !precise {
return count + 1;
}
let root_changed = flags.contains(StreamFlags::ROOT_CHANGED);
count += usize::from(root_changed);
count += usize::from(flags.contains(StreamFlags::MOUNT));
count += usize::from(flags.contains(StreamFlags::UNMOUNT));
count += usize::from(flags.contains(StreamFlags::ITEM_CREATED));
count += usize::from(flags.contains(StreamFlags::ITEM_RENAMED) && !root_changed);
count += usize::from(flags.contains(StreamFlags::INODE_META_MOD));
count += usize::from(flags.contains(StreamFlags::FINDER_INFO_MOD));
count += usize::from(flags.contains(StreamFlags::ITEM_CHANGE_OWNER));
count += usize::from(flags.contains(StreamFlags::ITEM_XATTR_MOD));
count += usize::from(flags.contains(StreamFlags::ITEM_MODIFIED));
count += usize::from(flags.contains(StreamFlags::ITEM_REMOVED) && !root_changed);
count
}
fn translate_flags_with(flags: StreamFlags, precise: bool, mut emit: impl FnMut(Event)) {
if flags.contains(StreamFlags::HISTORY_DONE) {
return;
}
let clone_related = precise && flags.contains(StreamFlags::ITEM_CLONED);
let own_process_id = if precise && flags.contains(StreamFlags::OWN_EVENT) {
Some(std::process::id())
} else {
None
};
let mut emit_event = |mut ev: Event| {
if clone_related && ev.info().is_none() {
ev.attrs.set_info("is: clone");
}
if let Some(process_id) = own_process_id {
ev.attrs.set_process_id(process_id);
}
emit(ev);
};
if flags.contains(StreamFlags::MUST_SCAN_SUBDIRS) {
let e = Event::new(EventKind::Other).set_flag(Flag::Rescan);
emit_event(if flags.contains(StreamFlags::USER_DROPPED) {
e.set_info("rescan: user dropped")
} else if flags.contains(StreamFlags::KERNEL_DROPPED) {
e.set_info("rescan: kernel dropped")
} else {
e
});
}
if !precise {
emit(Event::new(EventKind::Any));
return;
}
let root_changed = flags.contains(StreamFlags::ROOT_CHANGED);
if root_changed {
let kind = if flags.contains(StreamFlags::ITEM_REMOVED) {
if flags.contains(StreamFlags::IS_DIR) {
EventKind::Remove(RemoveKind::Folder)
} else if flags.contains(StreamFlags::IS_FILE) {
EventKind::Remove(RemoveKind::File)
} else {
EventKind::Remove(RemoveKind::Any)
}
} else if flags.contains(StreamFlags::ITEM_RENAMED) {
EventKind::Modify(ModifyKind::Name(RenameMode::From))
} else {
EventKind::Remove(RemoveKind::Any)
};
emit_event(Event::new(kind).set_info("root changed"));
}
if flags.contains(StreamFlags::MOUNT) {
emit_event(Event::new(EventKind::Create(CreateKind::Other)).set_info("mount"));
}
if flags.contains(StreamFlags::UNMOUNT) {
emit_event(Event::new(EventKind::Remove(RemoveKind::Other)).set_info("mount"));
}
if flags.contains(StreamFlags::ITEM_CREATED) {
emit_event(if flags.contains(StreamFlags::IS_DIR) {
Event::new(EventKind::Create(CreateKind::Folder))
} else if flags.contains(StreamFlags::IS_FILE) {
Event::new(EventKind::Create(CreateKind::File))
} else {
let e = Event::new(EventKind::Create(CreateKind::Other));
if flags.contains(StreamFlags::IS_SYMLINK) {
e.set_info("is: symlink")
} else if flags.contains(StreamFlags::IS_HARDLINK) {
e.set_info("is: hardlink")
} else if flags.contains(StreamFlags::ITEM_CLONED) {
e.set_info("is: clone")
} else {
Event::new(EventKind::Create(CreateKind::Any))
}
});
}
if flags.contains(StreamFlags::ITEM_RENAMED) && !root_changed {
emit_event(Event::new(EventKind::Modify(ModifyKind::Name(
RenameMode::Any,
))));
}
if flags.contains(StreamFlags::INODE_META_MOD) {
emit_event(Event::new(EventKind::Modify(ModifyKind::Metadata(
MetadataKind::Any,
))));
}
if flags.contains(StreamFlags::FINDER_INFO_MOD) {
emit_event(
Event::new(EventKind::Modify(ModifyKind::Metadata(MetadataKind::Other)))
.set_info("meta: finder info"),
);
}
if flags.contains(StreamFlags::ITEM_CHANGE_OWNER) {
emit_event(Event::new(EventKind::Modify(ModifyKind::Metadata(
MetadataKind::Ownership,
))));
}
if flags.contains(StreamFlags::ITEM_XATTR_MOD) {
emit_event(Event::new(EventKind::Modify(ModifyKind::Metadata(
MetadataKind::Extended,
))));
}
if flags.contains(StreamFlags::ITEM_MODIFIED) {
emit_event(Event::new(EventKind::Modify(ModifyKind::Data(
DataChange::Content,
))));
}
if flags.contains(StreamFlags::ITEM_REMOVED) && !root_changed {
emit_event(if flags.contains(StreamFlags::IS_DIR) {
Event::new(EventKind::Remove(RemoveKind::Folder))
} else if flags.contains(StreamFlags::IS_FILE) {
Event::new(EventKind::Remove(RemoveKind::File))
} else {
let e = Event::new(EventKind::Remove(RemoveKind::Other));
if flags.contains(StreamFlags::IS_SYMLINK) {
e.set_info("is: symlink")
} else if flags.contains(StreamFlags::IS_HARDLINK) {
e.set_info("is: hardlink")
} else if flags.contains(StreamFlags::ITEM_CLONED) {
e.set_info("is: clone")
} else {
Event::new(EventKind::Remove(RemoveKind::Any))
}
});
}
}
struct StreamContextInfo {
event_handler: Arc<Mutex<dyn EventHandler>>,
recursive_info: Arc<Mutex<HashMap<PathBuf, WatchInfo>>>,
event_kinds: EventKindMask,
}
unsafe extern "C-unwind" fn release_context(info: *const libc::c_void) {
unsafe {
drop(Box::from_raw(
info as *const StreamContextInfo as *mut StreamContextInfo,
));
}
}
impl FsEventWatcher {
fn from_event_handler(
event_handler: Arc<Mutex<dyn EventHandler>>,
event_kinds: EventKindMask,
latency: cf::CFTimeInterval,
) -> Result<Self> {
Ok(FsEventWatcher {
since_when: None,
latency,
flags: fs::kFSEventStreamCreateFlagFileEvents
| fs::kFSEventStreamCreateFlagNoDefer
| fs::kFSEventStreamCreateFlagWatchRoot,
event_handler,
runloop: None,
watches: HashMap::new(),
watch_paths: BTreeSet::new(),
event_kinds,
path_reservation: FseventsPathReservation::new(&ACTIVE_FSEVENTS_PATHS),
})
}
fn watch_inner(&mut self, path: &Path, config: crate::WatchPathConfig) -> Result<()> {
let (canonical_path, previous) = self.append_path(path, config)?;
let entry = &self.watches[&canonical_path];
let unchanged = previous.as_ref().is_some_and(|previous| {
previous.device == entry.device
&& previous.inode == entry.inode
&& previous.info.is_recursive == entry.info.is_recursive
});
if (unchanged || self.is_covered(&canonical_path, entry.device))
&& let Some(runloop) = &self.runloop
{
runloop
.recursive_info
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.insert(canonical_path, entry.info.clone());
return Ok(());
}
if let Err(err) = self.reserve_roots(self.stream_roots().count()) {
self.set_watch(canonical_path, previous);
return Err(err.add_path(path.into()));
}
self.restart()
}
fn unwatch_inner(&mut self, path: &Path) -> Result<()> {
let (canonical_path, entry) = self.remove_path(path)?;
if self.is_covered(&canonical_path, entry.device)
&& let Some(runloop) = &self.runloop
{
runloop
.recursive_info
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.remove(&canonical_path);
return Ok(());
}
if let Err(err) = self.reserve_roots(self.stream_roots().count()) {
self.set_watch(canonical_path, Some(entry));
return Err(err.add_path(path.into()));
}
self.restart()
}
#[expect(
clippy::result_large_err,
reason = "Match Watcher::update_paths without boxing its public batch error"
)]
fn update_paths_inner(
&mut self,
ops: Vec<crate::PathOp>,
) -> crate::StdResult<(), crate::UpdatePathsError> {
if ops.is_empty() {
return Ok(());
}
let previous_roots: HashMap<_, _> = self
.stream_roots()
.map(|(path, entry)| (path.clone(), (entry.device, entry.inode)))
.collect();
let mut roots = previous_roots.len();
let result = crate::update_paths(ops, |op| {
let change = match &op {
PathOp::Watch(path, config) => self
.watch_entry(path, config.clone())
.map(|(canonical_path, entry)| (canonical_path, Some(entry))),
PathOp::Unwatch(path) => self
.watched_path(path)
.map(|canonical_path| (canonical_path, None)),
};
let (canonical_path, entry) = match change {
Ok(change) => change,
Err(err) => return Err((op, err)),
};
let covers = |entry: Option<&WatchEntry>| {
entry
.filter(|entry| {
entry.info.is_recursive && !self.is_covered(&canonical_path, entry.device)
})
.map(|entry| entry.device)
};
let nested = covers(self.watches.get(&canonical_path)) != covers(entry.as_ref());
let before = self.roots_at(&canonical_path, nested);
let previous = self.set_watch(canonical_path.clone(), entry);
let after = self.roots_at(&canonical_path, nested);
if let Err(err) = self.reserve_roots(roots + after - before) {
self.set_watch(canonical_path, previous);
let err = err.add_path(op.as_path().into());
return Err((op, err));
}
roots = roots + after - before;
Ok(())
});
let root_count = self.stream_roots().count();
debug_assert_eq!(roots, root_count);
let roots_unchanged = root_count == previous_roots.len()
&& self.stream_roots().all(|(path, entry)| {
previous_roots.get(path) == Some(&(entry.device, entry.inode))
});
if roots_unchanged && let Some(runloop) = &self.runloop {
*runloop
.recursive_info
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner()) = self
.watches
.iter()
.map(|(path, entry)| (path.clone(), entry.info.clone()))
.collect();
self.path_reservation.shrink_to(previous_roots.len());
return result;
}
match self.restart() {
Err(run_error) => match result {
Ok(()) => Err(crate::UpdatePathsError {
source: run_error,
origin: None,
remaining: Default::default(),
}),
Err(path_op_error) => {
log::error!(
"Unable to run fsevents watcher after updating paths error: {run_error:?}"
);
Err(path_op_error)
}
},
Ok(()) => result,
}
}
fn reserve_roots(&mut self, roots: usize) -> Result<()> {
let budget = fsevents_path_budget().unwrap_or(usize::MAX);
self.path_reservation
.reserve(roots, budget)
.map_err(|active_path_count| {
log::error!(
"refusing to watch {roots} FSEvents paths: {active_path_count} are active in \
this process and the safe limit is {budget}. Raise RLIMIT_NOFILE, watch \
fewer paths, or use macos_kqueue."
);
Error::new(ErrorKind::MaxFilesWatch)
})
}
fn restart(&mut self) -> Result<()> {
self.stop();
let result = self.run();
let roots = if self.is_running() {
self.stream_roots().count()
} else {
0
};
self.path_reservation.shrink_to(roots);
result
}
#[inline]
fn is_running(&self) -> bool {
self.runloop.is_some()
}
fn stop(&mut self) {
if !self.is_running() {
return;
}
if let Some(RunLoopHandle {
runloop,
stop_flag,
thread_handle,
..
}) = self.runloop.take()
{
stop_flag.store(true, Ordering::Release);
runloop.stop();
runloop.wake_up();
self.since_when = Some(thread_handle.join().expect("thread to shut down"));
}
}
fn remove_path(&mut self, path: &Path) -> Result<(PathBuf, WatchEntry)> {
let path = self.watched_path(path)?;
let entry = self.set_watch(path.clone(), None);
entry
.map(|entry| (path, entry))
.ok_or_else(Error::watch_not_found)
}
fn watched_path(&self, path: &Path) -> Result<PathBuf> {
let p = path
.canonicalize()
.ok()
.or_else(|| {
self.watches
.iter()
.find(|(_, entry)| entry.info.reported_path == path)
.map(|(path, _)| path.clone())
})
.or_else(|| absolute_path(path).ok())
.unwrap_or_else(|| path.to_owned());
if self.watches.contains_key(&p) {
Ok(p)
} else {
Err(Error::watch_not_found())
}
}
fn append_path(
&mut self,
path: &Path,
config: crate::WatchPathConfig,
) -> Result<(PathBuf, Option<WatchEntry>)> {
let (canonical_path, entry) = self.watch_entry(path, config)?;
let previous = self.set_watch(canonical_path.clone(), Some(entry));
Ok((canonical_path, previous))
}
fn watch_entry(
&self,
path: &Path,
config: crate::WatchPathConfig,
) -> Result<(PathBuf, WatchEntry)> {
if !path.exists() {
return Err(Error::path_not_found().add_path(path.into()));
}
let canonical_path = path.to_path_buf().canonicalize()?;
let Some(cf_path) = path_to_cfstring_ref(&canonical_path) else {
return Err(Error::path_not_found().add_path(path.into()));
};
let metadata = std::fs::metadata(&canonical_path)?;
let (device, inode) = (metadata.dev(), metadata.ino());
let is_recursive = config.recursive_mode().is_recursive();
let now = || unsafe { fs::FSEventsGetCurrentEventId() };
let previous = self
.watches
.get(&canonical_path)
.filter(|previous| previous.device == device && previous.inode == inode)
.map(|previous| &previous.info);
let (since, deep_since) = match previous {
Some(previous) if previous.is_recursive || !is_recursive => {
(previous.since, previous.deep_since)
}
Some(previous) => (previous.since, now()),
None => {
let now = now();
(now, now)
}
};
let entry = WatchEntry {
info: WatchInfo {
is_recursive,
reported_path: path.to_path_buf(),
user_data: config.user_data(),
since,
deep_since,
},
cf_path,
device,
inode,
};
Ok((canonical_path, entry))
}
fn set_watch(&mut self, path: PathBuf, entry: Option<WatchEntry>) -> Option<WatchEntry> {
match entry {
Some(entry) => {
self.watch_paths.insert(path.clone());
self.watches.insert(path, entry)
}
None => {
self.watch_paths.remove(&path);
self.watches.remove(&path)
}
}
}
fn roots_at(&self, path: &Path, nested: bool) -> usize {
self.watch_paths
.range::<Path, _>((Bound::Included(path), Bound::Unbounded))
.take_while(|watched| {
if nested {
watched.starts_with(path)
} else {
watched.as_path() == path
}
})
.filter(|watched| !self.is_covered(watched, self.watches[*watched].device))
.count()
}
fn is_covered(&self, path: &Path, device: u64) -> bool {
path.ancestors().skip(1).any(|ancestor| {
self.watches
.get(ancestor)
.is_some_and(|covering| covering.info.is_recursive && covering.device == device)
})
}
fn stream_roots(&self) -> impl Iterator<Item = (&PathBuf, &WatchEntry)> {
self.watches
.iter()
.filter(|(path, entry)| !self.is_covered(path, entry.device))
}
fn stream_paths(&self) -> cf::CFRetained<cf::CFMutableArray<cf::CFString>> {
let paths: cf::CFRetained<cf::CFMutableArray<cf::CFString>> = cf::CFMutableArray::empty();
for (_, entry) in self.stream_roots() {
paths.append(&entry.cf_path);
}
paths
}
fn run(&mut self) -> Result<()> {
let stream_paths = self.stream_paths();
if stream_paths.is_empty() {
self.since_when = None;
return Ok(());
}
self.reserve_roots(stream_paths.iter().count())?;
let recursive_info = Arc::new(Mutex::new(
self.watches
.iter()
.map(|(path, entry)| (path.clone(), entry.info.clone()))
.collect(),
));
let context = Box::into_raw(Box::new(StreamContextInfo {
event_handler: self.event_handler.clone(),
recursive_info: recursive_info.clone(),
event_kinds: self.event_kinds,
}));
let stream_context = fs::FSEventStreamContext {
version: 0,
info: context as *mut libc::c_void,
retain: None,
release: Some(release_context),
copyDescription: None,
};
let since_when = self
.since_when
.unwrap_or_else(|| unsafe { fs::FSEventsGetCurrentEventId() });
let stream = unsafe {
fs::FSEventStreamCreate(
cf::kCFAllocatorDefault,
Some(callback),
&stream_context as *const _ as *mut _,
stream_paths.as_opaque(),
since_when,
self.latency,
self.flags,
)
};
if stream.is_null() {
unsafe {
release_context(context.cast());
}
log::error!("FSEventStreamCreate returned NULL");
return Err(Error::new(ErrorKind::WatchStartFailed));
}
struct CFRunLoopSendWrapper(cf::CFRetained<cf::CFRunLoop>);
unsafe impl Send for CFRunLoopSendWrapper {}
struct FSEventStreamSendWrapper(fs::FSEventStreamRef);
unsafe impl Send for FSEventStreamSendWrapper {}
let stream_to_send = FSEventStreamSendWrapper(stream);
let (rl_tx, rl_rx) = unbounded();
let stop_flag = Arc::new(AtomicBool::new(false));
let stop_flag_thread = Arc::clone(&stop_flag);
let thread_handle = thread::Builder::new()
.name("notify-rs fsevents loop".to_string())
.spawn(move || {
let _ = &stream_to_send;
let stream = stream_to_send.0;
unsafe {
let cur_runloop =
cf::CFRunLoop::current().expect("Failed to get current runloop");
#[allow(deprecated)]
fs::FSEventStreamScheduleWithRunLoop(
stream,
&cur_runloop,
cf::kCFRunLoopDefaultMode.expect("Failed to get default runloop mode"),
);
if !fs::FSEventStreamStart(stream) {
fs::FSEventStreamInvalidate(stream);
fs::FSEventStreamRelease(stream);
log::error!("FSEventStreamStart returned false");
rl_tx
.send(Err(Error::new(ErrorKind::WatchStartFailed)))
.expect("Unable to send error for FSEventStreamStart");
return since_when;
}
rl_tx
.send(Ok(CFRunLoopSendWrapper(cur_runloop)))
.expect("Unable to send runloop to watcher");
while !stop_flag_thread.load(Ordering::Acquire) {
let result = cf::CFRunLoop::run_in_mode(
cf::kCFRunLoopDefaultMode,
RUNLOOP_STOP_RECHECK_SECONDS,
false,
);
if result == cf::CFRunLoopRunResult::Finished {
break;
}
}
fs::FSEventStreamStop(stream);
let since_when = fs::FSEventStreamGetLatestEventId(stream).max(since_when);
fs::FSEventStreamInvalidate(stream);
fs::FSEventStreamRelease(stream);
since_when
}
})
.inspect_err(|_| {
unsafe { fs::FSEventStreamRelease(stream) };
})?;
let runloop_wrapper = match rl_rx.recv() {
Ok(Ok(runloop_wrapper)) => runloop_wrapper,
Ok(Err(err)) => {
thread_handle
.join()
.expect("thread to shut down after FSEvent stream startup failure");
return Err(err);
}
Err(_) => {
thread_handle
.join()
.expect("thread to shut down after FSEvent stream startup channel close");
return Err(Error::generic(
"unable to receive FSEvent stream startup result",
));
}
};
self.runloop = Some(RunLoopHandle {
runloop: runloop_wrapper.0,
stop_flag,
thread_handle,
recursive_info,
});
Ok(())
}
fn configure_raw_mode(&mut self, _config: Config, tx: Sender<Result<bool>>) {
tx.send(Ok(false))
.expect("configuration channel disconnect");
}
}
fn fsevents_path_budget() -> Option<usize> {
let mut limit = unsafe { std::mem::zeroed::<libc::rlimit>() };
if unsafe { libc::getrlimit(libc::RLIMIT_NOFILE, &mut limit) } != 0 {
return None;
}
let soft = usize::try_from(limit.rlim_cur).ok()?;
Some(soft / 12)
}
unsafe extern "C-unwind" fn callback(
stream_ref: fs::ConstFSEventStreamRef,
info: *mut libc::c_void,
num_events: libc::size_t, event_paths: NonNull<libc::c_void>, event_flags: NonNull<fs::FSEventStreamEventFlags>, event_ids: NonNull<fs::FSEventStreamEventId>, ) {
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| unsafe {
callback_impl(
stream_ref,
info,
num_events,
event_paths,
event_flags,
event_ids,
)
}))
.map_err(|_| {
log::error!("panic in FSEvents callback; dropping pending events");
});
}
fn watch_for<'a>(
recursive_info: &'a HashMap<PathBuf, WatchInfo>,
path: &Path,
event_id: Option<fs::FSEventStreamEventId>,
) -> Option<(&'a PathBuf, &'a WatchInfo)> {
let is_after = |since| event_id.is_none_or(|event_id| event_id > since);
if let Some(watch) = recursive_info
.get_key_value(path)
.filter(|(_, watch_info)| is_after(watch_info.since))
{
return Some(watch);
}
path.ancestors()
.skip(1)
.enumerate()
.find_map(|(depth, ancestor)| {
let (watch_path, watch_info) = recursive_info.get_key_value(ancestor)?;
let since = if depth == 0 {
watch_info.since
} else if watch_info.is_recursive {
watch_info.deep_since
} else {
return None;
};
is_after(since).then_some((watch_path, watch_info))
})
}
unsafe fn callback_impl(
_stream_ref: fs::ConstFSEventStreamRef,
info: *mut libc::c_void,
num_events: libc::size_t, event_paths: NonNull<libc::c_void>, event_flags: NonNull<fs::FSEventStreamEventFlags>, event_ids: NonNull<fs::FSEventStreamEventId>, ) {
let event_paths = event_paths.as_ptr() as *const *const libc::c_char;
let info = unsafe { &*(info as *const StreamContextInfo) };
let event_handler_mutex = &info.event_handler;
let event_kinds = info.event_kinds;
let mut event_handler_guard = None;
for p in 0..num_events {
let path = unsafe { CStr::from_ptr(*event_paths.add(p)) };
let path = Path::new(OsStr::from_bytes(path.to_bytes()));
let raw_flag = unsafe { *event_flags.as_ptr().add(p) };
let flag = StreamFlags::from_bits_truncate(raw_flag);
let unknown_bits = raw_flag & !StreamFlags::all().bits();
if unknown_bits != 0 {
log::trace!("unknown FSEventStreamEventFlags bits: 0x{unknown_bits:08x}");
}
let event_id = unsafe { *event_ids.as_ptr().add(p) };
let event_id =
Some(event_id).filter(|&id| id != 0 && !flag.contains(StreamFlags::MUST_SCAN_SUBDIRS));
let recursive_info = info
.recursive_info
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
let Some((watch_path, watch_info)) = watch_for(&recursive_info, path, event_id) else {
if flag.contains(StreamFlags::MUST_SCAN_SUBDIRS) {
drop(recursive_info);
let mut ev = Event::new(EventKind::Other).set_flag(Flag::Rescan);
ev = if flag.contains(StreamFlags::USER_DROPPED) {
ev.set_info("rescan: user dropped")
} else if flag.contains(StreamFlags::KERNEL_DROPPED) {
ev.set_info("rescan: kernel dropped")
} else {
ev
};
ev.paths.push(path.to_path_buf());
if event_kinds.matches(&ev.kind) {
let event_handler = event_handler_guard.get_or_insert_with(|| {
match event_handler_mutex.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
}
});
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
event_handler.handle_event(Ok(ev));
}))
.map_err(|_| {
log::error!("panic in FSEvents event handler; dropping event");
});
}
}
continue;
};
let translated_count = translated_event_count(&flag, true);
if translated_count == 0 {
continue;
}
let mut event_path = Some(reported_path(watch_path, &watch_info.reported_path, path));
let user_data = watch_info.user_data;
drop(recursive_info);
let single_translated_event = translated_count == 1;
log::trace!("FSEvent: path = `{}`, flag = {:?}", path.display(), flag);
translate_flags_with(flag, true, |mut ev| {
if !event_kinds.matches(&ev.kind) {
return;
}
if let Some(user_data) = user_data {
ev = ev.set_user_data(user_data);
}
if single_translated_event {
ev.paths
.push(event_path.take().expect("single translated event path"));
} else {
ev.paths
.push(event_path.as_ref().expect("translated event path").clone());
}
let event_handler =
event_handler_guard.get_or_insert_with(|| match event_handler_mutex.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
});
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
event_handler.handle_event(Ok(ev));
}))
.map_err(|_| {
log::error!("panic in FSEvents event handler; dropping event");
});
});
}
}
impl Watcher for FsEventWatcher {
fn new<F: EventHandler>(event_handler: F, config: Config) -> Result<Self> {
Self::from_event_handler(
Arc::new(Mutex::new(event_handler)),
config.event_kinds(),
config.fsevent_latency().as_secs_f64(),
)
}
fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> {
self.watch_with(path, crate::WatchPathConfig::new(recursive_mode))
}
fn watch_with(&mut self, path: &Path, config: crate::WatchPathConfig) -> Result<()> {
let user_data = config.user_data();
self.watch_inner(path, config)
.map_err(|err| err.set_user_data_opt(user_data))
}
fn unwatch(&mut self, path: &Path) -> Result<()> {
self.unwatch_inner(path)
}
fn update_paths(&mut self, ops: Vec<PathOp>) -> crate::StdResult<(), crate::UpdatePathsError> {
self.update_paths_inner(ops)
}
fn configure(&mut self, config: Config) -> Result<bool> {
let (tx, rx) = unbounded();
self.configure_raw_mode(config, tx);
rx.recv()?
}
fn watched_paths(&self) -> Result<Vec<WatchedPath>> {
Ok(self
.watches
.iter()
.map(|(_path, WatchEntry { info, .. })| {
WatchedPath::new(
info.reported_path.clone(),
if info.is_recursive {
RecursiveMode::Recursive
} else {
RecursiveMode::NonRecursive
},
)
})
.collect())
}
fn kind() -> crate::WatcherKind {
crate::WatcherKind::Fsevent
}
}
impl Drop for FsEventWatcher {
fn drop(&mut self) {
self.stop();
}
}
fn path_to_cfstring_ref(source: &Path) -> Option<cf::CFRetained<cf::CFString>> {
let url = cf::CFURL::from_file_path(source)?;
let mut placeholder = url.absolute_url()?;
let imaginary = cf::CFMutableArray::empty();
while !unsafe { placeholder.resource_is_reachable(ptr::null_mut()) } {
if let Some(child) = placeholder.last_path_component() {
imaginary.insert(0, &*child);
}
placeholder = cf::CFURL::new_copy_deleting_last_path_component(None, Some(&placeholder))?;
}
let url =
unsafe { cf::CFURL::new_file_reference_url(None, Some(&placeholder), ptr::null_mut()) }?;
let mut placeholder =
unsafe { cf::CFURL::new_file_path_url(None, Some(&url), ptr::null_mut()) }?;
for component in imaginary {
placeholder = cf::CFURL::new_copy_appending_path_component(
None,
Some(&placeholder),
Some(&component),
false,
)?;
}
placeholder.file_system_path(cf::CFURLPathStyle::CFURLPOSIXPathStyle)
}
#[cfg(test)]
mod tests {
use std::sync::mpsc;
use std::time::{Duration, Instant};
use crate::{ErrorKind, WatchPathConfig};
use super::*;
use crate::test::*;
fn watcher() -> (TestWatcher<FsEventWatcher>, Receiver) {
channel()
}
fn watch_info(is_recursive: bool) -> WatchInfo {
WatchInfo {
is_recursive,
reported_path: PathBuf::from("/reported"),
user_data: None,
since: 0,
deep_since: 0,
}
}
#[test]
fn watch_for_matches_each_kind_of_watch() {
let mut recursive_info = HashMap::new();
recursive_info.insert(PathBuf::from("/repo"), watch_info(false));
recursive_info.insert(PathBuf::from("/repo/src"), watch_info(false));
recursive_info.insert(PathBuf::from("/deep"), watch_info(true));
recursive_info.insert(PathBuf::from("/deep/inner"), watch_info(false));
recursive_info.insert(PathBuf::from("/single/file.txt"), watch_info(false));
let cases = [
("/repo", Some("/repo")),
("/deep", Some("/deep")),
("/single/file.txt", Some("/single/file.txt")),
("/repo/readme.md", Some("/repo")),
("/repo/src/main.rs", Some("/repo/src")),
("/repo/target/debug", None),
("/deep/a", Some("/deep")),
("/deep/a/b/c", Some("/deep")),
("/deep/inner/x", Some("/deep/inner")),
("/deep/inner/x/y", Some("/deep")),
("/repository/readme.md", None),
("/deeper/a", None),
("/single", None),
("/single/other.txt", None),
("/elsewhere/x", None),
("/", None),
];
for (path, expected) in cases {
let matched = watch_for(&recursive_info, Path::new(path), None)
.map(|(watch_path, _)| watch_path.as_path());
assert_eq!(matched, expected.map(Path::new), "{path}");
}
}
#[test]
fn watch_for_agrees_with_a_scan_of_every_watch() {
fn scan<'a>(
recursive_info: &'a HashMap<PathBuf, WatchInfo>,
path: &Path,
) -> Option<&'a PathBuf> {
recursive_info
.iter()
.filter(|(watch_path, watch_info)| {
path.starts_with(watch_path)
&& (watch_info.is_recursive
|| path == watch_path.as_path()
|| path.parent() == Some(watch_path.as_path()))
})
.map(|(watch_path, _)| watch_path)
.max_by_key(|watch_path| watch_path.as_os_str().as_bytes().len())
}
let watches: [(&str, bool); 7] = [
("/a", false),
("/a/b", true),
("/a/b/c", false),
("/a/b/c/d", true),
("/x/y", false),
("/x/y/z.txt", false),
("/r", true),
];
let paths = [
"/",
"/a",
"/a/b",
"/a/b/c",
"/a/b/c/d",
"/a/b/c/d/e",
"/a/b/c/d/e/f",
"/a/b/q/r",
"/a/z",
"/a/z/q",
"/ab",
"/x",
"/x/y",
"/x/y/z.txt",
"/x/y/w",
"/x/y/w/v",
"/r",
"/r/s/t",
"/rs",
];
for mask in 0u32..(1 << watches.len()) {
let recursive_info: HashMap<PathBuf, WatchInfo> = watches
.iter()
.enumerate()
.filter(|(index, _)| mask & (1 << index) != 0)
.map(|(_, &(watch_path, is_recursive))| {
(PathBuf::from(watch_path), watch_info(is_recursive))
})
.collect();
for path in paths {
assert_eq!(
watch_for(&recursive_info, Path::new(path), None)
.map(|(watch_path, _)| watch_path),
scan(&recursive_info, Path::new(path)),
"{path} against {recursive_info:?}"
);
}
}
}
fn runloop_thread_id(watcher: &FsEventWatcher) -> thread::ThreadId {
watcher
.runloop
.as_ref()
.expect("watcher to be running")
.thread_handle
.thread()
.id()
}
fn wait_for_path(rx: &mpsc::Receiver<Result<Event>>, path: &Path) -> Event {
let deadline = Instant::now() + Duration::from_secs(10);
loop {
let event = rx
.recv_timeout(deadline.saturating_duration_since(Instant::now()))
.unwrap_or_else(|err| panic!("missing event for {}: {err}", path.display()))
.expect("watcher event");
if event.paths.iter().any(|event_path| event_path == path) {
return event;
}
}
}
fn pause_runloop(watcher: &FsEventWatcher) -> mpsc::Sender<()> {
type Pause = (mpsc::Sender<()>, mpsc::Receiver<()>);
unsafe extern "C-unwind" fn perform(info: *mut libc::c_void) {
let (entered, resume) = unsafe { &*info.cast::<Pause>() };
let _ = entered.send(());
let _ = resume.recv_timeout(Duration::from_secs(20));
}
unsafe extern "C-unwind" fn release(info: *const libc::c_void) {
drop(unsafe { Box::from_raw(info.cast_mut().cast::<Pause>()) });
}
let (entered_tx, entered_rx) = mpsc::channel::<()>();
let (resume_tx, resume_rx) = mpsc::channel();
let mut context = cf::CFRunLoopSourceContext {
version: 0,
info: Box::into_raw(Box::new((entered_tx, resume_rx))).cast(),
retain: None,
release: Some(release),
copyDescription: None,
equal: None,
hash: None,
schedule: None,
cancel: None,
perform: Some(perform),
};
let runloop = &watcher.runloop.as_ref().expect("running watcher").runloop;
let source = unsafe {
cf::CFRunLoopSource::new(cf::kCFAllocatorDefault, isize::MIN, &mut context)
.expect("pause source")
};
runloop.add_source(Some(&source), unsafe { cf::kCFRunLoopDefaultMode });
source.signal();
runloop.wake_up();
entered_rx
.recv_timeout(Duration::from_secs(10))
.expect("runloop paused");
resume_tx
}
fn restart_while_paused(
watcher: &mut FsEventWatcher,
resume: mpsc::Sender<()>,
change: &str,
apply: impl FnOnce(&mut FsEventWatcher),
) {
let stop_flag = watcher.runloop.as_ref().unwrap().stop_flag.clone();
thread::scope(|scope| {
scope.spawn(move || {
let deadline = Instant::now() + Duration::from_secs(10);
while !stop_flag.load(Ordering::Acquire) && Instant::now() < deadline {
thread::sleep(Duration::from_millis(1));
}
let stopped = stop_flag.load(Ordering::Acquire);
resume.send(()).expect("resume runloop");
assert!(stopped, "{change} did not stop the old stream");
});
apply(watcher);
});
}
#[test]
fn queued_events_survive_watch_changes() {
for change in [
"watch",
"rewatch",
"unwatch",
"update_paths",
"failed_update_paths",
] {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
let a = root.join("a");
let b = root.join("b");
let c = root.join("c");
for path in [&a, &b, &c] {
std::fs::create_dir(path).unwrap();
}
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
watcher
.update_paths(vec![
PathOp::watch_recursive(a.clone()),
PathOp::watch_recursive(b.clone()),
])
.unwrap();
let (observer_tx, observer_rx) = mpsc::channel();
let mut observer = FsEventWatcher::new(observer_tx, Config::default()).unwrap();
observer.watch(&a, RecursiveMode::Recursive).unwrap();
let resume = pause_runloop(&watcher);
let path = a.join("pending");
std::fs::write(&path, "pending event").unwrap();
wait_for_path(&observer_rx, &path);
assert!(
rx.try_iter()
.all(|event| !event.unwrap().paths.contains(&path))
);
restart_while_paused(&mut watcher, resume, change, |watcher| match change {
"watch" => watcher.watch(&c, RecursiveMode::Recursive).unwrap(),
"rewatch" => watcher.watch(&a, RecursiveMode::NonRecursive).unwrap(),
"unwatch" => watcher.unwatch(&b).unwrap(),
"update_paths" => watcher
.update_paths(vec![
PathOp::unwatch(b.clone()),
PathOp::watch_recursive(c.clone()),
])
.unwrap(),
"failed_update_paths" => {
let err = watcher
.update_paths(vec![
PathOp::unwatch(b.clone()),
PathOp::unwatch(root.join("missing")),
PathOp::watch_recursive(c.clone()),
])
.unwrap_err();
assert!(matches!(err.source.kind, ErrorKind::WatchNotFound));
assert_eq!(err.remaining.len(), 1);
}
_ => unreachable!(),
});
wait_for_path(&rx, &path);
}
}
#[test]
fn events_before_a_watch_are_not_delivered() {
for change in ["watch", "update_paths"] {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
let a = root.join("a");
let b = root.join("b");
for path in [&a, &b] {
std::fs::create_dir(path).unwrap();
}
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
watcher.watch(&a, RecursiveMode::Recursive).unwrap();
let first = a.join("first");
std::fs::create_dir(&first).unwrap();
wait_for_path(&rx, &first);
let (observer_tx, observer_rx) = mpsc::channel();
let mut observer = FsEventWatcher::new(observer_tx, Config::default()).unwrap();
observer.watch(&root, RecursiveMode::Recursive).unwrap();
let resume = pause_runloop(&watcher);
let before = b.join("before");
let pending = a.join("pending");
for path in [&before, &pending] {
std::fs::create_dir(path).unwrap();
wait_for_path(&observer_rx, path);
}
restart_while_paused(&mut watcher, resume, change, |watcher| match change {
"watch" => watcher.watch(&b, RecursiveMode::Recursive).unwrap(),
"update_paths" => watcher
.update_paths(vec![PathOp::watch_recursive(b.clone())])
.unwrap(),
_ => unreachable!(),
});
let after = b.join("after");
std::fs::create_dir(&after).unwrap();
let mut delivered = Vec::new();
while !delivered.contains(&after) {
let event = rx
.recv_timeout(Duration::from_secs(10))
.unwrap_or_else(|err| panic!("{change}: missing event after the watch: {err}"))
.expect("watcher event");
delivered.extend(event.paths);
}
assert!(delivered.contains(&pending), "{change}: {delivered:?}");
assert!(!delivered.contains(&before), "{change}: {delivered:?}");
}
}
#[test]
fn rewatching_keeps_the_starting_event_of_an_unchanged_target() {
fn advance_event_id(dir: &Path) {
let id = unsafe { fs::FSEventsGetCurrentEventId() };
std::fs::create_dir(dir.join(id.to_string())).unwrap();
let deadline = Instant::now() + Duration::from_secs(10);
while unsafe { fs::FSEventsGetCurrentEventId() } == id {
assert!(Instant::now() < deadline, "FSEvents recorded no change");
thread::sleep(Duration::from_millis(1));
}
}
let dir = tempfile::tempdir().unwrap();
let parent = dir.path().canonicalize().unwrap();
let root = parent.join("root");
std::fs::create_dir(&root).unwrap();
let mut watcher = FsEventWatcher::new(|_| {}, Config::default()).unwrap();
let watch = |watcher: &mut FsEventWatcher, mode| {
advance_event_id(&parent);
watcher
.append_path(&root, WatchPathConfig::new(mode))
.unwrap();
let info = &watcher.watches[&root].info;
(info.since, info.deep_since)
};
let (since, _) = watch(&mut watcher, RecursiveMode::NonRecursive);
let (widened_since, deep_since) = watch(&mut watcher, RecursiveMode::Recursive);
assert_eq!(widened_since, since);
assert!(deep_since > since);
assert_eq!(
watch(&mut watcher, RecursiveMode::Recursive),
(since, deep_since)
);
std::fs::rename(&root, parent.join("old")).unwrap();
std::fs::create_dir(&root).unwrap();
let (replaced_since, replaced_deep_since) = watch(&mut watcher, RecursiveMode::Recursive);
assert!(replaced_since > deep_since);
assert_eq!(replaced_deep_since, replaced_since);
watcher.remove_path(&root).unwrap();
let (rewatched_since, rewatched_deep_since) = watch(&mut watcher, RecursiveMode::Recursive);
assert!(rewatched_since > replaced_since);
assert_eq!(rewatched_deep_since, rewatched_since);
}
#[test]
fn events_during_stream_restart_are_replayed() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
watcher.watch(&root, RecursiveMode::Recursive).unwrap();
let before = root.join("before");
std::fs::write(&before, "before restart").unwrap();
wait_for_path(&rx, &before);
watcher.stop();
assert!(watcher.since_when.is_some());
let (observer_tx, observer_rx) = mpsc::channel();
let mut observer = FsEventWatcher::new(observer_tx, Config::default()).unwrap();
observer.watch(&root, RecursiveMode::Recursive).unwrap();
let during = root.join("during");
std::fs::write(&during, "during restart").unwrap();
wait_for_path(&observer_rx, &during);
watcher.run().unwrap();
wait_for_path(&rx, &during);
watcher.unwatch(&root).unwrap();
assert_eq!(watcher.since_when, None);
}
#[test]
fn unchanged_stream_roots_keep_pending_events() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
let child = root.join("child");
let nested = child.join("nested");
let missing = root.join("missing");
std::fs::create_dir_all(&nested).unwrap();
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
watcher.watch(&root, RecursiveMode::Recursive).unwrap();
watcher.watch(&child, RecursiveMode::Recursive).unwrap();
let thread_id = runloop_thread_id(&watcher);
let resume = pause_runloop(&watcher);
let pending = root.join("pending");
std::fs::write(&pending, "pending event").unwrap();
watcher.watch(&root, RecursiveMode::Recursive).unwrap();
assert_eq!(runloop_thread_id(&watcher), thread_id);
watcher.unwatch(&child).unwrap();
assert_eq!(runloop_thread_id(&watcher), thread_id);
assert!(matches!(
watcher.unwatch(&missing).unwrap_err().kind,
ErrorKind::WatchNotFound
));
assert_eq!(runloop_thread_id(&watcher), thread_id);
watcher.update_paths(vec![]).unwrap();
assert_eq!(runloop_thread_id(&watcher), thread_id);
watcher
.update_paths(vec![PathOp::watch_recursive(child.clone())])
.unwrap();
assert_eq!(runloop_thread_id(&watcher), thread_id);
watcher
.update_paths(vec![PathOp::unwatch(child.clone())])
.unwrap();
assert_eq!(runloop_thread_id(&watcher), thread_id);
let err = watcher
.update_paths(vec![PathOp::watch_recursive(missing.clone())])
.unwrap_err();
assert!(matches!(err.source.kind, ErrorKind::PathNotFound));
assert_eq!(runloop_thread_id(&watcher), thread_id);
let err = watcher
.update_paths(vec![
PathOp::Watch(
root.clone(),
WatchPathConfig::new(RecursiveMode::NonRecursive),
),
PathOp::unwatch(missing),
PathOp::watch_recursive(child),
])
.unwrap_err();
assert!(matches!(err.source.kind, ErrorKind::WatchNotFound));
assert_eq!(err.remaining.len(), 1);
assert_eq!(runloop_thread_id(&watcher), thread_id);
let recursive_info = watcher
.runloop
.as_ref()
.unwrap()
.recursive_info
.lock()
.unwrap();
assert!(!recursive_info[&root].is_recursive);
assert!(watch_for(&recursive_info, &nested.join("entry"), None).is_none());
drop(recursive_info);
resume.send(()).expect("resume runloop");
wait_for_path(&rx, &pending);
let path = root.join("entry");
std::fs::write(&path, "still watched").unwrap();
wait_for_path(&rx, &path);
}
#[test]
fn rewatching_a_replaced_root_restarts_the_stream() {
for batch in [false, true] {
let dir = tempfile::tempdir().unwrap();
let parent = dir.path().canonicalize().unwrap();
let root = parent.join("root");
std::fs::create_dir(&root).unwrap();
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
watcher.watch(&root, RecursiveMode::Recursive).unwrap();
let thread_id = runloop_thread_id(&watcher);
std::fs::rename(&root, parent.join("old")).unwrap();
std::fs::create_dir(&root).unwrap();
if batch {
watcher
.update_paths(vec![PathOp::watch_recursive(root.clone())])
.unwrap();
} else {
watcher.watch(&root, RecursiveMode::Recursive).unwrap();
}
assert_ne!(runloop_thread_id(&watcher), thread_id);
let path = root.join("entry");
std::fs::write(&path, "replacement root").unwrap();
wait_for_path(&rx, &path);
}
}
#[test]
fn rewatching_same_path_replaces_recursive_info() {
let dir = tempfile::tempdir().unwrap();
let mut watcher = FsEventWatcher::new(|_| {}, Config::default()).unwrap();
watcher
.append_path(dir.path(), WatchPathConfig::new(RecursiveMode::Recursive))
.expect("watch recursively");
watcher
.append_path(
dir.path(),
WatchPathConfig::new(RecursiveMode::NonRecursive),
)
.expect("rewatch non-recursively");
let watched = watcher.watched_paths().expect("watched paths");
assert_eq!(
watched,
vec![WatchedPath::new(
dir.path().to_path_buf(),
RecursiveMode::NonRecursive
)]
);
assert_eq!(watcher.stream_paths().iter().count(), 1);
}
#[test]
fn user_data_changes_update_callback_without_restarting_stream() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
let mut watcher = FsEventWatcher::new(|_| {}, Config::default()).unwrap();
watcher.watch(&root, RecursiveMode::Recursive).unwrap();
let thread = runloop_thread_id(&watcher);
let config = WatchPathConfig::new(RecursiveMode::Recursive).with_user_data(42);
watcher.watch_with(&root, config).unwrap();
assert_eq!(runloop_thread_id(&watcher), thread);
assert_eq!(
watcher
.runloop
.as_ref()
.unwrap()
.recursive_info
.lock()
.unwrap()[&root]
.user_data,
Some(42)
);
watcher
.update_paths(vec![PathOp::watch_recursive(root.clone())])
.unwrap();
assert_eq!(runloop_thread_id(&watcher), thread);
assert_eq!(
watcher
.runloop
.as_ref()
.unwrap()
.recursive_info
.lock()
.unwrap()[&root]
.user_data,
None
);
}
#[test]
fn only_recursive_ancestors_cover_nested_watches() {
let dir = tempfile::tempdir().unwrap();
let child = dir.path().join("child");
let grandchild = child.join("first").join("second").join("grandchild");
std::fs::create_dir_all(&grandchild).unwrap();
let mut watcher = FsEventWatcher::new(|_| {}, Config::default()).unwrap();
for (path, mode) in [
(dir.path(), RecursiveMode::Recursive),
(child.as_path(), RecursiveMode::NonRecursive),
(grandchild.as_path(), RecursiveMode::Recursive),
] {
watcher
.append_path(path, WatchPathConfig::new(mode))
.expect("watch");
}
assert_eq!(watcher.stream_paths().iter().count(), 1);
assert_eq!(watcher.watched_paths().expect("watched paths").len(), 3);
watcher.remove_path(dir.path()).expect("unwatch parent");
assert_eq!(watcher.stream_paths().iter().count(), 2);
watcher.remove_path(&child).expect("unwatch child");
assert_eq!(watcher.stream_paths().iter().count(), 1);
}
#[test]
fn sibling_watches_each_get_a_stream_root() {
let dir = tempfile::tempdir().unwrap();
let first = dir.path().join("first");
let second = dir.path().join("second");
std::fs::create_dir(&first).unwrap();
std::fs::create_dir(&second).unwrap();
let mut watcher = FsEventWatcher::new(|_| {}, Config::default()).unwrap();
watcher
.append_path(&first, WatchPathConfig::new(RecursiveMode::Recursive))
.expect("watch first");
watcher
.append_path(&second, WatchPathConfig::new(RecursiveMode::Recursive))
.expect("watch second");
assert_eq!(watcher.stream_paths().iter().count(), 2);
}
#[test]
fn roots_at_counts_a_path_and_the_watches_nested_in_it() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
let parent = root.join("parent");
let siblings = [root.join("parent-other"), root.join("parent.d")];
let nested = [parent.join("first"), parent.join("second/deep")];
for path in siblings.iter().chain(&nested) {
std::fs::create_dir_all(path).unwrap();
}
let mut watcher = FsEventWatcher::new(|_| {}, Config::default()).unwrap();
for path in siblings.iter().chain(&nested) {
watcher
.append_path(path, WatchPathConfig::new(RecursiveMode::NonRecursive))
.unwrap();
}
assert_eq!(watcher.roots_at(&parent, true), 2);
assert_eq!(watcher.roots_at(&parent, false), 0);
assert_eq!(watcher.roots_at(&root, true), 4);
watcher
.append_path(&parent, WatchPathConfig::new(RecursiveMode::Recursive))
.unwrap();
assert_eq!(watcher.roots_at(&parent, true), 1);
assert_eq!(watcher.roots_at(&parent, false), 1);
assert_eq!(watcher.roots_at(&root, true), 3);
assert_eq!(watcher.stream_paths().iter().count(), 3);
watcher.remove_path(&parent).unwrap();
assert_eq!(watcher.roots_at(&parent, true), 2);
}
#[test]
fn covering_watch_keeps_receiving_outside_the_nested_watch() {
let tmpdir = testdir();
let child = tmpdir.path().join("child");
let sibling = tmpdir.path().join("sibling");
std::fs::create_dir(&child).expect("create child");
std::fs::create_dir(&sibling).expect("create sibling");
let (mut watcher, mut rx) = watcher();
watcher.watch_recursively(&tmpdir);
let thread_id = runloop_thread_id(&watcher.watcher);
watcher.watch_recursively(&child);
assert_eq!(runloop_thread_id(&watcher.watcher), thread_id);
let path = sibling.join("entry");
std::fs::File::create_new(&path).expect("create");
rx.wait_unordered([expected(path).create_file()]);
}
#[test]
fn covered_watch_updates_callback_without_restarting_stream() {
let tmpdir = testdir();
let root = tmpdir.path().join("root");
let child = root.join("child");
let nested = child.join("nested");
let alias = tmpdir.path().join("alias");
std::fs::create_dir_all(&nested).expect("create dirs");
std::os::unix::fs::symlink(&child, &alias).expect("symlink");
let (mut watcher, mut rx) = watcher();
watcher.watch_recursively(&root);
let thread_id = runloop_thread_id(&watcher.watcher);
watcher.watch_recursively(&alias);
assert_eq!(runloop_thread_id(&watcher.watcher), thread_id);
std::fs::File::create_new(nested.join("first")).expect("create");
rx.wait_unordered([expected(alias.join("nested/first")).create_file()]);
watcher.watch_nonrecursively(&alias);
assert_eq!(runloop_thread_id(&watcher.watcher), thread_id);
assert!(
watcher
.watcher
.watched_paths()
.expect("watched paths")
.contains(&WatchedPath::new(
alias.clone(),
RecursiveMode::NonRecursive
))
);
std::fs::File::create_new(child.join("immediate")).expect("create");
std::fs::File::create_new(nested.join("second")).expect("create");
rx.wait_unordered([
expected(alias.join("immediate")).create_file(),
expected(nested.join("second")).create_file(),
]);
}
#[test]
fn non_recursive_parent_does_not_skip_stream_restart() {
let tmpdir = testdir();
let child = tmpdir.path().join("child");
let nested = child.join("nested");
std::fs::create_dir_all(&nested).expect("create dirs");
let (mut watcher, mut rx) = watcher();
watcher.watch_nonrecursively(&tmpdir);
let thread_id = runloop_thread_id(&watcher.watcher);
watcher.watch_recursively(&child);
assert_ne!(runloop_thread_id(&watcher.watcher), thread_id);
let path = nested.join("entry");
std::fs::File::create_new(&path).expect("create");
rx.wait_unordered([expected(path).create_file()]);
}
#[test]
fn failed_watch_keeps_stream_running() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
watcher.watch_recursively(&tmpdir);
let thread_id = runloop_thread_id(&watcher.watcher);
let err = watcher
.watcher
.watch(&tmpdir.path().join("missing"), RecursiveMode::Recursive)
.expect_err("watch missing path");
assert!(matches!(err.kind, ErrorKind::PathNotFound));
assert_eq!(runloop_thread_id(&watcher.watcher), thread_id);
let path = tmpdir.path().join("entry");
std::fs::File::create_new(&path).expect("create");
rx.wait_unordered([expected(path).create_file()]);
}
#[test]
fn nested_watch_keeps_receiving_after_unwatching_its_parent() {
let tmpdir = testdir();
let child = tmpdir.path().join("child");
std::fs::create_dir(&child).expect("create dir");
let (mut watcher, mut rx) = watcher();
watcher.watch_recursively(&tmpdir);
watcher.watch_recursively(&child);
watcher
.watcher
.unwatch(tmpdir.path())
.expect("unwatch parent");
let path = child.join("entry");
std::fs::File::create_new(&path).expect("create");
rx.wait_unordered([expected(path).create_file()]);
}
#[test]
fn stop_does_not_wait_for_runloop_to_be_waiting() {
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::mpsc;
use std::time::Instant;
let dir = tempfile::tempdir().unwrap();
let (tx, _rx) = mpsc::channel::<crate::Result<Event>>();
let mut watcher = FsEventWatcher::new(tx, Default::default()).unwrap();
watcher.watch(dir.path(), RecursiveMode::Recursive).unwrap();
let runloop = watcher
.runloop
.as_ref()
.expect("watcher to be running")
.runloop
.clone();
let mode = unsafe { cf::kCFRunLoopDefaultMode.expect("default runloop mode") };
struct SourceHammer {
source: *const cf::CFRunLoopSource,
fires: AtomicUsize,
}
unsafe extern "C-unwind" fn hammer_source(info: *mut std::ffi::c_void) {
let Some(hammer) = (unsafe { (info as *const SourceHammer).as_ref() }) else {
return;
};
hammer.fires.fetch_add(1, Ordering::Relaxed);
let Some(source) = (unsafe { hammer.source.as_ref() }) else {
return;
};
source.signal();
}
let mut hammer = Box::new(SourceHammer {
source: std::ptr::null(),
fires: AtomicUsize::new(0),
});
let mut ctx = cf::CFRunLoopSourceContext {
version: 0,
info: (&mut *hammer as *mut SourceHammer).cast(),
retain: None,
release: None,
copyDescription: None,
equal: None,
hash: None,
schedule: None,
cancel: None,
perform: Some(hammer_source),
};
let source = unsafe {
cf::CFRunLoopSource::new(cf::kCFAllocatorDefault, 0, &mut ctx)
.expect("source to be created")
};
hammer.source = cf::CFRetained::as_ptr(&source).as_ptr();
runloop.add_source(Some(&source), Some(mode));
source.signal();
runloop.wake_up();
let setup_start = Instant::now();
while hammer.fires.load(Ordering::Relaxed) == 0
&& setup_start.elapsed() < Duration::from_secs(1)
{
std::thread::yield_now();
}
assert!(
hammer.fires.load(Ordering::Relaxed) > 0,
"runloop source never fired; test setup failed"
);
let (done_tx, done_rx) = mpsc::channel::<()>();
std::thread::spawn(move || {
drop(watcher);
let _ = done_tx.send(());
});
done_rx
.recv_timeout(Duration::from_secs(5))
.expect("dropping FsEventWatcher timed out (possible shutdown hang)");
}
#[test]
fn test_fsevent_watcher_drop() {
use super::*;
use std::time::Duration;
let dir = tempfile::tempdir().unwrap();
let (tx, rx) = std::sync::mpsc::channel();
{
let mut watcher = FsEventWatcher::new(tx, Default::default()).unwrap();
watcher.watch(dir.path(), RecursiveMode::Recursive).unwrap();
thread::sleep(Duration::from_millis(2000));
println!("is running -> {}", watcher.is_running());
thread::sleep(Duration::from_millis(1000));
watcher.unwatch(dir.path()).unwrap();
println!("is running -> {}", watcher.is_running());
}
thread::sleep(Duration::from_millis(1000));
for res in rx {
let e = res.unwrap();
println!("debug => {:?} {:?}", e.kind, e.paths);
}
println!("in test: {} works", file!());
}
#[test]
fn test_steam_context_info_send_and_sync() {
fn check_send<T: Send + Sync>() {}
check_send::<StreamContextInfo>();
}
fn run_callback(
recursive_info: HashMap<PathBuf, WatchInfo>,
events: &[(&[u8], u32)],
) -> Vec<crate::Result<Event>> {
let events: Vec<_> = events
.iter()
.zip(1..)
.map(|(&(path, flags), id)| (path, flags, id))
.collect();
run_callback_with_ids(recursive_info, &events)
}
fn run_callback_with_ids(
recursive_info: HashMap<PathBuf, WatchInfo>,
events: &[(&[u8], u32, fs::FSEventStreamEventId)],
) -> Vec<crate::Result<Event>> {
use std::ffi::CString;
use std::ptr;
let (tx, rx) = std::sync::mpsc::channel::<crate::Result<Event>>();
let event_handler: Arc<Mutex<dyn EventHandler>> = Arc::new(Mutex::new(tx));
let context = Box::new(StreamContextInfo {
event_handler,
recursive_info: Arc::new(Mutex::new(recursive_info)),
event_kinds: EventKindMask::ALL,
});
let context_ptr = Box::into_raw(context) as *mut libc::c_void;
let c_paths: Vec<CString> = events
.iter()
.map(|(path, ..)| CString::new(*path).expect("cstring"))
.collect();
let path_ptrs: Vec<_> = c_paths.iter().map(|p| p.as_ptr()).collect();
let event_paths = NonNull::new(path_ptrs.as_ptr() as *mut libc::c_void).unwrap();
let flags_arr: Vec<fs::FSEventStreamEventFlags> = events
.iter()
.map(|(_, flags, _)| *flags as fs::FSEventStreamEventFlags)
.collect();
let event_flags =
NonNull::new(flags_arr.as_ptr() as *mut fs::FSEventStreamEventFlags).unwrap();
let ids_arr: Vec<fs::FSEventStreamEventId> = events.iter().map(|(.., id)| *id).collect();
let event_ids = NonNull::new(ids_arr.as_ptr() as *mut fs::FSEventStreamEventId).unwrap();
let res = std::panic::catch_unwind(|| unsafe {
callback_impl(
ptr::null(),
context_ptr,
events.len(),
event_paths,
event_flags,
event_ids,
);
});
unsafe {
drop(Box::from_raw(context_ptr as *mut StreamContextInfo));
}
assert!(res.is_ok(), "callback_impl should not panic");
rx.try_iter().collect()
}
#[test]
fn callback_impl_delivers_rescan_for_ancestor_recovery_paths() {
let mut recursive_info = HashMap::new();
recursive_info.insert(
PathBuf::from("/watched/a"),
WatchInfo {
reported_path: PathBuf::from("/watched/a"),
..watch_info(true)
},
);
recursive_info.insert(
PathBuf::from("/watched/b"),
WatchInfo {
reported_path: PathBuf::from("/watched/b"),
..watch_info(false)
},
);
let recovery_flags = [
StreamFlags::MUST_SCAN_SUBDIRS.bits(),
(StreamFlags::MUST_SCAN_SUBDIRS | StreamFlags::USER_DROPPED).bits(),
(StreamFlags::MUST_SCAN_SUBDIRS | StreamFlags::KERNEL_DROPPED).bits(),
];
for flags in recovery_flags {
for path in [
b"/watched/a".as_slice(),
b"/watched".as_slice(),
b"/".as_slice(),
] {
let events = run_callback(recursive_info.clone(), &[(path, flags)]);
let path_buf = PathBuf::from(std::str::from_utf8(path).unwrap());
assert!(
events.iter().any(|event| {
let event = event.as_ref().expect("callback event");
event.need_rescan() && event.paths == [path_buf.clone()]
}),
"missing rescan for {} flags {flags:#x}: {events:?}",
String::from_utf8_lossy(path)
);
}
}
let ordinary = (StreamFlags::ITEM_MODIFIED | StreamFlags::IS_FILE).bits();
for (path, expected) in [
(b"/watched".as_slice(), false),
(b"/".as_slice(), false),
(b"/watched/a/deep/file".as_slice(), true),
(b"/watched/b/file".as_slice(), true),
(b"/watched/b/deep/file".as_slice(), false),
] {
let events = run_callback(recursive_info.clone(), &[(path, ordinary)]);
assert_eq!(
!events.is_empty(),
expected,
"ordinary path {}",
String::from_utf8_lossy(path)
);
assert!(
events
.iter()
.all(|event| !event.as_ref().expect("callback event").need_rescan())
);
}
}
#[test]
fn callback_drops_events_from_before_the_watch() {
let watch = |user_data, since, deep_since| WatchInfo {
user_data: Some(user_data),
since,
deep_since,
..watch_info(true)
};
let recursive_info = HashMap::from([
(PathBuf::from("/watched"), watch(1, 10, 20)),
(PathBuf::from("/watched/nested"), watch(2, 30, 30)),
]);
let created = (StreamFlags::ITEM_CREATED | StreamFlags::IS_FILE).bits();
let cases: [(&[u8], u32, fs::FSEventStreamEventId, Option<u64>); 13] = [
(b"/watched/file", created, 9, None),
(b"/watched/file", created, 10, None),
(b"/watched/file", created, 11, Some(1)),
(b"/watched/deep/file", created, 20, None),
(b"/watched/deep/file", created, 21, Some(1)),
(b"/watched/nested", created, 30, Some(1)),
(b"/watched/nested", created, 31, Some(2)),
(b"/watched/nested/file", created, 20, None),
(b"/watched/nested/file", created, 30, Some(1)),
(b"/watched/nested/file", created, 31, Some(2)),
(
b"/watched/nested",
StreamFlags::ROOT_CHANGED.bits(),
0,
Some(2),
),
(
b"/watched/nested",
StreamFlags::MUST_SCAN_SUBDIRS.bits(),
1,
Some(2),
),
(b"/watched", StreamFlags::HISTORY_DONE.bits(), 0, None),
];
for (path, flags, id, expected) in cases {
let delivered: Vec<_> =
run_callback_with_ids(recursive_info.clone(), &[(path, flags, id)])
.into_iter()
.map(|event| event.unwrap().user_data())
.collect();
assert_eq!(
delivered,
Vec::from_iter(expected.map(Some)),
"{} at {id}",
String::from_utf8_lossy(path)
);
}
}
#[test]
fn callback_user_data_identifies_events_and_watch_specific_rescans() {
let mut info = watch_info(true);
info.user_data = Some(42);
let recursive_info = HashMap::from([
(PathBuf::from("/watched"), info),
(PathBuf::from("/watched/nested"), watch_info(true)),
]);
let events: Vec<_> = run_callback(
recursive_info,
&[
(
b"/watched/file",
(StreamFlags::ITEM_CREATED | StreamFlags::IS_FILE).bits(),
),
(b"/watched", StreamFlags::MUST_SCAN_SUBDIRS.bits()),
(b"/", StreamFlags::MUST_SCAN_SUBDIRS.bits()),
(
b"/watched/nested/file",
(StreamFlags::ITEM_CREATED | StreamFlags::IS_FILE).bits(),
),
],
)
.into_iter()
.map(Result::unwrap)
.collect();
assert_eq!(
events.iter().map(Event::user_data).collect::<Vec<_>>(),
[Some(42), Some(42), None, None]
);
assert!(events[1].need_rescan());
assert!(events[2].need_rescan());
}
#[test]
fn callback_impl_handles_non_utf8_paths_without_panicking() {
use std::os::unix::ffi::OsStrExt;
let mut recursive_info = HashMap::new();
recursive_info.insert(
PathBuf::from("/tmp"),
WatchInfo {
reported_path: PathBuf::from("/tmp"),
..watch_info(true)
},
);
let bytes = b"/tmp/\xff";
let events = run_callback(
recursive_info,
&[(bytes.as_slice(), StreamFlags::ITEM_CREATED.bits())],
);
let event = events
.first()
.expect("expected event")
.as_ref()
.expect("expected Ok(Event)");
assert!(
event.kind.is_create(),
"expected create event, got {event:?}"
);
assert_eq!(event.paths.len(), 1);
assert_eq!(event.paths[0].as_os_str().as_bytes(), bytes);
}
#[test]
fn callback_impl_ignores_unknown_flag_bits_without_panicking() {
let unknown_mask = !StreamFlags::all().bits();
let unknown_bit = unknown_mask & unknown_mask.wrapping_neg();
assert_ne!(unknown_bit, 0, "StreamFlags unexpectedly uses all bits");
let raw_flag = StreamFlags::ITEM_CREATED.bits() | unknown_bit;
assert!(
StreamFlags::from_bits(raw_flag).is_none(),
"raw_flag must include an unknown bit for this test to be meaningful"
);
let mut recursive_info = HashMap::new();
recursive_info.insert(
PathBuf::from("/tmp"),
WatchInfo {
reported_path: PathBuf::from("/tmp"),
..watch_info(true)
},
);
let events = run_callback(recursive_info, &[(b"/tmp/file".as_slice(), raw_flag)]);
let event = events
.first()
.expect("expected event")
.as_ref()
.expect("expected Ok(Event)");
assert!(
event.kind.is_create(),
"expected create event, got {event:?}"
);
}
#[test]
fn translate_flags_ignores_is_file_only_events() {
assert!(translate_flags(StreamFlags::IS_FILE, true).is_empty());
assert!(
translate_flags(StreamFlags::IS_FILE | StreamFlags::ITEM_CLONED, true).is_empty(),
"type-only clone flags should not produce events"
);
}
#[test]
fn translate_flags_sets_clone_info_for_file_events() {
let create = translate_flags(
StreamFlags::ITEM_CREATED | StreamFlags::IS_FILE | StreamFlags::ITEM_CLONED,
true,
);
assert_eq!(create.len(), 1);
assert_eq!(create[0].kind, EventKind::Create(CreateKind::File));
assert_eq!(create[0].info(), Some("is: clone"));
let modify = translate_flags(
StreamFlags::INODE_META_MOD
| StreamFlags::ITEM_MODIFIED
| StreamFlags::IS_FILE
| StreamFlags::ITEM_CLONED,
true,
);
assert_eq!(modify.len(), 2);
assert!(
modify
.iter()
.any(|e| matches!(e.kind, EventKind::Modify(ModifyKind::Metadata(_))))
);
assert!(
modify
.iter()
.any(|e| matches!(e.kind, EventKind::Modify(ModifyKind::Data(_))))
);
assert!(
modify.iter().all(|e| e.info() == Some("is: clone")),
"all events should be annotated as clone-related: {modify:?}"
);
}
#[test]
fn translate_flags_does_not_override_existing_info() {
let evs = translate_flags(
StreamFlags::ROOT_CHANGED
| StreamFlags::ITEM_REMOVED
| StreamFlags::IS_FILE
| StreamFlags::ITEM_CLONED,
true,
);
assert_eq!(evs.len(), 1);
assert_eq!(evs[0].info(), Some("root changed"));
}
#[test]
fn does_not_crash_with_empty_path() {
let mut watcher = FsEventWatcher::new(|_| {}, Default::default()).unwrap();
let watch_result = watcher.watch(Path::new(""), RecursiveMode::Recursive);
assert!(
matches!(
watch_result,
Err(Error {
kind: ErrorKind::PathNotFound,
..
})
),
"actual: {watch_result:#?}"
);
let unwatch_result = watcher.unwatch(Path::new(""));
assert!(
matches!(
unwatch_result,
Err(Error {
kind: ErrorKind::WatchNotFound,
..
})
),
"actual: {unwatch_result:#?}"
);
}
#[test]
fn create_file() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
watcher.watch_recursively(&tmpdir);
let path = tmpdir.path().join("entry");
std::fs::File::create_new(&path).expect("create");
rx.wait_unordered([expected(path).create_file()]);
}
#[test]
fn write_file() {
let tmpdir = testdir();
let path = tmpdir.path().join("entry");
std::fs::File::create_new(&path).expect("create");
let (mut watcher, mut rx) = watcher();
watcher.watch_recursively(&tmpdir);
std::fs::write(&path, b"123").expect("write");
rx.wait_unordered([expected(&path).modify_data_content()]);
}
#[test]
fn chmod_file() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
let file = std::fs::File::create_new(&path).expect("create");
let mut permissions = file.metadata().expect("metadata").permissions();
permissions.set_readonly(true);
watcher.watch_recursively(&tmpdir);
file.set_permissions(permissions).expect("set_permissions");
rx.wait_unordered([expected(&path).modify_meta_owner()]);
}
#[test]
fn rename_file() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
std::fs::File::create_new(&path).expect("create");
watcher.watch_recursively(&tmpdir);
let new_path = tmpdir.path().join("renamed");
std::fs::rename(&path, &new_path).expect("rename");
rx.wait_unordered([expected(path).rename_any(), expected(new_path).rename_any()]);
}
#[test]
fn delete_file() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let file = tmpdir.path().join("file");
std::fs::write(&file, "").expect("write");
watcher.watch_nonrecursively(&tmpdir);
std::fs::remove_file(&file).expect("remove");
rx.wait_unordered([expected(&file).remove_file()]);
}
#[test]
fn delete_self_file() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let file = tmpdir.path().join("file");
std::fs::write(&file, "").expect("write");
watcher.watch_nonrecursively(&file);
std::fs::remove_file(&file).expect("remove");
rx.wait_unordered([expected(file).remove_file()]);
}
#[test]
fn delete_self_dir() {
let tmpdir = testdir();
let dir = tmpdir.path().join("dir");
std::fs::create_dir(&dir).expect("create");
let (mut watcher, mut rx) = watcher();
watcher.watch_nonrecursively(&dir);
std::fs::remove_dir(&dir).expect("remove");
rx.wait_unordered([expected(&dir).remove_folder()]);
}
#[test]
fn create_write_overwrite() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let overwritten_file = tmpdir.path().join("overwritten_file");
let overwriting_file = tmpdir.path().join("overwriting_file");
std::fs::write(&overwritten_file, "123").expect("write1");
watcher.watch_nonrecursively(&tmpdir);
std::fs::File::create(&overwriting_file).expect("create");
std::fs::write(&overwriting_file, "321").expect("write2");
std::fs::rename(&overwriting_file, &overwritten_file).expect("rename");
rx.wait_unordered([
expected(&overwriting_file).create(),
expected(&overwriting_file).modify_data_content().multiple(),
expected(&overwriting_file).rename_any(),
expected(&overwritten_file).rename_any(),
]);
}
#[test]
fn create_dir() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
watcher.watch_recursively(&tmpdir);
let path = tmpdir.path().join("entry");
std::fs::create_dir(&path).expect("create");
rx.wait_unordered([expected(&path).create_folder()]);
}
#[test]
fn chmod_dir() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
std::fs::create_dir(&path).expect("create_dir");
let mut permissions = std::fs::metadata(&path).expect("metadata").permissions();
permissions.set_readonly(true);
watcher.watch_recursively(&tmpdir);
std::fs::set_permissions(&path, permissions).expect("set_permissions");
rx.wait_unordered([expected(&path).modify_meta_owner()]);
}
#[test]
fn rename_dir() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
let new_path = tmpdir.path().join("new_path");
std::fs::create_dir(&path).expect("create_dir");
watcher.watch_recursively(&tmpdir);
std::fs::rename(&path, &new_path).expect("rename");
rx.wait_ordered([
expected(&path).rename_any(),
expected(&new_path).rename_any(),
]);
}
#[test]
fn delete_dir() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
std::fs::create_dir(&path).expect("create_dir");
watcher.watch_recursively(&tmpdir);
std::fs::remove_dir(&path).expect("remove");
rx.wait_unordered([expected(path).remove_folder()]);
}
#[test]
fn rename_dir_twice() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
let new_path = tmpdir.path().join("new_path");
let new_path2 = tmpdir.path().join("new_path2");
std::fs::create_dir(&path).expect("create_dir");
watcher.watch_recursively(&tmpdir);
std::fs::rename(&path, &new_path).expect("rename");
std::fs::rename(&new_path, &new_path2).expect("rename2");
rx.wait_unordered([
expected(&path).rename_any(),
expected(&new_path).rename_any(),
expected(&new_path2).rename_any(),
]);
}
#[test]
fn move_out_of_watched_dir() {
let tmpdir = testdir();
let subdir = tmpdir.path().join("subdir");
let (mut watcher, mut rx) = watcher();
let path = subdir.join("entry");
std::fs::create_dir_all(&subdir).expect("create_dir_all");
std::fs::File::create_new(&path).expect("create");
watcher.watch_recursively(&subdir);
let new_path = tmpdir.path().join("entry");
std::fs::rename(&path, &new_path).expect("rename");
rx.wait_unordered([expected(path).rename_any()]);
}
#[test]
#[ignore = "https://github.com/notify-rs/notify/issues/729"]
fn create_write_write_rename_write_remove() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let file1 = tmpdir.path().join("entry");
let file2 = tmpdir.path().join("entry2");
std::fs::File::create_new(&file2).expect("create file2");
let new_path = tmpdir.path().join("renamed");
watcher.watch_recursively(&tmpdir);
std::fs::write(&file1, "123").expect("write 1");
std::fs::write(&file2, "321").expect("write 2");
std::fs::rename(&file1, &new_path).expect("rename");
std::fs::write(&new_path, b"1").expect("write 3");
std::fs::remove_file(&new_path).expect("remove");
rx.wait_ordered([
expected(&file1).create_file(),
expected(&file1).modify_data_content(),
expected(&file2).modify_data_content(),
expected(&file1).rename_any(),
expected(&new_path).rename_any(),
expected(&new_path).modify_data_content(),
expected(&new_path).remove_file(),
]);
}
#[test]
fn rename_twice() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
std::fs::File::create_new(&path).expect("create");
watcher.watch_recursively(&tmpdir);
let new_path1 = tmpdir.path().join("renamed1");
let new_path2 = tmpdir.path().join("renamed2");
std::fs::rename(&path, &new_path1).expect("rename1");
std::fs::rename(&new_path1, &new_path2).expect("rename2");
rx.wait_unordered([
expected(&path).rename_any(),
expected(&new_path1).rename_any(),
expected(&new_path2).rename_any(),
]);
}
#[test]
fn set_file_mtime() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
let file = std::fs::File::create_new(&path).expect("create");
watcher.watch_recursively(&tmpdir);
file.set_modified(
std::time::SystemTime::now()
.checked_sub(Duration::from_secs(60 * 60))
.expect("time"),
)
.expect("set_time");
rx.wait_unordered([expected(&path).modify_meta_any()]);
}
#[test]
fn write_file_non_recursive_watch() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
std::fs::File::create_new(&path).expect("create");
watcher.watch_nonrecursively(&path);
std::fs::write(&path, b"123").expect("write");
rx.wait_unordered([expected(path).modify_data_content()]);
}
#[test]
fn write_to_a_hardlink_pointed_to_the_watched_file_triggers_an_event() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let subdir = tmpdir.path().join("subdir");
let file = subdir.join("file");
let hardlink = tmpdir.path().join("hardlink");
std::fs::create_dir(&subdir).expect("create");
std::fs::write(&file, "").expect("file");
std::fs::hard_link(&file, &hardlink).expect("hardlink");
watcher.watch_nonrecursively(&file);
std::fs::write(&hardlink, "123123").expect("write to the hard link");
rx.wait_unordered([expected(file).modify_data_content()]);
}
#[test]
fn recursive_creation() {
let tmpdir = testdir();
let nested1 = tmpdir.path().join("1");
let nested2 = tmpdir.path().join("1/2");
let nested3 = tmpdir.path().join("1/2/3");
let nested4 = tmpdir.path().join("1/2/3/4");
let nested5 = tmpdir.path().join("1/2/3/4/5");
let nested6 = tmpdir.path().join("1/2/3/4/5/6");
let nested7 = tmpdir.path().join("1/2/3/4/5/6/7");
let nested8 = tmpdir.path().join("1/2/3/4/5/6/7/8");
let nested9 = tmpdir.path().join("1/2/3/4/5/6/7/8/9");
let (mut watcher, mut rx) = watcher();
watcher.watch_recursively(&tmpdir);
std::fs::create_dir_all(&nested9).expect("create_dir_all");
rx.wait_ordered([
expected(&nested1).create_folder(),
expected(&nested2).create_folder(),
expected(&nested3).create_folder(),
expected(&nested4).create_folder(),
expected(&nested5).create_folder(),
expected(&nested6).create_folder(),
expected(&nested7).create_folder(),
expected(&nested8).create_folder(),
expected(&nested9).create_folder(),
]);
}
#[test]
fn fsevent_watcher_respects_event_kind_mask() {
use crate::Watcher;
use notify_types::event::EventKindMask;
let tmpdir = testdir();
let (tx, rx) = std::sync::mpsc::channel();
let config = Config::default().with_event_kinds(EventKindMask::CREATE);
let mut watcher = FsEventWatcher::new(tx, config).expect("create watcher");
watcher
.watch(tmpdir.path(), crate::RecursiveMode::Recursive)
.expect("watch");
let path = tmpdir.path().join("test_file");
std::fs::File::create_new(&path).expect("create");
std::thread::sleep(Duration::from_millis(100));
std::fs::write(&path, "modified content").expect("write modified");
std::thread::sleep(Duration::from_millis(100));
let events: Vec<_> = rx.try_iter().filter_map(|r| r.ok()).collect();
assert!(
events.iter().any(|e| e.kind.is_create()),
"Expected CREATE event, got: {:?}",
events
);
assert!(
!events.iter().any(|e| e.kind.is_modify()),
"Should not receive MODIFY events with CREATE-only mask, got: {:?}",
events
);
}
#[test]
fn path_budget_is_shared_across_live_streams() {
static ACTIVE_PATHS: AtomicUsize = AtomicUsize::new(0);
let mut first = FseventsPathReservation::new(&ACTIVE_PATHS);
let mut second = FseventsPathReservation::new(&ACTIVE_PATHS);
first
.reserve(15, 21)
.expect("first stream must fit within the budget");
assert_eq!(second.reserve(15, 21), Err(15));
first.reserve(18, 21).expect("three more paths must fit");
assert_eq!(second.reserve(4, 21), Err(18));
assert_eq!(first.reserve(22, 21), Err(18));
assert_eq!(first.path_count, 18);
first.shrink_to(10);
second
.reserve(11, 21)
.expect("released paths must be available");
assert_eq!(ACTIVE_PATHS.load(Ordering::Relaxed), 21);
assert_eq!(first.reserve(10, 20), Err(21));
assert_eq!(first.reserve(9, 19), Err(21));
first.reserve(9, 20).expect("one path fewer must fit");
assert_eq!(first.path_count, 10);
drop(first);
drop(second);
assert_eq!(ACTIVE_PATHS.load(Ordering::Relaxed), 0);
}
struct RootLimit {
budget: usize,
root: PathBuf,
_dir: tempfile::TempDir,
_limit: RestoreLimit,
}
impl RootLimit {
fn new() -> Self {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
watcher.watch(&root, RecursiveMode::NonRecursive).unwrap();
let path = root.join("first_stream");
std::fs::write(&path, "").unwrap();
wait_for_path(&rx, &path);
drop(watcher);
let limit = RestoreLimit::lower(256);
Self {
budget: fsevents_path_budget().expect("path budget"),
root,
_dir: dir,
_limit: limit,
}
}
fn dirs(&self, count: usize) -> Vec<PathBuf> {
(0..count)
.map(|i| {
let path = self.root.join(format!("dir_{i}"));
std::fs::create_dir(&path).unwrap();
path
})
.collect()
}
}
fn watched(watcher: &FsEventWatcher) -> Vec<WatchedPath> {
let mut watched = watcher.watched_paths().unwrap();
watched.sort_by(|a, b| a.path.cmp(&b.path));
watched
}
fn active_paths() -> usize {
ACTIVE_FSEVENTS_PATHS.load(Ordering::Relaxed)
}
#[test]
#[ignore = "fills the process-wide path budget; run alone with --ignored --test-threads=1"]
fn root_limit_refused_watch_keeps_the_stream_running() {
let limit = RootLimit::new();
let dirs = limit.dirs(limit.budget + 1);
let (last, spare) = (&dirs[limit.budget - 1], &dirs[limit.budget]);
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
watcher
.update_paths(
dirs[..limit.budget - 1]
.iter()
.map(PathOp::watch_non_recursive)
.collect(),
)
.unwrap();
watcher.watch(last, RecursiveMode::NonRecursive).unwrap();
let thread_id = runloop_thread_id(&watcher);
let before = watched(&watcher);
let config = WatchPathConfig::new(RecursiveMode::Recursive).with_user_data(7);
let err = watcher.watch_with(spare, config).unwrap_err();
assert!(matches!(err.kind, ErrorKind::MaxFilesWatch), "{err:?}");
assert_eq!(err.paths, [spare.as_path()]);
assert_eq!(err.user_data(), Some(7));
assert_eq!(runloop_thread_id(&watcher), thread_id);
assert_eq!(watched(&watcher), before);
assert_eq!(active_paths(), limit.budget);
for dir in [&dirs[0], last] {
let path = dir.join("entry");
std::fs::write(&path, "still watched").unwrap();
wait_for_path(&rx, &path);
}
}
#[test]
#[ignore = "fills the process-wide path budget; run alone with --ignored --test-threads=1"]
fn root_limit_lowered_below_the_stream_refuses_to_replace_it() {
let limit = RootLimit::new();
let dirs = limit.dirs(limit.budget);
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
watcher
.update_paths(dirs.iter().map(PathOp::watch_non_recursive).collect())
.unwrap();
let thread_id = runloop_thread_id(&watcher);
let before = watched(&watcher);
let lowered = RestoreLimit::lower((12 * (limit.budget - 1) - 1) as libc::rlim_t);
let single = watcher.unwatch(&dirs[0]);
let batch = watcher.update_paths(vec![PathOp::unwatch(&dirs[0])]);
drop(lowered);
let err = single.unwrap_err();
assert!(matches!(err.kind, ErrorKind::MaxFilesWatch), "{err:?}");
let err = batch.unwrap_err();
assert!(
matches!(err.source.kind, ErrorKind::MaxFilesWatch),
"{err:?}"
);
assert_eq!(runloop_thread_id(&watcher), thread_id);
assert_eq!(watched(&watcher), before);
assert_eq!(active_paths(), limit.budget);
let path = dirs[0].join("entry");
std::fs::write(&path, "still watched").unwrap();
wait_for_path(&rx, &path);
watcher.unwatch(&dirs[0]).unwrap();
assert_eq!(active_paths(), limit.budget - 1);
}
#[test]
#[ignore = "fills the process-wide path budget; run alone with --ignored --test-threads=1"]
fn root_limit_refuses_to_uncover_nested_watches() {
let limit = RootLimit::new();
let children = limit.dirs(limit.budget + 1);
let nested = children[0].join("nested");
std::fs::create_dir(&nested).unwrap();
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
let mut ops = vec![PathOp::Watch(
limit.root.clone(),
WatchPathConfig::new(RecursiveMode::Recursive).with_user_data(1),
)];
ops.extend(children.iter().map(PathOp::watch_non_recursive));
watcher.update_paths(ops).unwrap();
assert_eq!(active_paths(), 1);
let thread_id = runloop_thread_id(&watcher);
let before = watched(&watcher);
let err = watcher
.watch(&limit.root, RecursiveMode::NonRecursive)
.unwrap_err();
assert!(matches!(err.kind, ErrorKind::MaxFilesWatch), "{err:?}");
let err = watcher.unwatch(&limit.root).unwrap_err();
assert!(matches!(err.kind, ErrorKind::MaxFilesWatch), "{err:?}");
assert_eq!(err.paths, [limit.root.as_path()]);
let err = watcher
.update_paths(vec![
PathOp::unwatch(&limit.root),
PathOp::unwatch(&children[0]),
])
.unwrap_err();
assert!(
matches!(err.source.kind, ErrorKind::MaxFilesWatch),
"{err:?}"
);
assert!(matches!(&err.origin, Some(PathOp::Unwatch(path)) if *path == limit.root));
assert_eq!(err.remaining.len(), 1);
assert_eq!(runloop_thread_id(&watcher), thread_id);
assert_eq!(watched(&watcher), before);
assert_eq!(active_paths(), 1);
let path = nested.join("entry");
std::fs::write(&path, "still recursive").unwrap();
assert_eq!(wait_for_path(&rx, &path).user_data(), Some(1));
watcher
.update_paths(vec![
PathOp::unwatch(&children[0]),
PathOp::unwatch(&limit.root),
])
.unwrap();
assert_eq!(active_paths(), limit.budget);
let path = children[1].join("entry");
std::fs::write(&path, "now a stream root").unwrap();
wait_for_path(&rx, &path);
}
#[test]
#[ignore = "fills the process-wide path budget; run alone with --ignored --test-threads=1"]
fn root_limit_batch_keeps_the_operations_before_the_refused_one() {
let limit = RootLimit::new();
let dirs = limit.dirs(limit.budget + 2);
let refused = &dirs[limit.budget];
let (tx, rx) = mpsc::channel();
let mut watcher = FsEventWatcher::new(tx, Config::default()).unwrap();
watcher
.watch(&dirs[0], RecursiveMode::NonRecursive)
.unwrap();
let ops = dirs[1..]
.iter()
.zip(1..)
.map(|(dir, id)| {
let config = WatchPathConfig::new(RecursiveMode::NonRecursive).with_user_data(id);
PathOp::Watch(dir.clone(), config)
})
.collect();
let err = watcher.update_paths(ops).unwrap_err();
assert!(
matches!(err.source.kind, ErrorKind::MaxFilesWatch),
"{err:?}"
);
assert_eq!(err.source.paths, [refused.as_path()]);
assert_eq!(err.source.user_data(), Some(limit.budget as u64));
assert_eq!(
err.origin.as_ref().map(PathOp::as_path),
Some(refused.as_path())
);
assert_eq!(
err.remaining
.iter()
.map(PathOp::as_path)
.collect::<Vec<_>>(),
[dirs[limit.budget + 1].as_path()]
);
let mut applied = dirs[..limit.budget].to_vec();
applied.sort();
assert_eq!(
watched(&watcher)
.into_iter()
.map(|watched| watched.path)
.collect::<Vec<_>>(),
applied
);
assert_eq!(active_paths(), limit.budget);
for dir in [&dirs[0], &dirs[limit.budget - 1]] {
let path = dir.join("entry");
std::fs::write(&path, "watched").unwrap();
wait_for_path(&rx, &path);
}
let err = watcher
.update_paths(vec![
PathOp::watch_non_recursive(refused),
PathOp::unwatch(&dirs[0]),
])
.unwrap_err();
assert!(
matches!(err.source.kind, ErrorKind::MaxFilesWatch),
"{err:?}"
);
assert_eq!(err.remaining.len(), 1);
watcher
.update_paths(vec![
PathOp::unwatch(&dirs[0]),
PathOp::watch_non_recursive(refused),
])
.unwrap();
assert_eq!(active_paths(), limit.budget);
let path = refused.join("entry");
std::fs::write(&path, "watched").unwrap();
wait_for_path(&rx, &path);
}
#[test]
#[ignore = "fills the process-wide path budget; run alone with --ignored --test-threads=1"]
fn root_limit_is_shared_and_held_while_a_stream_is_replaced() {
let limit = RootLimit::new();
let dirs = limit.dirs(limit.budget + 1);
let (last, spare) = (&dirs[limit.budget - 1], &dirs[limit.budget]);
let (tx, rx) = mpsc::channel();
let mut first = FsEventWatcher::new(tx, Config::default()).unwrap();
first
.update_paths(
dirs[..limit.budget - 1]
.iter()
.map(PathOp::watch_non_recursive)
.collect(),
)
.unwrap();
let mut second = FsEventWatcher::new(|_| {}, Config::default()).unwrap();
let resume = pause_runloop(&first);
let stop_flag = first.runloop.as_ref().unwrap().stop_flag.clone();
thread::scope(|scope| {
scope.spawn(|| first.watch(last, RecursiveMode::NonRecursive).unwrap());
let deadline = Instant::now() + Duration::from_secs(10);
while !stop_flag.load(Ordering::Acquire) && Instant::now() < deadline {
thread::sleep(Duration::from_millis(1));
}
let result = second.watch(spare, RecursiveMode::NonRecursive);
resume.send(()).expect("resume runloop");
assert!(matches!(result.unwrap_err().kind, ErrorKind::MaxFilesWatch));
});
assert_eq!(active_paths(), limit.budget);
first.unwatch(&dirs[0]).unwrap();
second.watch(spare, RecursiveMode::NonRecursive).unwrap();
assert_eq!(active_paths(), limit.budget);
let path = last.join("entry");
std::fs::write(&path, "watched").unwrap();
wait_for_path(&rx, &path);
drop(first);
assert_eq!(active_paths(), 1);
drop(second);
assert_eq!(active_paths(), 0);
}
#[test]
fn rename_then_remove_remove_event_must_be_the_last_one() {
let tmpdir = testdir();
let (mut watcher, mut rx) = watcher();
let path = tmpdir.path().join("entry");
std::fs::File::create_new(&path).expect("create");
watcher.watch_recursively(&tmpdir);
let new_path1 = tmpdir.path().join("renamed1");
let new_path2 = tmpdir.path().join("renamed2");
std::fs::rename(&path, &new_path1).expect("rename1");
std::fs::rename(&new_path1, &new_path2).expect("rename2");
std::fs::remove_file(&new_path2).expect("remove_file");
loop {
let ev = rx.recv();
if matches!(ev.kind, EventKind::Remove(RemoveKind::File)) {
assert_eq!(&ev.paths, &[new_path2]);
break;
}
}
rx.ensure_empty();
}
}