`242efe5`

feat(config): add garnotify auto-spawn integration

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 242efe581a0af45216921a554bed9eb251fd1a9d
Parents: b19cd1f
Tree: d7b12f0

5 changed files

Status	File	+	-
M	`Cargo.lock`	2	2
M	`gar/src/config/lua.rs`	28	2
M	`gar/src/config/mod.rs`	4	0
M	`gar/src/core/mod.rs`	3	0
M	`gar/src/x11/events.rs`	130	0

Cargo.lockmodified

  [[package]]
  name = "gar"
 -version = "0.2.0"
 +version = "0.3.0"
  dependencies = [
   "dirs",
   "libc",
  [[package]]
  name = "garctl"
 -version = "0.2.0"
 +version = "0.3.0"
  dependencies = [
   "clap",
   "serde",

gar/src/config/lua.rsmodified

          // Check if gar.bar table exists - enables garbar integration
          self.check_bar_config()?;
 +        // Check if gar.notification table exists - enables garnotify integration
 +        self.check_notification_config()?;
++
          let state = self.state.lock().unwrap();
          tracing::info!(
 -            "Config loaded: {} keybinds registered, bar_enabled={}",
 +            "Config loaded: {} keybinds registered, bar_enabled={}, notification_enabled={}",
              state.keybinds.len(),
 -            state.config.bar_enabled
 +            state.config.bar_enabled,
 +            state.config.notification_enabled
          );
          Ok(())
          Ok(())
+     }
 +    /// Check if gar.notification table is configured, enabling garnotify integration
 +    fn check_notification_config(&self) -> LuaResult<()> {
 +        let globals = self.lua.globals();
 +        let gar: Table = globals.get("gar")?;
++
 +        // Check if gar.notification exists and is a table
 +        match gar.get::<Table>("notification") {
 +            Ok(_) => {
 +                // gar.notification exists! Enable garnotify integration
 +                let mut state = self.state.lock().unwrap();
 +                state.config.notification_enabled = true;
 +                tracing::info!("garnotify integration enabled");
 +            }
 +            Err(_) => {
 +                // gar.notification not set, garnotify won't be auto-spawned
 +                tracing::debug!("gar.notification not configured, garnotify integration disabled");
 +            }
 +        }
++
 +        Ok(())
 +    }
++
      /// Reload configuration (clears existing keybinds and rules)
      pub fn reload(&self) -> LuaResult<()> {
+         {

gar/src/config/mod.rsmodified

      pub bar_height: u32,
      // garbar integration: spawn garbar automatically if gar.bar is configured
      pub bar_enabled: bool,
 +    // garnotify integration: spawn garnotify automatically if gar.notification is configured
 +    pub notification_enabled: bool,
      // Monitor ordering: list of monitor names in desired left-to-right order
      // If empty, monitors are sorted by X position (default)
      pub monitor_order: Vec<String>,
              bar_height: 0,
              // garbar not enabled by default (enabled when gar.bar table is set)
              bar_enabled: false,
 +            // garnotify not enabled by default (enabled when gar.notification table is set)
 +            notification_enabled: false,
              // Monitor order: empty = sort by X position
              monitor_order: Vec::new(),
              // Screen timeout: enabled by default with 10 minute timeout

gar/src/core/mod.rsmodified

      pub tiled_edge_cursor: Option<(XWindow, XWindow, Direction)>,
      /// garbar child process (managed automatically when gar.bar is configured)
      pub garbar_process: Option<std::process::Child>,
 +    /// garnotify child process (managed automatically when gar.notification is configured)
 +    pub garnotify_process: Option<std::process::Child>,
      /// Directional focus memory: (source_window, direction) -> last_target_window
      /// Used to remember which window was focused when navigating in a direction
      pub directional_focus_memory: HashMap<(XWindow, Direction), XWindow>,
              current_edge_cursor: None,
              tiled_edge_cursor: None,
              garbar_process: None,
 +            garnotify_process: None,
              directional_focus_memory: HashMap::new(),
          })
+     }

gar/src/x11/events.rsmodified

          libc::kill(child.id() as i32, libc::SIGHUP);
+     }
+ }
++
 +// ============================================================================
 +// garnotify integration - auto-spawn notification daemon
 +// ============================================================================
++
 +/// Get garnotify socket path
 +fn garnotify_socket_path() -> String {
 +    std::env::var("XDG_RUNTIME_DIR")
 +        .map(|dir| format!("{}/garnotify.sock", dir))
 +        .unwrap_or_else(|_| "/tmp/garnotify.sock".to_string())
 +}
++
 +/// Check if garnotify is healthy (socket exists)
 +fn is_garnotify_healthy() -> bool {
 +    std::path::Path::new(&garnotify_socket_path()).exists()
 +}
