itsi-scheduler 0.2.17 → 0.2.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fdc8a1856e4a8a91bd48b9feeaf5bd352b5c6f2f2def8bf7fcc99abf997224f
-  data.tar.gz: b7d66f0141c268c5d126ce620813f0f2651ccb49d25a18cdeb2bb9ff4ff892e4
+  metadata.gz: fac0124df4d981948e915496a34f6d508c9d8c68fc13286d7a6400927e2cd3d1
+  data.tar.gz: 860ac83fee517bdef9291ba85119bca438e3c21ed04b1cac759f3e8d86a3cc39
 SHA512:
-  metadata.gz: 8711a0865c3c15e91425450155b426a136791ffa4fa9d2a4713ea6d0774cc072cb9015fd2f90f99e8a39ff3d6acf206ecd3369692a8c3603293b466913c73cb3
-  data.tar.gz: b557b5137f60bcda9569015decf8a47b802e15fc025f930281f5090ca068412efd70c016ee5cd4351923a934ccdb0bf6bdb9b2e9288ede643d75c974b2a901d3
+  metadata.gz: 6a8d221f21d7dba3cea0659e350b378534ac1720471c2d132e85402920940065e0fca70fecaba35890654ec57da91283090ad7b771f4dcd016ee5c057e99aeae
+  data.tar.gz: a0ac27575945761c81cc0c613da84fb7c8efd1be5d3aed3f3db4436668994d1d838ab29f49e578bf50c2f70c1aa86c456863ce36cf64ee0c3db4a1aadef542a3

data/Cargo.lock

@@ -213,7 +213,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "itsi-scheduler"
-version = "0.2.17"
+version = "0.2.18"
 dependencies = [
  "bytes",
  "derive_more",

data/ext/itsi_scheduler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-scheduler"
-version = "0.2.17"
+version = "0.2.18"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"

data/ext/itsi_server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-server"
-version = "0.2.17"
+version = "0.2.18"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"

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);
     }
 }

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

