fix: use trailing-edge debounce for file watcher

Author: cablehead

src/main.rs

@@ -22,7 +22,7 @@ use hyper::service::service_fn;
 use hyper_util::rt::{TokioExecutor, TokioIo};
 use hyper_util::server::conn::auto::Builder as HttpConnectionBuilder;
 use hyper_util::server::graceful::GracefulShutdown;
-use notify::{RecursiveMode, Watcher};
+use notify::RecursiveMode;
 use tokio::signal;
 use tokio::sync::mpsc;
 
@@ -154,50 +154,27 @@ fn spawn_file_watcher(script_path: PathBuf, tx: mpsc::Sender<String>) {
 
         let (raw_tx, raw_rx) = std::sync::mpsc::channel();
 
-        let mut watcher = notify::recommended_watcher(raw_tx).expect("Failed to create watcher");
+        let mut debouncer =
+            notify_debouncer_mini::new_debouncer(Duration::from_millis(100), raw_tx)
+                .expect("Failed to create debouncer");
 
-        watcher
+        debouncer
+            .watcher()
             .watch(&watch_dir, RecursiveMode::Recursive)
             .expect("Failed to watch directory");
 
-        // Keep watcher alive
-        let _watcher = watcher;
-
-        // Set to past time so first event isn't debounced
-        let mut last_reload = std::time::Instant::now() - Duration::from_secs(1);
-        let debounce = Duration::from_millis(100);
-
         for result in raw_rx {
             match result {
-                Ok(event) => {
-                    // Only react to modifications, not access/open events
-                    use notify::EventKind;
-                    let is_modification = matches!(
-                        event.kind,
-                        EventKind::Create(_) | EventKind::Modify(_) | EventKind::Remove(_)
-                    );
-                    if !is_modification {
-                        continue;
-                    }
-
-                    // Debounce rapid events
-                    if last_reload.elapsed() < debounce {
-                        continue;
-                    }
-                    last_reload = std::time::Instant::now();
-
-                    // Re-read and send the script file
-                    match std::fs::read_to_string(&script_path) {
-                        Ok(content) => {
-                            if tx.blocking_send(content).is_err() {
-                                break;
-                            }
-                        }
-                        Err(e) => {
-                            eprintln!("Error reading script file: {e}");
+                Ok(_events) => match std::fs::read_to_string(&script_path) {
+                    Ok(content) => {
+                        if tx.blocking_send(content).is_err() {
+                            break;
                         }
                     }
-                }
+                    Err(e) => {
+                        eprintln!("Error reading script file: {e}");
+                    }
+                },
                 Err(e) => {
                     eprintln!("Watch error: {e:?}");
                 }

tests/server_test.rs

@@ -1435,10 +1435,15 @@ async fn test_watch_file_reload_on_change() {
         .expect("curl failed");
     assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "version1");
 
-    // Modify the script file
+    // Trigger a spurious event, then write the actual change.
+    // This tests trailing-edge debounce: the reload should wait for events to
+    // settle and read the final content, not the content at the first event.
+    let dummy_path = tmp.path().join("trigger.txt");
+    std::fs::write(&dummy_path, "trigger").unwrap();
+    tokio::time::sleep(std::time::Duration::from_millis(10)).await;
     std::fs::write(&script_path, r#"{|req| "version2"}"#).unwrap();
 
-    // Wait for file watcher to detect change and reload
+    // Wait for debounced reload to complete
     tokio::time::sleep(std::time::Duration::from_millis(500)).await;
 
     // Verify updated response