use std::collections::{HashMap, HashSet};
use std::io;
use std::os::windows::io::AsRawHandle;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, MutexGuard, OnceLock, Weak};
use std::time::Duration;
use windows_overlapped_io_sys::{Issued, Operation, Submitted, UnassociatedEndpoint};
use windows_sys::Win32::Foundation::ERROR_IO_PENDING;
use windows_sys::Win32::Storage::FileSystem::{
FILE_NOTIFY_CHANGE_ATTRIBUTES, FILE_NOTIFY_CHANGE_CREATION, FILE_NOTIFY_CHANGE_DIR_NAME,
FILE_NOTIFY_CHANGE_FILE_NAME, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_NOTIFY_CHANGE_SECURITY,
FILE_NOTIFY_CHANGE_SIZE, FindNextChangeNotification, ReadDirectoryChangesW,
};
use windows_threadpool_sys::io::{IoCompletion, ThreadpoolIo};
use windows_threadpool_sys::timer::ThreadpoolTimer;
use windows_threadpool_sys::wait::{ThreadpoolWait, WaitActivation};
use windows_threadpool_sys::work::ThreadpoolWork;
use crate::coarse::CoarseHandle;
use crate::directory::{
DirectoryHandle, DirectoryId, FaultDetail, OpenFailure, VolumeIdentity, classify,
classify_detail,
};
use crate::monitor::{Resident, rekey};
use crate::notify::{DecodedBatch, DesyncCause, decode_batch};
use crate::queue::{Notification, Resume, WatchId};
use crate::retry::{FaultOperation, WatchMode, clamp};
use crate::route::Route;
use crate::watch::{RetryMode, VolumeChangeDecision, VolumeChangePolicy};
pub const DEFAULT_BUFFER_BYTES: usize = 64 * 1024;
const BYTES_PER_WORD: usize = size_of::<u32>();
pub(crate) const ALL_NOTIFY_FILTERS: u32 = FILE_NOTIFY_CHANGE_FILE_NAME
| FILE_NOTIFY_CHANGE_DIR_NAME
| FILE_NOTIFY_CHANGE_ATTRIBUTES
| FILE_NOTIFY_CHANGE_SIZE
| FILE_NOTIFY_CHANGE_LAST_WRITE
| FILE_NOTIFY_CHANGE_CREATION
| FILE_NOTIFY_CHANGE_SECURITY;
struct ReadBuffer {
words: Box<[u32]>,
}
impl ReadBuffer {
fn new(bytes: usize) -> Self {
let words = bytes.div_ceil(BYTES_PER_WORD).max(1);
Self {
words: vec![0_u32; words].into_boxed_slice(),
}
}
fn as_mut_ptr(&mut self) -> *mut core::ffi::c_void {
self.words.as_mut_ptr().cast()
}
fn byte_len(&self) -> u32 {
let bytes = self.words.len() * BYTES_PER_WORD;
u32::try_from(bytes).expect("the completion buffer is sized in this crate and fits a u32")
}
fn filled(&self, len: usize) -> &[u8] {
let bytes = self.words.len() * BYTES_PER_WORD;
let len = len.min(bytes);
unsafe { std::slice::from_raw_parts(self.words.as_ptr().cast::<u8>(), len) }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArmGate {
Open,
Backpressured,
Reopening,
Faulted,
VolumeChangePending,
TornDown,
}
struct FaultState {
operation: FaultOperation,
awaiting: HashSet<WatchId>,
earliest: Duration,
detail: FaultDetail,
}
struct VolumeChangeState {
handle: DirectoryHandle,
awaiting: HashSet<WatchId>,
decisions: HashMap<WatchId, VolumeChangeDecision>,
}
enum Endpoint {
Detailed(ThreadpoolIo),
Coarse(ThreadpoolWait),
}
struct WatcherInner {
path: PathBuf,
endpoint: Mutex<Option<Endpoint>>,
resume_work: OnceLock<ThreadpoolWork>,
retry_timer: OnceLock<ThreadpoolTimer>,
filter: u32,
buffer_bytes: usize,
routes: Mutex<HashMap<WatchId, Route>>,
gate: Mutex<ArmGate>,
fault: Mutex<Option<FaultState>>,
stopped: Mutex<Option<io::Error>>,
force_coarse: AtomicBool,
directory_id: Mutex<DirectoryId>,
volume_identity: Mutex<Option<VolumeIdentity>>,
resident: OnceLock<Weak<Mutex<Resident>>>,
volume_change: Mutex<Option<VolumeChangeState>>,
case_sensitive: AtomicBool,
reopen_lock: Mutex<()>,
}
impl WatcherInner {
fn arm(self: &Arc<Self>) -> Result<(), io::Error> {
let mut gate = self
.gate
.lock()
.unwrap_or_else(|poison| poison.into_inner());
if matches!(*gate, ArmGate::TornDown | ArmGate::Reopening) {
return Ok(());
}
self.arm_locked(&mut gate)
}
fn arm_after_install(self: &Arc<Self>) -> Result<(), io::Error> {
let mut gate = self
.gate
.lock()
.unwrap_or_else(|poison| poison.into_inner());
if *gate == ArmGate::TornDown {
return Ok(());
}
self.arm_locked(&mut gate)
}
fn resume_arm(self: &Arc<Self>) {
let mut gate = self
.gate
.lock()
.unwrap_or_else(|poison| poison.into_inner());
if *gate != ArmGate::Backpressured {
return;
}
if let Err(error) = self.arm_locked(&mut gate) {
drop(gate);
self.enter_fault(classify_detail(&error), FaultOperation::Arm);
}
}
fn arm_locked(self: &Arc<Self>, gate: &mut ArmGate) -> Result<(), io::Error> {
if !self.any_route_has_room() {
*gate = ArmGate::Backpressured;
if !self.any_route_has_room() {
return Ok(());
}
}
*gate = ArmGate::Open;
let endpoint_guard = lock(&self.endpoint);
match endpoint_guard.as_ref() {
Some(Endpoint::Detailed(io)) => self.arm_detailed_read(io),
Some(Endpoint::Coarse(wait)) => {
wait.arm(None);
Ok(())
}
None => {
Err(io::Error::other("the watcher's endpoint is not yet set"))
}
}
}
fn arm_detailed_read(&self, io: &ThreadpoolIo) -> Result<(), io::Error> {
let mut operation = Operation::new(ReadBuffer::new(self.buffer_bytes));
let buffer_ptr = operation.payload_mut().as_mut_ptr();
let buffer_len = operation.payload().byte_len();
let filter = self.filter;
let subtree = i32::from({
let routes = lock(&self.routes);
routes
.values()
.any(|route| route.scope.needs_kernel_subtree())
});
let submitted = unsafe {
io.submit(operation, |handle, overlapped| {
let ok = ReadDirectoryChangesW(
handle.as_raw_handle(),
buffer_ptr,
buffer_len,
subtree,
filter,
std::ptr::null_mut(),
overlapped,
None,
);
classify_submission(ok, io::Error::last_os_error)
})
};
match submitted {
Submitted::Pending(_) => Ok(()),
Submitted::Completed { .. } => Ok(()),
Submitted::Failed { error, .. } => Err(error),
}
}
fn on_completion(self: &Arc<Self>, completion: &IoCompletion) {
let operation = unsafe { completion.claim::<ReadBuffer>() };
if let Some(error) = completion.error() {
if error.raw_os_error() == Some(OPERATION_ABORTED) {
return;
}
self.enter_fault(classify_detail(&error), FaultOperation::Arm);
return;
}
if let Err(error) = self.arm() {
self.enter_fault(classify_detail(&error), FaultOperation::Arm);
}
let transferred = completion.bytes_transferred();
let batch = decode_batch(operation.payload().filled(transferred));
self.publish(batch);
}
fn on_activation(self: &Arc<Self>, activation: &WaitActivation<'_>) {
let reset = unsafe { FindNextChangeNotification(activation.handle().as_raw_handle()) };
if reset == 0 {
self.enter_fault(
classify_detail(&io::Error::last_os_error()),
FaultOperation::Arm,
);
return;
}
if let Err(error) = self.arm() {
self.enter_fault(classify_detail(&error), FaultOperation::Arm);
return;
}
self.publish(DecodedBatch::Desync(DesyncCause::Coarse));
}
fn publish(&self, batch: DecodedBatch) {
let routes = lock(&self.routes);
let case_sensitive = self.case_sensitive.load(Ordering::Relaxed);
match batch {
DecodedBatch::Changes(changes) if changes.is_empty() => {}
DecodedBatch::Changes(changes) => {
for route in routes.values() {
let matched = route.select(&changes, case_sensitive);
if matched.is_empty() {
continue;
}
let _ = route.sink.send(Notification::Batch {
watch: route.watch,
changes: matched,
});
}
}
DecodedBatch::Desync(cause) => {
for route in routes.values() {
let _ = route.sink.send(Notification::Desync {
watch: route.watch,
cause,
});
}
}
}
}
fn any_route_has_room(&self) -> bool {
lock(&self.routes)
.values()
.any(|route| route.sink.has_room())
}
fn enter_fault(self: &Arc<Self>, detail: FaultDetail, operation: FaultOperation) {
{
let mut gate = lock(&self.gate);
if *gate == ArmGate::TornDown {
return;
}
*gate = ArmGate::Faulted;
}
log::warn!("windows-file-watcher: {operation:?} failed, recovering: {detail:?}");
let routes = lock(&self.routes);
let mut awaiting = HashSet::new();
for route in routes.values() {
if route.report_liveness {
let _ = route
.sink
.send(Notification::Suspended { watch: route.watch });
}
if route.retry == RetryMode::Interactive && route.fault_slot.is_some() {
awaiting.insert(route.watch);
}
}
let nobody_asked = awaiting.is_empty();
*lock(&self.fault) = Some(FaultState {
operation,
awaiting,
earliest: operation.default_delay(),
detail,
});
for route in routes.values() {
if route.retry == RetryMode::Interactive
&& let Some(slot) = &route.fault_slot
{
slot.send(Notification::RetryQuestion {
watch: route.watch,
operation,
detail,
});
}
}
drop(routes);
if nobody_asked {
self.resolve_and_schedule(operation.default_delay());
}
}
fn answer(&self, watch: WatchId, delay: Option<Duration>) {
let resolved = {
let mut fault = lock(&self.fault);
let Some(state) = fault.as_mut() else {
return;
};
if !state.awaiting.remove(&watch) {
return;
}
let candidate = delay.unwrap_or_else(|| state.operation.default_delay());
if candidate < state.earliest {
state.earliest = candidate;
}
state.awaiting.is_empty().then_some(state.earliest)
};
if let Some(delay) = resolved {
self.resolve_and_schedule(delay);
}
}
fn resolve_and_schedule(&self, delay: Duration) {
if let Some(timer) = self.retry_timer.get() {
timer.set_after(clamp(delay));
}
}
fn retry_reestablish(self: &Arc<Self>) {
if *lock(&self.gate) == ArmGate::TornDown {
return;
}
match DirectoryHandle::open(&self.path) {
Ok(handle) => self.on_path_based_reopen(handle),
Err(open_error) => {
if open_error.failure().is_retryable() {
self.enter_fault(open_error.detail(), FaultOperation::Open);
} else {
self.record_stop(io::Error::other(open_error));
}
}
}
}
fn finish_reopen(self: &Arc<Self>, handle: DirectoryHandle) {
match self.install(handle) {
Ok(()) => self.resolve_fault_success(),
Err(error) => self.enter_fault(classify_detail(&error), FaultOperation::Arm),
}
}
fn on_path_based_reopen(self: &Arc<Self>, handle: DirectoryHandle) {
let new_id = handle.identity();
let old_id = std::mem::replace(&mut *lock(&self.directory_id), new_id);
if new_id != old_id
&& let Some(resident) = self.resident.get().and_then(Weak::upgrade)
{
rekey(&resident, old_id, new_id);
}
let previous_volume = lock(&self.volume_identity).clone();
let current_volume = handle.volume_identity().ok();
let changed = matches!(
(&previous_volume, ¤t_volume),
(Some(previous), Some(current)) if previous != current
);
if !changed {
self.finish_reopen(handle);
return;
}
let previous_volume = previous_volume.expect("checked above");
let current_volume = current_volume.expect("checked above");
let routes = lock(&self.routes);
let awaiting: HashSet<WatchId> = routes
.values()
.filter(|route| {
route.on_volume_change == VolumeChangePolicy::Confirm && route.fault_slot.is_some()
})
.map(|route| route.watch)
.collect();
if awaiting.is_empty() {
drop(routes);
log::warn!(
"windows-file-watcher: {:?} reopened on a different volume than before, and now \
resolves to {:?}",
self.path,
handle.canonical_path().ok()
);
self.finish_reopen(handle);
return;
}
{
let mut gate = lock(&self.gate);
if *gate == ArmGate::TornDown {
return;
}
*gate = ArmGate::VolumeChangePending;
}
*lock(&self.volume_change) = Some(VolumeChangeState {
handle,
awaiting: awaiting.clone(),
decisions: HashMap::new(),
});
for route in routes.values() {
if awaiting.contains(&route.watch)
&& let Some(slot) = &route.fault_slot
{
slot.send(Notification::VolumeChanged {
watch: route.watch,
previous: previous_volume.clone(),
current: current_volume.clone(),
});
}
}
drop(routes);
}
fn answer_volume_change(
self: &Arc<Self>,
watch: WatchId,
decision: VolumeChangeDecision,
) -> Option<(usize, Vec<WatchId>)> {
let ready = {
let mut state = lock(&self.volume_change);
let pending = state.as_mut()?;
if !pending.awaiting.remove(&watch) {
return None;
}
pending.decisions.insert(watch, decision);
pending.awaiting.is_empty()
};
ready.then(|| self.resolve_volume_change())
}
fn remove_route_from_volume_change(
self: &Arc<Self>,
watch: WatchId,
) -> Option<(usize, Vec<WatchId>)> {
let ready = {
let mut state = lock(&self.volume_change);
let pending = state.as_mut()?;
if !pending.awaiting.remove(&watch) {
return None;
}
pending.awaiting.is_empty()
};
ready.then(|| self.resolve_volume_change())
}
fn resolve_volume_change(self: &Arc<Self>) -> (usize, Vec<WatchId>) {
let pending = lock(&self.volume_change)
.take()
.expect("called only once awaiting has just emptied, with state present");
let stopped: Vec<WatchId> = pending
.decisions
.iter()
.filter(|(_, decision)| **decision == VolumeChangeDecision::Stop)
.map(|(watch, _)| *watch)
.collect();
{
let mut routes = lock(&self.routes);
for watch in &stopped {
routes.remove(watch);
}
}
let remaining = lock(&self.routes).len();
if remaining == 0 {
drop(pending.handle);
return (0, stopped);
}
self.finish_reopen(pending.handle);
(remaining, stopped)
}
fn resolve_fault_success(&self) {
*lock(&self.fault) = None;
log::info!("windows-file-watcher: recovery succeeded, re-established");
let mode = self.mode();
self.publish(DecodedBatch::Desync(DesyncCause::Reestablished));
let routes = lock(&self.routes);
for route in routes.values() {
if route.report_liveness {
let _ = route
.sink
.send(Notification::Resumed { watch: route.watch });
let _ = route.sink.send(Notification::Established {
watch: route.watch,
mode,
});
}
}
}
fn mode(&self) -> WatchMode {
match lock(&self.endpoint).as_ref() {
Some(Endpoint::Coarse(_)) => WatchMode::Coarse,
_ => WatchMode::Detailed,
}
}
fn teardown_endpoint(&self) {
let endpoint = lock(&self.endpoint).take();
match endpoint {
Some(Endpoint::Detailed(old)) => {
let _ = old.cancel_all();
old.run_down();
}
Some(Endpoint::Coarse(old)) => old.stop_and_drain(),
None => {}
}
}
fn establish_detailed(self: &Arc<Self>, handle: DirectoryHandle) -> io::Result<()> {
let weak = Arc::downgrade(self);
let endpoint = unsafe { UnassociatedEndpoint::assume_overlapped(handle.into_handle()) };
let io = ThreadpoolIo::new(
endpoint,
move |completion: &IoCompletion| {
let Some(inner) = weak.upgrade() else {
drop(unsafe { completion.claim::<ReadBuffer>() });
return;
};
inner.on_completion(completion);
},
None,
)?;
*lock(&self.endpoint) = Some(Endpoint::Detailed(io));
Ok(())
}
fn establish_coarse(self: &Arc<Self>) -> io::Result<()> {
let subtree = lock(&self.routes)
.values()
.any(|route| route.scope.needs_kernel_subtree());
let coarse =
CoarseHandle::open(&self.path, subtree, self.filter).map_err(io::Error::other)?;
let weak = Arc::downgrade(self);
let waitable = unsafe { coarse.into_waitable() };
let wait = ThreadpoolWait::new(
waitable,
move |activation: &WaitActivation<'_>| {
let Some(inner) = weak.upgrade() else {
return;
};
inner.on_activation(activation);
},
None,
)?;
*lock(&self.endpoint) = Some(Endpoint::Coarse(wait));
Ok(())
}
fn install(self: &Arc<Self>, handle: DirectoryHandle) -> io::Result<()> {
let _reopen_guard = self
.reopen_lock
.lock()
.unwrap_or_else(|poison| poison.into_inner());
{
let mut gate = lock(&self.gate);
if *gate == ArmGate::TornDown {
return Ok(());
}
*gate = ArmGate::Reopening;
}
self.teardown_endpoint();
if self.force_coarse.load(Ordering::Relaxed) {
drop(handle);
} else {
if let Ok(identity) = handle.volume_identity() {
*lock(&self.volume_identity) = Some(identity);
}
self.case_sensitive
.store(handle.is_case_sensitive(), Ordering::Relaxed);
self.establish_detailed(handle)?;
match self.arm_after_install() {
Ok(()) => return Ok(()),
Err(error) if classify(&error) == OpenFailure::Unsupported => {
log::warn!(
"windows-file-watcher: detailed watching unsupported, downgrading to coarse: {error}"
);
self.teardown_endpoint();
}
Err(error) => return Err(error),
}
}
self.establish_coarse()?;
self.arm_after_install()
}
fn record_stop(&self, error: io::Error) {
let mut stopped = lock(&self.stopped);
if stopped.is_none() {
*stopped = Some(error);
drop(stopped);
*lock(&self.fault) = None;
self.publish(DecodedBatch::Desync(DesyncCause::Stopped));
}
}
}
const OPERATION_ABORTED: i32 = windows_sys::Win32::Foundation::ERROR_OPERATION_ABORTED as i32;
impl Resume for WatcherInner {
fn resume(&self) {
if let Some(work) = self.resume_work.get() {
work.submit();
}
}
}
impl Drop for WatcherInner {
fn drop(&mut self) {
self.teardown_endpoint();
if let Some(work) = self.resume_work.get() {
work.stop_and_drain();
}
if let Some(timer) = self.retry_timer.get() {
timer.stop_and_drain();
}
}
}
pub struct DirectoryWatcher {
inner: Arc<WatcherInner>,
}
impl DirectoryWatcher {
pub(crate) fn start(
directory: DirectoryHandle,
path: PathBuf,
route: Route,
) -> Result<Self, (io::Error, Route)> {
Self::start_with(directory, path, DEFAULT_BUFFER_BYTES, route)
}
pub(crate) fn start_with(
directory: DirectoryHandle,
path: PathBuf,
buffer_bytes: usize,
route: Route,
) -> Result<Self, (io::Error, Route)> {
Self::start_inner(directory, path, buffer_bytes, route, false)
}
#[cfg(test)]
pub(crate) fn start_forcing_coarse(
directory: DirectoryHandle,
path: PathBuf,
route: Route,
) -> Result<Self, (io::Error, Route)> {
Self::start_inner(directory, path, DEFAULT_BUFFER_BYTES, route, true)
}
fn start_inner(
directory: DirectoryHandle,
path: PathBuf,
buffer_bytes: usize,
route: Route,
force_coarse: bool,
) -> Result<Self, (io::Error, Route)> {
let watch = route.watch;
let initial_sink = route.sink.clone();
let mut routes = HashMap::new();
routes.insert(watch, route);
let initial_id = directory.identity();
let inner = Arc::new(WatcherInner {
path,
endpoint: Mutex::new(None),
resume_work: OnceLock::new(),
retry_timer: OnceLock::new(),
filter: ALL_NOTIFY_FILTERS,
buffer_bytes,
routes: Mutex::new(routes),
gate: Mutex::new(ArmGate::Open),
fault: Mutex::new(None),
stopped: Mutex::new(None),
force_coarse: AtomicBool::new(force_coarse),
directory_id: Mutex::new(initial_id),
volume_identity: Mutex::new(None),
resident: OnceLock::new(),
volume_change: Mutex::new(None),
case_sensitive: AtomicBool::new(false),
reopen_lock: Mutex::new(()),
});
let reclaim_route = |inner: &Arc<WatcherInner>| -> Route {
lock(&inner.routes)
.remove(&watch)
.expect("the route inserted above is still the map's only entry")
};
let resuming = Arc::downgrade(&inner);
let resume_work = match ThreadpoolWork::new(
move || {
if let Some(inner) = resuming.upgrade() {
inner.resume_arm();
}
},
None,
) {
Ok(work) => work,
Err(error) => return Err((error, reclaim_route(&inner))),
};
inner
.resume_work
.set(resume_work)
.unwrap_or_else(|_| unreachable!("the resume work is set exactly once, here"));
let retrying = Arc::downgrade(&inner);
let retry_timer = match ThreadpoolTimer::new(
move |_firing| {
if let Some(inner) = retrying.upgrade() {
inner.retry_reestablish();
}
},
None,
) {
Ok(timer) => timer,
Err(error) => return Err((error, reclaim_route(&inner))),
};
inner
.retry_timer
.set(retry_timer)
.unwrap_or_else(|_| unreachable!("the retry timer is set exactly once, here"));
initial_sink.register_resume(&inner);
if let Err(error) = inner.install(directory) {
return Err((error, reclaim_route(&inner)));
}
Ok(Self { inner })
}
pub(crate) fn add_route(&self, route: Route, fresh_handle: DirectoryHandle) {
let widen = route.scope.needs_kernel_subtree();
let watch = route.watch;
let sink = route.sink.clone();
let already_recursive = {
let mut routes = lock(&self.inner.routes);
let already = routes
.values()
.any(|existing| existing.scope.needs_kernel_subtree());
routes.insert(watch, route);
already
};
sink.register_resume(&self.inner);
if widen
&& !already_recursive
&& self.gate() == ArmGate::Open
&& let Err(error) = self.inner.install(fresh_handle)
{
self.inner
.enter_fault(classify_detail(&error), FaultOperation::Arm);
}
}
pub(crate) fn remove_route(&self, watch: WatchId) -> (usize, Vec<WatchId>) {
let remaining = {
let mut routes = lock(&self.inner.routes);
routes.remove(&watch);
routes.len()
};
let resolved = {
let mut fault = lock(&self.inner.fault);
match fault.as_mut() {
Some(state) => {
if state.awaiting.remove(&watch) && state.awaiting.is_empty() {
Some(state.earliest)
} else {
None
}
}
None => None,
}
};
if let Some(delay) = resolved {
self.inner.resolve_and_schedule(delay);
}
if let Some((remaining, stopped)) = self.inner.remove_route_from_volume_change(watch) {
return (remaining, stopped);
}
(remaining, Vec::new())
}
pub(crate) fn answer(&self, watch: WatchId, delay: Option<Duration>) {
self.inner.answer(watch, delay);
}
pub(crate) fn answer_volume_change(
&self,
watch: WatchId,
decision: VolumeChangeDecision,
) -> Option<(usize, Vec<WatchId>)> {
self.inner.answer_volume_change(watch, decision)
}
pub fn stop_reason(&self) -> Option<io::Error> {
lock(&self.inner.stopped).as_ref().map(|error| {
error.raw_os_error().map_or_else(
|| io::Error::other("watcher stopped"),
io::Error::from_raw_os_error,
)
})
}
pub fn is_watching(&self) -> bool {
lock(&self.inner.stopped).is_none() && self.gate() != ArmGate::TornDown
}
#[must_use]
pub fn is_faulted(&self) -> bool {
lock(&self.inner.fault).is_some()
}
#[must_use]
pub fn fault_detail(&self) -> Option<FaultDetail> {
lock(&self.inner.fault).as_ref().map(|state| state.detail)
}
#[cfg(test)]
pub(crate) fn enter_fault_for_test(&self, detail: FaultDetail, operation: FaultOperation) {
self.inner.enter_fault(detail, operation);
}
#[cfg(test)]
pub(crate) fn record_stop_for_test(&self, error: io::Error) {
self.inner.record_stop(error);
}
#[cfg(test)]
pub(crate) fn simulate_volume_change_for_test(&self, previous: VolumeIdentity) {
*lock(&self.inner.volume_identity) = Some(previous);
self.inner.retry_reestablish();
}
#[must_use]
pub(crate) fn mode(&self) -> WatchMode {
self.inner.mode()
}
pub(crate) fn bind_resident(&self, resident: Weak<Mutex<Resident>>) {
let _ = self.inner.resident.set(resident);
}
pub(crate) fn path(&self) -> &Path {
&self.inner.path
}
pub(crate) fn take_routes(&self) -> Vec<Route> {
std::mem::take(&mut *lock(&self.inner.routes))
.into_values()
.collect()
}
pub fn gate(&self) -> ArmGate {
*lock(&self.inner.gate)
}
pub fn stop(&self) {
{
let mut gate = lock(&self.inner.gate);
*gate = ArmGate::TornDown;
}
if let Some(timer) = self.inner.retry_timer.get() {
timer.stop_and_drain();
}
self.inner.teardown_endpoint();
}
}
impl std::fmt::Debug for DirectoryWatcher {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DirectoryWatcher")
.field("watching", &self.is_watching())
.finish_non_exhaustive()
}
}
impl Drop for DirectoryWatcher {
fn drop(&mut self) {
self.stop();
}
}
fn classify_submission<F>(returned: i32, last_error: F) -> Result<Issued, io::Error>
where
F: FnOnce() -> io::Error,
{
if returned != 0 {
return Ok(Issued::Pending);
}
let error = last_error();
if error.raw_os_error() == Some(ERROR_IO_PENDING as i32) {
return Ok(Issued::Pending);
}
Err(error)
}
fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
mutex.lock().unwrap_or_else(|poison| poison.into_inner())
}
#[cfg(test)]
mod tests;