use std::io;
use std::path::Path;
use crate::monitor::Request;
use crate::queue::{Reservation, WatchId};
use crate::session::Session;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum RetryMode {
#[default]
Defaults,
Interactive,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum VolumeChangeDecision {
Continue,
Stop,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum VolumeChangePolicy {
#[default]
AutoContinue,
Confirm,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct WatchOptions {
pub subtree: bool,
pub retry: RetryMode,
pub report_liveness: bool,
pub on_volume_change: VolumeChangePolicy,
}
impl WatchOptions {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn subtree(mut self, subtree: bool) -> Self {
self.subtree = subtree;
self
}
#[must_use]
pub fn retry(mut self, retry: RetryMode) -> Self {
self.retry = retry;
self
}
#[must_use]
pub fn report_liveness(mut self, report_liveness: bool) -> Self {
self.report_liveness = report_liveness;
self
}
#[must_use]
pub fn on_volume_change(mut self, policy: VolumeChangePolicy) -> Self {
self.on_volume_change = policy;
self
}
}
#[must_use = "a Watch cancels its subscription when dropped, so discarding one here stops the watch immediately"]
#[derive(Debug)]
pub struct Watch {
id: WatchId,
session: Session,
cancellation: Option<Reservation>,
}
impl Watch {
pub(crate) fn new(id: WatchId, session: Session, cancellation: Reservation) -> Self {
Self {
id,
session,
cancellation: Some(cancellation),
}
}
#[must_use]
pub fn id(&self) -> WatchId {
self.id
}
pub fn cancel(mut self) {
self.enqueue_cancel();
}
fn enqueue_cancel(&mut self) {
let Some(completion) = self.cancellation.take() else {
return;
};
let _ = self.session.submit(Request::Cancel {
watch: self.id,
completion,
});
}
}
impl Drop for Watch {
fn drop(&mut self) {
self.enqueue_cancel();
}
}
pub(crate) fn subscribe(
session: &Session,
path: &Path,
options: WatchOptions,
) -> io::Result<Watch> {
let completion = session.sink().reserve().ok_or_else(saturated)?;
let cancellation = session.sink().reserve().ok_or_else(saturated)?;
let fault_slot = if options.retry == RetryMode::Interactive
|| options.on_volume_change == VolumeChangePolicy::Confirm
{
Some(session.sink().reserve_standing().ok_or_else(saturated)?)
} else {
None
};
let id = session.next_watch();
let request = Request::Subscribe {
watch: id,
path: path.to_path_buf(),
options,
sink: session.sink().clone(),
completion,
fault_slot,
};
session.submit(request).map_err(|_| {
io::Error::new(
io::ErrorKind::NotConnected,
"the monitor has shut down, so no new subscription can be registered",
)
})?;
Ok(Watch::new(id, session.clone(), cancellation))
}
fn saturated() -> io::Error {
io::Error::new(
io::ErrorKind::WouldBlock,
"the notification queue is full, so a subscription's completions cannot be guaranteed",
)
}
#[cfg(test)]
mod tests;