`2fae700`

add graceful shutdown on SIGINT, release all overlays on exit

Authored by

espadonne 1 month ago

SHA: 2fae700a74e9d9ea07568d949fa24e5720bfb814
Parents: ffb609e
Tree: 8b9beb9

3 changed files

Status	File	+	-
M	`Cargo.toml`	1	0
M	`src/main.rs`	35	4
M	`src/skylight.rs`	2	0

Cargo.tomlmodified

  description = "Window border renderer for tarmac"
  [dependencies]
 +libc = "0.2"
  serde = { version = "1", features = ["derive"] }
  serde_json = "1"
  tracing = "0.1"

src/main.rsmodified

  use skylight::*;
  use std::collections::HashMap;
  use std::ptr;
 +use std::sync::atomic::{AtomicBool, Ordering};
  use std::sync::mpsc;
 +use std::sync::Arc;
  /// Per-overlay state: the connection it was created on + its wid.
  struct Overlay {
+         }
+     }
 +    fn remove_all(&mut self) {
 +        let wids: Vec<u32> = self.overlays.keys().copied().collect();
 +        for wid in wids {
 +            self.remove(wid);
 +        }
 +    }
++
      fn remove(&mut self, target_wid: u32) {
          if let Some(overlay) = self.overlays.remove(&target_wid) {
              unsafe {
      eprintln!("{} overlays tracked", borders.overlays.len());
 +    // SIGINT flag — background thread checks this to clean up
 +    let running = Arc::new(AtomicBool::new(true));
 +    unsafe {
 +        libc::signal(libc::SIGINT, {
 +            unsafe extern "C" fn handler(_: libc::c_int) {
 +                // Stop CFRunLoop on main thread — this returns control to main()
 +                CFRunLoopStop(CFRunLoopGetMain());
 +            }
 +            handler as libc::sighandler_t
 +        });
 +    }
++
      // Process events on background thread with coalescing
 -    std::thread::spawn(move || {
 +    let running_bg = Arc::clone(&running);
 +    let handle = std::thread::spawn(move || {
          use std::collections::HashSet;
 +        use std::time::Duration;
          // Persist across batches: windows we know about but haven't bordered yet
          let mut pending: HashSet<u32> = HashSet::new();
 -        loop {
 -            let first = match rx.recv() {
 +        while running_bg.load(Ordering::Relaxed) {
 +            let first = match rx.recv_timeout(Duration::from_millis(100)) {
                  Ok(e) => e,
 -                Err(_) => break,
 +                Err(mpsc::RecvTimeoutError::Timeout) => continue,
 +                Err(mpsc::RecvTimeoutError::Disconnected) => break,
              };
              std::thread::sleep(std::time::Duration::from_millis(16));
              // After all processing, enforce active-only visibility
              borders.enforce_active_only();
+         }
++
 +        // Clean up all overlays before exiting
 +        borders.remove_all();
      });
      unsafe { CFRunLoopRun() };
++
 +    // SIGINT received — signal background thread to stop and wait
 +    running.store(false, Ordering::Relaxed);
 +    let _ = handle.join();
+ }
  fn setup_event_port(cid: CGSConnectionID) {

src/skylight.rsmodified

      ) -> CFRunLoopSourceRef;
      pub fn CFRunLoopGetCurrent() -> CFRunLoopRef;
 +    pub fn CFRunLoopGetMain() -> CFRunLoopRef;
      pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFStringRef);
      pub fn CFRunLoopRun();
 +    pub fn CFRunLoopStop(rl: CFRunLoopRef);
      pub static kCFAllocatorDefault: CFAllocatorRef;
      pub static kCFTypeDictionaryKeyCallBacks: c_void;