1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
//! Blocking file watching
use crate::{util, Error, Event};
use notify::Watcher as _;
use std::{
collections::HashMap,
path::{Path, PathBuf},
sync::mpsc::{channel, Receiver},
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Flow {
/// Continue watching and blocking the thread.
Continue,
/// Stop watching, returning control of the thread.
Exit,
}
impl Default for Flow {
fn default() -> Self {
Self::Continue
}
}
/// A blocking hotwatch instance.
///
/// No watching will actually happen until you call [`Hotwatch::run`], which blocks
/// the thread until a handler returns [`Flow::Exit`]. This is useful if you just
/// want to wait on some criteria, rather than if you're building some long-running
/// sexy hot reload service.
///
/// Dropping this will unwatch everything.
pub struct Hotwatch {
watcher: notify::RecommendedWatcher,
handlers: HashMap<PathBuf, Box<dyn FnMut(Event) -> Flow>>,
rx: Receiver<Event>,
}
impl std::fmt::Debug for Hotwatch {
fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
fmt.debug_struct("Hotwatch").finish()
}
}
impl Hotwatch {
/// Creates a new blocking hotwatch instance.
///
/// # Errors
///
/// This will fail if the underlying [notify](https://docs.rs/notify/4.0/notify/)
/// instance fails to initialize.
///
/// # Examples
///
/// ```
/// use hotwatch::blocking::Hotwatch;
///
/// let hotwatch = Hotwatch::new().expect("hotwatch failed to initialize");
/// ```
pub fn new() -> Result<Self, Error> {
Self::new_with_custom_delay(std::time::Duration::from_secs(2))
}
/// Using [`Hotwatch::new`] will give you a default delay of 2 seconds.
/// This method allows you to specify your own value.
///
/// # Notes
///
/// A delay of over 30 seconds will prevent repetitions of previous events on macOS.
pub fn new_with_custom_delay(delay: std::time::Duration) -> Result<Self, Error> {
let (tx, rx) = channel();
let watcher = notify::Watcher::new(tx, delay).map_err(Error::Notify)?;
Ok(Self {
watcher,
handlers: Default::default(),
rx,
})
}
/// Watch a path and register a handler to it.
///
/// Handlers won't actually be run until you call [`Hotwatch::run`].
///
/// When watching a directory, that handler will receive all events for all directory
/// contents, even recursing through subdirectories.
///
/// Only the most specific applicable handler will be called. In other words, if you're
/// watching "dir" and "dir/file1", then only the latter handler will fire for changes to
/// `file1`.
///
/// # Errors
///
/// Watching will fail if the path can't be read, returning [`Error::Io`].
///
/// # Examples
///
/// ```
/// use hotwatch::{blocking::{Flow, Hotwatch}, Event};
///
/// let mut hotwatch = Hotwatch::new().expect("hotwatch failed to initialize!");
/// // Note that this won't actually do anything until you call `hotwatch.run()`!
/// hotwatch.watch("README.md", |event: Event| {
/// if let Event::Write(path) = event {
/// println!("{:?} changed!", path);
/// Flow::Exit
/// } else {
/// Flow::Continue
/// }
/// }).expect("failed to watch file!");
/// ```
pub fn watch<P, F>(&mut self, path: P, handler: F) -> Result<(), Error>
where
P: AsRef<Path>,
F: 'static + FnMut(Event) -> Flow,
{
let absolute_path = path.as_ref().canonicalize()?;
self.watcher
.watch(&absolute_path, notify::RecursiveMode::Recursive)?;
self.handlers.insert(absolute_path, Box::new(handler));
Ok(())
}
/// Stop watching a path.
///
/// # Errors
///
/// This will fail if the path wasn't being watched, or if the path
/// couldn't be unwatched for some platform-specific internal reason.
pub fn unwatch<P: AsRef<Path>>(&mut self, path: P) -> Result<(), Error> {
let absolute_path = path.as_ref().canonicalize()?;
self.watcher.unwatch(&absolute_path)?;
self.handlers.remove(&absolute_path);
Ok(())
}
/// Run handlers in an endless loop, blocking the thread.
///
/// The loop will only exit if a handler returns [`Flow::Exit`].
pub fn run(&mut self) {
loop {
match self.rx.recv() {
Ok(event) => {
util::log_event(&event);
if let Some(handler) = util::handler_for_event(&event, &mut self.handlers) {
if let Flow::Exit = handler(event) {
break;
}
}
}
Err(_) => {
util::log_dead();
break;
}
}
}
}
}