itsi-server 0.2.17 → 0.2.19

data/ext/itsi_server/src/ruby_types/itsi_server/file_watcher.rs

@@ -1,69 +1,136 @@
 use derive_more::Debug;
 use globset::{Glob, GlobSet, GlobSetBuilder};
 use magnus::error::Result;
-use nix::unistd::{close, fork, pipe, read};
+use nix::unistd::{close, dup, fork, pipe, read, write};
 use notify::event::ModifyKind;
-use notify::{Event, RecursiveMode, Watcher};
-use notify::{EventKind, RecommendedWatcher};
+use notify::{Event, EventKind, RecursiveMode, Watcher};
+use parking_lot::Mutex;
+use std::collections::{HashMap, HashSet};
+use std::fs;
+use std::os::fd::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 use std::path::Path;
-use std::sync::mpsc::Sender;
+use std::path::PathBuf;
+use std::process::Command;
+
+use std::sync::{mpsc, Arc};
+use std::thread;
 use std::time::{Duration, Instant};
-use std::{collections::HashSet, fs};
-use std::{
-    os::fd::{AsRawFd, IntoRawFd, OwnedFd},
-    path::PathBuf,
-    process::Command,
-    sync::mpsc,
-    thread::{self},
-};
-use tracing::debug;
-
-/// Represents a set of patterns and commands.
+use tracing::{error, info};
+
 #[derive(Debug, Clone)]
 struct PatternGroup {
     base_dir: PathBuf,
     glob_set: GlobSet,
-    pattern: String,
     commands: Vec<Vec<String>>,
+    pattern: String,
     last_triggered: Option<Instant>,
 }
 