++
 +/// Spawn garnotify notification daemon
 +fn spawn_garnotify() -> Option<std::process::Child> {
 +    tracing::info!("Spawning garnotify...");
++
 +    // Try to find garnotify in PATH or common locations
 +    let garnotify_cmd = which_garnotify().unwrap_or_else(|| "garnotify".to_string());
++
 +    // Inherit DISPLAY from current environment
 +    let x_display = std::env::var("DISPLAY").unwrap_or_else(|_| ":0".to_string());
++
 +    match Command::new(&garnotify_cmd)
 +        .arg("daemon")
 +        .env("DISPLAY", &x_display)
 +        .spawn()
 +    {
 +        Ok(child) => {
 +            tracing::info!("garnotify started (PID {}), DISPLAY={}", child.id(), x_display);
++
 +            // Wait briefly and verify garnotify becomes healthy
 +            for attempt in 1..=10 {
 +                std::thread::sleep(std::time::Duration::from_millis(200));
 +                if is_garnotify_healthy() {
 +                    tracing::info!("garnotify socket ready after {}ms", attempt * 200);
 +                    return Some(child);
 +                }
 +            }
++
 +            // Socket never appeared - might still be starting up
 +            tracing::warn!("garnotify socket not ready after 2s, may still be starting");
 +            Some(child)
 +        }
 +        Err(e) => {
 +            tracing::error!("Failed to spawn garnotify: {}", e);
 +            tracing::info!("Hint: Ensure garnotify is installed and in PATH");
 +            None
 +        }
 +    }
 +}
++
 +/// Find garnotify executable
 +fn which_garnotify() -> Option<String> {
 +    // Check if garnotify is in PATH
 +    if Command::new("which")
 +        .arg("garnotify")
 +        .output()
 +        .map(|o| o.status.success())
 +        .unwrap_or(false)
 +    {
 +        return Some("garnotify".to_string());
 +    }
++
 +    // Check common cargo install location
 +    if let Ok(home) = std::env::var("HOME") {
 +        let cargo_bin = format!("{}/.cargo/bin/garnotify", home);
 +        if std::path::Path::new(&cargo_bin).exists() {
 +            return Some(cargo_bin);
 +        }
 +    }
++
 +    // Check /usr/local/bin
 +    if std::path::Path::new("/usr/local/bin/garnotify").exists() {
 +        return Some("/usr/local/bin/garnotify".to_string());
 +    }
++
 +    None
 +}
++
 +/// Stop garnotify gracefully by sending SIGTERM.
 +fn stop_garnotify(child: &mut std::process::Child) {
 +    tracing::info!("Stopping garnotify (PID {})...", child.id());
++
 +    // Send SIGTERM for graceful shutdown
 +    unsafe {
 +        libc::kill(child.id() as i32, libc::SIGTERM);
 +    }
++
 +    // Wait briefly for it to exit
 +    match child.try_wait() {
 +        Ok(Some(status)) => {
 +            tracing::info!("garnotify exited with status: {}", status);
 +        }
 +        Ok(None) => {
 +            std::thread::sleep(std::time::Duration::from_millis(100));
 +            match child.try_wait() {
 +                Ok(Some(status)) => {
 +                    tracing::info!("garnotify exited with status: {}", status);
 +                }
 +                Ok(None) => {
 +                    tracing::warn!("garnotify did not exit gracefully, sending SIGKILL");
 +                    let _ = child.kill();
 +                }
 +                Err(e) => {
 +                    tracing::warn!("Error waiting for garnotify: {}", e);
 +                }
 +            }
 +        }
 +        Err(e) => {
 +            tracing::warn!("Error checking garnotify status: {}", e);
 +        }
 +    }
 +}
++
  use x11rb::protocol::xproto::{
      ButtonPressEvent, ButtonReleaseEvent, ClientMessageEvent, ConfigureRequestEvent,
      ConfigureWindowAux, ConnectionExt, DestroyNotifyEvent, EnterNotifyEvent, EventMask,
              self.garbar_process = spawn_garbar();
+         }
 +        // Spawn garnotify if gar.notification is configured
 +        if self.config.notification_enabled {
 +            self.garnotify_process = spawn_garnotify();
 +        }
++
          while self.running {
              // Handle X11 events (non-blocking poll)
              while let Some(event) = self.conn.conn.poll_for_event()? {
+         }
          self.garbar_process = None;
 +        // Stop garnotify if it was spawned
 +        if let Some(ref mut child) = self.garnotify_process {
 +            stop_garnotify(child);
 +        }
 +        self.garnotify_process = None;
++
          // Kill picom to prevent compositor effects from bleeding into the greeter
          tracing::info!("Killing picom...");
          let _ = std::process::Command::new("pkill")