fix: use trailing-edge debounce for file watcher

Author: cablehead

Cargo.lock

@@ -57,7 +57,6 @@ chrono = "0.4"
 ipnet = "2"
 tower-http = { version = "0.6.6", features = ["fs"] }
 tower = { version = "0.5.2", features = ["util"] }
-ureq = { version = "2.12.1", default-features = false, features = ["tls"] }
 brotli = "8"
 http_encoding_headers = "0.2.0"
 headers = "0.4.1"
@@ -69,7 +68,6 @@ syntect = "5.3.0"
 syntect-assets = "0.23.6"
 pulldown-cmark = "0.12.2"
 notify = "8"
-notify-debouncer-mini = "0.6"
 
 [dependencies.cross-stream]
 version = "0.9.0"

Cargo.toml

@@ -160,46 +160,47 @@ fn spawn_file_watcher(script_path: PathBuf, tx: mpsc::Sender<String>) {
             .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);
+        let mut pending_reload = false;
+
+        loop {
+            let timeout = if pending_reload {
+                debounce
+            } else {
+                Duration::from_secs(86400)
+            };
 
-        for result in raw_rx {
-            match result {
-                Ok(event) => {
-                    // Only react to modifications, not access/open events
+            match raw_rx.recv_timeout(timeout) {
+                Ok(Ok(event)) => {
                     use notify::EventKind;
-                    let is_modification = matches!(
+                    let dominated_by = matches!(
                         event.kind,
                         EventKind::Create(_) | EventKind::Modify(_) | EventKind::Remove(_)
                     );
-                    if !is_modification {
-                        continue;
-                    }
-
-                    // Debounce rapid events
-                    if last_reload.elapsed() < debounce {
-                        continue;
+                    if dominated_by {
+                        pending_reload = true;
                     }
-                    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;
+                }
+                Ok(Err(e)) => {
+                    eprintln!("Watch error: {e:?}");
+                }
+                Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
+                    if pending_reload {
+                        pending_reload = false;
+                        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!("Error reading script file: {e}");
                         }
                     }
                 }
-                Err(e) => {
-                    eprintln!("Watch error: {e:?}");
+                Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
+                    break;
                 }
             }
         }

src/main.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