-/// Extracts the base directory from a wildcard pattern by taking the portion up to the first
-/// component that contains a wildcard character.
-fn extract_and_canonicalize_base_dir(pattern: &str) -> PathBuf {
-    if !(pattern.contains("*") || pattern.contains("?") || pattern.contains('[')) {
-        let base = PathBuf::from(".");
-        return fs::canonicalize(&base).unwrap_or(base);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum WatcherCommand {
+    Stop,
+    ConfigError,
+    Continue,
+}
+
+#[derive(Debug)]
+pub struct WatcherPipes {
+    pub read_fd: OwnedFd,
+    pub write_fd: OwnedFd,
+}
+
+impl AsRawFd for WatcherPipes {
+    fn as_raw_fd(&self) -> RawFd {
+        self.read_fd.as_raw_fd()
     }
+}
+
+impl Drop for WatcherPipes {
+    fn drop(&mut self) {
+        let _ = send_watcher_command(&self.write_fd, WatcherCommand::Stop);
+        let _ = close(self.read_fd.as_raw_fd());
+        let _ = close(self.write_fd.as_raw_fd());
+    }
+}
 
+fn extract_and_canonicalize_base_dir(pattern: &str) -> (PathBuf, String) {
     let path = Path::new(pattern);
     let mut base = PathBuf::new();
+    let mut remaining_components = Vec::new();
+    let mut found_glob = false;
+
     for comp in path.components() {
         let comp_str = comp.as_os_str().to_string_lossy();
-        if comp_str.contains('*') || comp_str.contains('?') || comp_str.contains('[') {
-            break;
+        if !found_glob
+            && (comp_str.contains('*') || comp_str.contains('?') || comp_str.contains('['))
+        {
+            found_glob = true;
+            remaining_components.push(comp_str.to_string());
+        } else if found_glob {
+            remaining_components.push(comp_str.to_string());
         } else {
             base.push(comp);
         }
     }
-    // If no base was built, default to "."
-    let base = if base.as_os_str().is_empty() || !base.exists() {
+
+    let base = if base.as_os_str().is_empty() {
         PathBuf::from(".")
     } else {
         base
     };
+    let base = fs::canonicalize(&base).unwrap_or(base);
+    let remaining_pattern = remaining_components.join("/");
 
-    fs::canonicalize(&base).unwrap_or(base)
+    (base, remaining_pattern)
 }
 
-/// Minimum time between triggering the same pattern group (debounce time)
-const DEBOUNCE_DURATION: Duration = Duration::from_millis(2000);
+const DEBOUNCE_DURATION: Duration = Duration::from_millis(300);
+const EVENT_DEDUP_DURATION: Duration = Duration::from_millis(50);
+const AUTO_RECOVERY_TIMEOUT: Duration = Duration::from_secs(5);
+
+fn serialize_command(cmd: WatcherCommand) -> u8 {
+    match cmd {
+        WatcherCommand::Stop => 0,
+        WatcherCommand::ConfigError => 1,
+        WatcherCommand::Continue => 2,
+    }
+}
+
+fn deserialize_command(byte: u8) -> Option<WatcherCommand> {
+    match byte {
+        0 => Some(WatcherCommand::Stop),
+        1 => Some(WatcherCommand::ConfigError),
+        2 => Some(WatcherCommand::Continue),
+        _ => None,
+    }
+}
+
+pub fn send_watcher_command(fd: &OwnedFd, cmd: WatcherCommand) -> Result<()> {
+    let buf = [serialize_command(cmd)];
+    match write(fd, &buf) {
+        Ok(_) => Ok(()),
+        Err(e) => Err(magnus::Error::new(
+            magnus::exception::standard_error(),
+            format!("Failed to send command to watcher: {}", e),
+        )),
+    }
+}
+
+pub fn watch_groups(
+    pattern_groups: Vec<(String, Vec<Vec<String>>)>,
+) -> Result<Option<WatcherPipes>> {
+    // Create bidirectional pipes for communication
+    let (parent_read_fd, child_write_fd): (OwnedFd, OwnedFd) = pipe().map_err(|e| {
+        magnus::Error::new(
+            magnus::exception::standard_error(),
+            format!("Failed to create parent read pipe: {}", e),
+        )
+    })?;
 
-pub fn watch_groups(pattern_groups: Vec<(String, Vec<Vec<String>>)>) -> Result<Option<OwnedFd>> {
-    let (r_fd, w_fd): (OwnedFd, OwnedFd) = pipe().map_err(|e| {
+    let (child_read_fd, parent_write_fd): (OwnedFd, OwnedFd) = pipe().map_err(|e| {
         magnus::Error::new(
             magnus::exception::standard_error(),
-            format!("Failed to create watcher pipe: {}", e),
+            format!("Failed to create child read pipe: {}", e),
         )
     })?;
 
@@ -77,17 +144,41 @@ pub fn watch_groups(pattern_groups: Vec<(String, Vec<Vec<String>>)>) -> Result<O
     }?;
 
     if fork_result.is_child() {
-        let _ = close(w_fd.into_raw_fd());
+        // Child process - close the parent ends of the pipes
+        let _ = close(parent_read_fd.into_raw_fd());
+        let _ = close(parent_write_fd.into_raw_fd());
+
+        let _child_read_fd_clone =
+            unsafe { OwnedFd::from_raw_fd(dup(child_read_fd.as_raw_fd()).unwrap()) };
+        let child_write_fd_clone =
+            unsafe { OwnedFd::from_raw_fd(dup(child_write_fd.as_raw_fd()).unwrap()) };
+
+        let command_channel = Arc::new(Mutex::new(None));
+        let command_channel_clone = command_channel.clone();
+
+        // Thread to read commands from parent
         thread::spawn(move || {
             let mut buf = [0u8; 1];
             loop {
-                match read(r_fd.as_raw_fd(), &mut buf) {
+                match read(child_read_fd.as_raw_fd(), &mut buf) {
                     Ok(0) => {
+                        info!("Parent closed command pipe, exiting watcher");
                         std::process::exit(0);
                     }
-                    Ok(_) => {}
-                    Err(_) => {
-                        std::process::exit(0);
+                    Ok(_) => {
+                        if let Some(cmd) = deserialize_command(buf[0]) {
+                            info!("Received command from parent: {:?}", cmd);
+                            *command_channel_clone.lock() = Some(cmd);
+
+                            if matches!(cmd, WatcherCommand::Stop) {
+                                info!("Received stop command, exiting watcher");
+                                std::process::exit(0);
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        error!("Error reading from command pipe: {}", e);
+                        std::process::exit(1);
                     }
                 }
             }
@@ -95,11 +186,19 @@ pub fn watch_groups(pattern_groups: Vec<(String, Vec<Vec<String>>)>) -> Result<O
 
         let mut groups = Vec::new();
         for (pattern, commands) in pattern_groups.into_iter() {
-            let base_dir = extract_and_canonicalize_base_dir(&pattern);
-            let glob = Glob::new(pattern.trim_start_matches("./")).map_err(|e| {
+            let (base_dir, remaining_pattern) = extract_and_canonicalize_base_dir(&pattern);
+            info!(
+                "Watching base directory {:?} with pattern {:?} (original: {:?})",
+                base_dir, remaining_pattern, pattern
+            );
+
+            let glob = Glob::new(&remaining_pattern).map_err(|e| {
                 magnus::Error::new(
                     magnus::exception::standard_error(),
-                    format!("Failed to create watch glob: {}", e),
+                    format!(
+                        "Failed to create watch glob for pattern '{}': {}",
+                        remaining_pattern, e
+                    ),
                 )
             })?;
             let glob_set = GlobSetBuilder::new().add(glob).build().map_err(|e| {
@@ -108,117 +207,339 @@ pub fn watch_groups(pattern_groups: Vec<(String, Vec<Vec<String>>)>) -> Result<O
                     format!("Failed to create watch glob set: {}", e),
                 )
             })?;
+
             groups.push(PatternGroup {
                 base_dir,
                 glob_set,
-                pattern,
                 commands,
+                pattern: remaining_pattern,
                 last_triggered: None,
             });
         }
 
-        // Create a channel and a watcher.
+        // Create a channel and a watcher
         let (tx, rx) = mpsc::channel::<notify::Result<Event>>();
+        let startup_time = Instant::now();
         let sender = tx.clone();
-        fn event_fn(sender: Sender<notify::Result<Event>>) -> impl Fn(notify::Result<Event>) {
-            move |res| match res {
-                Ok(event) => {
-                    sender.send(Ok(event)).unwrap();
-                }
-                Err(e) => println!("watch error: {:?}", e),
+
+        let event_fn = move |res: notify::Result<Event>| {
+            if let Ok(event) = res {
+                sender.send(Ok(event)).unwrap_or_else(|e| {
+                    error!("Failed to send event: {}", e);
+                });
+            } else if let Err(e) = res {
+                error!("Watch error: {:?}", e);
             }
-        }
+        };
+
+        let mut watched_paths = HashSet::new();
+        let mut watcher = notify::recommended_watcher(event_fn).expect("Failed to create watcher");
 
-        let mut watched_dirs = HashSet::new();
-        let mut watcher: RecommendedWatcher =
-            notify::recommended_watcher(event_fn(sender)).expect("Failed to create watcher");
         for group in &groups {
-            if watched_dirs.insert(group.base_dir.clone()) {
-                debug!("Watching {}/{}", group.base_dir.display(), group.pattern);
+            if watched_paths.insert(group.base_dir.clone()) {
+                let recursive = if group.pattern.is_empty() {
+                    RecursiveMode::NonRecursive
+                } else {
+                    RecursiveMode::Recursive
+                };
+
                 watcher
-                    .watch(&group.base_dir, RecursiveMode::Recursive)
+                    .watch(&group.base_dir, recursive)
                     .expect("Failed to add watch");
             }
         }
 
-        debug!("Monitored groups {:?}", groups.len());
-        // Main event loop.
+        // Wait briefly to avoid initial event storm
+        thread::sleep(Duration::from_millis(100));
+
+        // State management
+        let mut recent_events: HashMap<(PathBuf, EventKind), Instant> = HashMap::new();
+        let restart_state = Arc::new(Mutex::new(None::<Instant>));
+
+        // Main event loop
         for res in rx {
             match res {
                 Ok(event) => {
                     if !matches!(event.kind, EventKind::Modify(ModifyKind::Data(_))) {
                         continue;
                     }
-                    debug!("Event fired {:?}", event);
+
                     let now = Instant::now();
+
+                    // Skip startup events
+                    if now.duration_since(startup_time) < Duration::from_millis(500) {
+                        continue;
+                    }
+
+                    // Deduplicate events
+                    let mut should_process = true;
+                    for path in &event.paths {
+                        let event_key = (path.clone(), event.kind);
+                        if let Some(&last_seen) = recent_events.get(&event_key) {
+                            if now.duration_since(last_seen) < EVENT_DEDUP_DURATION {
+                                should_process = false;
+                                break;
+                            }
+                        }
+                        recent_events.insert(event_key, now);
+                    }
+
+                    if !should_process {
+                        continue;
+                    }
+
+                    // Clean up old entries
+                    recent_events
+                        .retain(|_, &mut time| now.duration_since(time) < Duration::from_secs(1));
+
+                    // Check restart state
+                    let should_skip = {
+                        let state = restart_state.lock();
+                        if let Some(restart_time) = *state {
+                            now.duration_since(restart_time) < Duration::from_millis(500)
+                        } else {
+                            false
+                        }
+                    };
+
+                    if should_skip {
+                        continue;
+                    }
+
+                    // Process commands from parent
+                    let command_to_process = {
+                        let mut command_guard = command_channel.lock();
+                        let cmd = *command_guard;
+                        *command_guard = None;
+                        cmd
+                    };
+
+                    if let Some(cmd) = command_to_process {
+                        match cmd {
+                            WatcherCommand::ConfigError => {
+                                info!("Received config error notification, resuming file watching");
+                                *restart_state.lock() = None;
+                                for group in &mut groups {
+                                    group.last_triggered = None;
+                                }
+                                recent_events.clear();
+                            }
+                            WatcherCommand::Continue => {
+                                info!("Received continue notification, resuming file watching");
+                                *restart_state.lock() = None;
+                            }
+                            WatcherCommand::Stop => { /* Handled in command thread */ }
+                        }
+                    }
+
+                    // Process file events
                     for group in &mut groups {
+                        // Apply debounce
+                        if let Some(last_triggered) = group.last_triggered {
+                            if now.duration_since(last_triggered) < DEBOUNCE_DURATION {
+                                continue;
+                            }
+                        }
+
                         for path in event.paths.iter() {
-                            if let Ok(rel_path) = path.strip_prefix(&group.base_dir) {
-                                if group.glob_set.is_match(rel_path)
-                                    || rel_path.to_str().is_some_and(|s| s == group.pattern)
-                                {
-                                    debug!("Matched pattern: {:?}", group.pattern);
-                                    // Check if we should debounce this event
-                                    if let Some(last_triggered) = group.last_triggered {
-                                        if now.duration_since(last_triggered) < DEBOUNCE_DURATION {
-                                            // Skip this event as we've recently triggered for this pattern
-                                            continue;
-                                        }
+                            let matches = if group.pattern.is_empty() {
+                                path == &group.base_dir
+                            } else if let Ok(rel_path) = path.strip_prefix(&group.base_dir) {
+                                group.glob_set.is_match(rel_path)
+                            } else {
+                                false
+                            };
+
+                            if matches {
+                                group.last_triggered = Some(now);
+
+                                // Execute commands
+                                for command in &group.commands {
+                                    if command.is_empty() {
+                                        continue;
                                     }
 
-                                    // Update the last triggered time
-                                    group.last_triggered = Some(now);
+                                    // Check for shell command or restart/reload
+                                    let is_shell_command = command.len() == 1
+                                        && (command[0].contains("&&")
+                                            || command[0].contains("||")
+                                            || command[0].contains("|")
+                                            || command[0].contains(";"));
+
+                                    let is_restart = command
+                                        .windows(2)
+                                        .any(|w| w[0] == "itsi" && w[1] == "restart")
+                                        || (is_shell_command
+                                            && command[0].contains("itsi restart"));
+
+                                    let is_reload = command
+                                        .windows(2)
+                                        .any(|w| w[0] == "itsi" && w[1] == "reload")
+                                        || (is_shell_command && command[0].contains("itsi reload"));
+
+                                    // Handle restart/reload
+                                    if is_restart || is_reload {
+                                        let cmd_type =
+                                            if is_restart { "restart" } else { "reload" };
+                                        let mut should_run = false;
+
+                                        {
+                                            let mut state = restart_state.lock();
+                                            if let Some(last_time) = *state {
+                                                if now.duration_since(last_time)
+                                                    < Duration::from_secs(3)
+                                                {
+                                                    info!(
+                                                        "Ignoring {} command - too soon",
+                                                        cmd_type
+                                                    );
+                                                } else {
+                                                    *state = Some(now);
+                                                    should_run = true;
+                                                }
+                                            } else {
+                                                *state = Some(now);
+                                                should_run = true;
+                                            }
+                                        }
 
-                                    // Execute the commands for this group.
-                                    for command in &group.commands {
-                                        if command.is_empty() {
+                                        if !should_run {
                                             continue;
                                         }
+
+                                        // Notify parent (optional)
+                                        let _ = write(&child_write_fd_clone, &[3]);
+                                    }
+
+                                    // Build and execute command
+                                    let mut cmd = if is_shell_command {
+                                        let mut shell_cmd = Command::new("sh");
+                                        shell_cmd.arg("-c").arg(command.join(" "));
+                                        shell_cmd
+                                    } else {
                                         let mut cmd = Command::new(&command[0]);
                                         if command.len() > 1 {
                                             cmd.args(&command[1..]);
                                         }
-                                        debug!(
-                                            "Executing command: {:?} due to change in {:?}",
-                                            command, path
-                                        );
-                                        match cmd.spawn() {
-                                            Ok(mut child) => {
-                                                if let Err(e) = child.wait() {
-                                                    eprintln!(
-                                                        "Command {:?} failed: {:?}",
-                                                        command, e
-                                                    );
-                                                }
+                                        cmd
+                                    };
+
+                                    match cmd.spawn() {
+                                        Ok(mut child) => {
+                                            if let Err(e) = child.wait() {
+                                                error!("Command {:?} failed: {:?}", command, e);
                                             }
-                                            Err(e) => {
-                                                eprintln!(
-                                                    "Failed to execute command {:?}: {:?}",
-                                                    command, e
-                                                );
+
+                                            if is_restart || is_reload {
+                                                info!("Itsi command submitted, waiting for parent response");
+
+                                                // Set auto-recovery timer
+                                                let restart_state_clone =
+                                                    Arc::clone(&restart_state);
+                                                let now_clone = now;
+                                                thread::spawn(move || {
+                                                    thread::sleep(AUTO_RECOVERY_TIMEOUT);
+                                                    let mut state = restart_state_clone.lock();
+                                                    if let Some(restart_time) = *state {
+                                                        if now_clone.duration_since(restart_time)
+                                                            < Duration::from_secs(1)
+                                                        {
+                                                            info!("Auto-recovering from potential restart failure");
+                                                            *state = None;
+                                                        }
+                                                    }
+                                                });
                                             }
                                         }
+                                        Err(e) => {
+                                            error!(
+                                                "Failed to execute command {:?}: {:?}",
+                                                command, e
+                                            );
+                                        }
                                     }
-                                    break;
                                 }
+                                break;
                             }
                         }
                     }
                 }
-                Err(e) => println!("Watch error: {:?}", e),
+                Err(e) => error!("Watch error: {:?}", e),
             }
         }
 
-        // Clean up the watches.
-        for group in &groups {
-            watcher
-                .unwatch(&group.base_dir)
-                .expect("Failed to remove watch");
-        }
+        // Clean up
         drop(watcher);
         std::process::exit(0);
     } else {
-        let _ = close(r_fd.into_raw_fd());
-        Ok(Some(w_fd))
+        // Parent process - close the child ends of the pipes
+        let _ = close(child_read_fd.into_raw_fd());
+        let _ = close(child_write_fd.into_raw_fd());
+
+        // Create a paired structure to return
+        let watcher_pipes = WatcherPipes {
+            read_fd: parent_read_fd,
+            write_fd: parent_write_fd,
+        };
+
+        Ok(Some(watcher_pipes))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::env;
+
+    use super::*;
+
+    #[test]
+    fn test_extract_patterns() {
+        // Save current dir to restore later
+        let original_dir = env::current_dir().unwrap();
+
+        // Create a temp dir and work from there for consistent results
+        let temp_dir = env::temp_dir().join("itsi_test_patterns");
+        let _ = fs::create_dir_all(&temp_dir);
+        env::set_current_dir(&temp_dir).unwrap();
+
+        // Test glob patterns
+        let (base, pattern) = extract_and_canonicalize_base_dir("assets/*/**.tsx");
+        assert!(base.ends_with("assets"));
+        assert_eq!(pattern, "*/**.tsx");
+
+        let (base, pattern) = extract_and_canonicalize_base_dir("./assets/*/**.tsx");
+        assert!(base.ends_with("assets"));
+        assert_eq!(pattern, "*/**.tsx");
+
+        // Test non-glob patterns - exact files should have empty pattern
+        let (base, pattern) = extract_and_canonicalize_base_dir("foo/bar.txt");
+        assert!(base.ends_with("bar.txt"));
+        assert_eq!(pattern, "");
+
+        // Test current directory patterns
+        let (base, pattern) = extract_and_canonicalize_base_dir("*.txt");
+        assert_eq!(base, temp_dir.canonicalize().unwrap());
+        assert_eq!(pattern, "*.txt");
+
+        // Test file in current directory
+        let (base, pattern) = extract_and_canonicalize_base_dir("test.txt");
+        assert!(base.ends_with("test.txt"));
+        assert_eq!(pattern, "");
+
+        // Restore original directory and clean up
+        env::set_current_dir(original_dir).unwrap();
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    fn test_watcher_commands() {
+        assert_eq!(serialize_command(WatcherCommand::Stop), 0);
+        assert_eq!(serialize_command(WatcherCommand::ConfigError), 1);
+        assert_eq!(serialize_command(WatcherCommand::Continue), 2);
+
+        assert_eq!(deserialize_command(0), Some(WatcherCommand::Stop));
+        assert_eq!(deserialize_command(1), Some(WatcherCommand::ConfigError));
+        assert_eq!(deserialize_command(2), Some(WatcherCommand::Continue));
+        assert_eq!(deserialize_command(99), None);
     }
 }