@@ -1,4 +1,4 @@
-use super::file_watcher::{self};
+use super::file_watcher::{self, WatcherCommand};
 use crate::{
     ruby_types::ITSI_SERVER_CONFIG,
     server::{
@@ -9,7 +9,7 @@ use crate::{
 use derive_more::Debug;
 use itsi_error::ItsiError;
 use itsi_rb_helpers::{call_with_gvl, print_rb_backtrace, HeapValue};
-use itsi_tracing::{set_format, set_level, set_target, set_target_filters};
+use itsi_tracing::{error, set_format, set_level, set_target, set_target_filters};
 use magnus::{
     block::Proc,
     error::Result,
@@ -18,12 +18,12 @@ use magnus::{
 };
 use nix::{
     fcntl::{fcntl, FcntlArg, FdFlag},
-    unistd::{close, dup},
+    unistd::dup,
 };
 use parking_lot::{Mutex, RwLock};
 use std::{
     collections::HashMap,
-    os::fd::{AsRawFd, OwnedFd, RawFd},
+    os::fd::RawFd,
     path::PathBuf,
     str::FromStr,
     sync::{
@@ -32,7 +32,7 @@ use std::{
     },
     time::Duration,
 };
-use tracing::{debug, error};
+use tracing::debug;
 static DEFAULT_BIND: &str = "http://localhost:3000";
 static ID_BUILD_CONFIG: LazyId = LazyId::new("build_config");
 static ID_RELOAD_EXEC: LazyId = LazyId::new("reload_exec");
@@ -44,7 +44,7 @@ pub struct ItsiServerConfig {
     pub itsi_config_proc: Arc<Option<HeapValue<Proc>>>,
     #[debug(skip)]
     pub server_params: Arc<RwLock<Arc<ServerParams>>>,
-    pub watcher_fd: Arc<Option<OwnedFd>>,
+    pub watcher_fd: Arc<Option<file_watcher::WatcherPipes>>,
 }
 
 #[derive(Debug)]
@@ -84,7 +84,7 @@ pub struct ServerParams {
     listener_info: Mutex<HashMap<String, i32>>,
     pub itsi_server_token_preference: ItsiServerTokenPreference,
     pub preloaded: AtomicBool,
-    socket_opts: SocketOpts,
+    pub socket_opts: SocketOpts,
     preexisting_listeners: Option<String>,
 }
 
@@ -442,6 +442,10 @@ impl ItsiServerConfig {
         }
     }
 
+    pub fn use_reuse_port_load_balancing(&self) -> bool {
+        cfg!(target_os = "linux") && self.server_params.read().socket_opts.reuse_port
+    }
+
     /// Reload
     pub fn reload(self: Arc<Self>, cluster_worker: bool) -> Result<bool> {
         let server_params = call_with_gvl(|ruby| {
@@ -553,6 +557,9 @@ impl ItsiServerConfig {
     }
 
     pub fn dup_fds(self: &Arc<Self>) -> Result<()> {
+        // Ensure the watcher is already stopped before duplicating file descriptors
+        // to prevent race conditions between closing the watcher FD and duplicating socket FDs
+
         let binding = self.server_params.read();
         let mut listener_info_guard = binding.listener_info.lock();
         let dupped_fd_map = listener_info_guard
@@ -578,8 +585,10 @@ impl ItsiServerConfig {
     }
 
     pub fn stop_watcher(self: &Arc<Self>) -> Result<()> {
-        if let Some(r_fd) = self.watcher_fd.as_ref() {
-            close(r_fd.as_raw_fd()).ok();
+        if let Some(pipes) = self.watcher_fd.as_ref() {
+            // Send explicit stop command to the watcher process
+            file_watcher::send_watcher_command(&pipes.write_fd, WatcherCommand::Stop)?;
+            // We don't close the pipes here - they'll be closed when the WatcherPipes is dropped
         }
         Ok(())
     }
@@ -594,8 +603,24 @@ impl ItsiServerConfig {
     pub async fn check_config(&self) -> bool {
         if let Some(errors) = self.get_config_errors().await {
             Self::print_config_errors(errors);
+            // Notify watcher that config check failed
+            if let Some(pipes) = self.watcher_fd.as_ref() {
+                if let Err(e) =
+                    file_watcher::send_watcher_command(&pipes.write_fd, WatcherCommand::ConfigError)
+                {
+                    error!("Failed to notify watcher of config error: {}", e);
+                }
+            }
             return false;
         }
+        // If we reach here, the config is valid
+        if let Some(pipes) = self.watcher_fd.as_ref() {
+            if let Err(e) =
+                file_watcher::send_watcher_command(&pipes.write_fd, WatcherCommand::Continue)
+            {
+                error!("Failed to notify watcher to continue: {}", e);
+            }
+        }
         true
     }
 
@@ -609,7 +634,8 @@ impl ItsiServerConfig {
                     )
                 })?;
 
-        self.stop_watcher()?;
+        // Make sure we're not calling stop_watcher here to avoid double-stopping
+        // The watcher should be stopped earlier in the restart sequence
         call_with_gvl(|ruby| -> Result<()> {
             ruby.get_inner_ref(&ITSI_SERVER_CONFIG)
                 .funcall::<_, _, Value>(*ID_RELOAD_EXEC, (listener_json,))?;

data/ext/itsi_server/src/server/binds/listener.rs

@@ -304,16 +304,16 @@ impl Listener {
         connect_tcp_socket(ip, port, &socket_opts).unwrap()
     }
 
-    pub fn into_tokio_listener(self, no_rebind: bool) -> TokioListener {
+    pub fn into_tokio_listener(self, should_rebind: bool) -> TokioListener {
         match self {
             Listener::Tcp(mut listener) => {
-                if cfg!(target_os = "linux") && !no_rebind {
+                if should_rebind {
                     listener = Listener::rebind_listener(listener);
                 }
                 TokioListener::Tcp(TokioTcpListener::from_std(listener).unwrap())
             }
             Listener::TcpTls((mut listener, acceptor)) => {
-                if cfg!(target_os = "linux") && !no_rebind {
+                if should_rebind {
                     listener = Listener::rebind_listener(listener);
                 }
                 TokioListener::TcpTls(

data/ext/itsi_server/src/server/serve_strategy/cluster_mode.rs

@@ -100,9 +100,11 @@ impl ClusterMode {
             LifecycleEvent::Restart => {
                 if self.server_config.check_config().await {
                     self.invoke_hook("before_restart");
+                    self.server_config.stop_watcher()?;
                     self.server_config.dup_fds()?;
                     self.shutdown().await.ok();
                     info!("Shutdown complete. Calling reload exec");
+
                     self.server_config.reload_exec()?;
                 }
                 Ok(())
@@ -111,8 +113,11 @@ impl ClusterMode {
                 if !self.server_config.check_config().await {
                     return Ok(());
                 }
+
                 let should_reexec = self.server_config.clone().reload(true)?;
+
                 if should_reexec {
+                    self.server_config.stop_watcher()?;
                     self.server_config.dup_fds()?;
                     self.shutdown().await.ok();
                     self.server_config.reload_exec()?;
@@ -321,15 +326,6 @@ impl ClusterMode {
             .iter()
             .try_for_each(|worker| worker.boot(Arc::clone(&self)))?;
 
-        if cfg!(target_os = "linux") {
-            self.server_config
-                .server_params
-                .write()
-                .listeners
-                .lock()
-                .drain(..);
-        };
-
         let (sender, mut receiver) = watch::channel(());
         *CHILD_SIGNAL_SENDER.lock() = Some(sender);
 

data/ext/itsi_server/src/server/serve_strategy/single_mode.rs

@@ -262,7 +262,14 @@ impl SingleMode {
         let shutdown_timeout = self.server_config.server_params.read().shutdown_timeout;
         let (shutdown_sender, _) = watch::channel(RunningPhase::Running);
         let monitor_thread = self.clone().start_monitors(thread_workers.clone());
+
+        // If we're on Linux with reuse_port enabled, we can use
+        // kernel level load balancing across processes sharing a port.
+        // To take advantage of this, these forks will rebind to the same port upon boot.
+        // Worker 0 is special (this one just inherits the bind from the master process).
         let is_zero_worker = self.is_zero_worker();
+        let should_rebind = !is_zero_worker && self.server_config.use_reuse_port_load_balancing();
+
         if monitor_thread.is_none() {
             error!("Failed to start monitor thread");
             return Err(ItsiError::new("Failed to start monitor thread"));
@@ -283,7 +290,7 @@ impl SingleMode {
                 .listeners
                 .lock()
                 .drain(..)
-                .map(|list| Arc::new(list.into_tokio_listener(is_zero_worker)))
+                .map(|list| Arc::new(list.into_tokio_listener(should_rebind)))
                 .collect::<Vec<_>>();
 
             tokio_listeners.iter().cloned().for_each(|listener| {
@@ -311,7 +318,7 @@ impl SingleMode {
                 let mut after_accept_wait: Option<Duration> = None::<Duration>;
 
                 if cfg!(target_os = "macos") {
-                    after_accept_wait = if server_params.workers > 1 {
+                    after_accept_wait = if server_params.workers > 1 && !(server_params.socket_opts.reuse_port && server_params.socket_opts.reuse_address) {
                         Some(Duration::from_nanos(10 * server_params.workers as u64))
                     } else {
                         None
@@ -434,6 +441,7 @@ impl SingleMode {
         if self.is_single_mode() {
             self.invoke_hook("before_restart");
         }
+        self.server_config.stop_watcher()?;
         self.server_config.dup_fds()?;
         self.server_config.reload_exec()?;
         Ok(())

data/lib/itsi/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Scheduler
-    VERSION = "0.2.17"
+    VERSION = "0.2.18"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: itsi-scheduler
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.2.18
 platform: ruby
 authors:
 - Wouter Coppieters