From 8176849dc355d57c83ee45e4bb2275902a03c363 Mon Sep 17 00:00:00 2001
From: LGUG2Z <LGUG2Z@fastmail.com>
Date: Wed, 15 May 2024 08:53:44 -0700
Subject: [PATCH] fix(wm): restart cmd processing thread on fail

This commit makes some changes to process_command and process_event to
bring them more in line with newer modules, while primarily making sure
that the thread spawned in process_command will be restarted if
necessary.

In the future I might pull out the process_command and process_event fns
from the WindowManager struct and have them take an
Arc<Mutex<WindowManager>> instead which acquires the lock on every call
like the reconciliators and border_manager do.
---
 komorebi/src/border_manager/border.rs |  2 --
 komorebi/src/process_command.rs       | 29 ++++++++++++++++++---------
 komorebi/src/process_event.rs         | 23 +++++++++------------
 komorebi/src/stackbar.rs              |  2 --
 4 files changed, 30 insertions(+), 26 deletions(-)

diff --git a/komorebi/src/border_manager/border.rs b/komorebi/src/border_manager/border.rs
index 882a44be..8038dde5 100644
--- a/komorebi/src/border_manager/border.rs
+++ b/komorebi/src/border_manager/border.rs
@@ -17,7 +17,6 @@ use komorebi_core::Rect;
 
 use std::sync::atomic::Ordering;
 use std::sync::mpsc;
-use std::time::Duration;
 use windows::core::PCWSTR;
 use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::COLORREF;
@@ -104,7 +103,6 @@ impl Border {
                 while GetMessageW(&mut message, HWND(hwnd), 0, 0).into() {
                     TranslateMessage(&message);
                     DispatchMessageW(&message);
-                    std::thread::sleep(Duration::from_millis(10));
                 }
             }
 
diff --git a/komorebi/src/process_command.rs b/komorebi/src/process_command.rs
index ca80b243..494c1cab 100644
--- a/komorebi/src/process_command.rs
+++ b/komorebi/src/process_command.rs
@@ -78,23 +78,34 @@ use crate::WORKSPACE_RULES;
 
 #[tracing::instrument]
 pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
-    let listener = wm
-        .lock()
-        .command_listener
-        .try_clone()
-        .expect("could not clone unix listener");
+    std::thread::spawn(move || loop {
+        let listener = wm
+            .lock()
+            .command_listener
+            .try_clone()
+            .expect("could not clone unix listener");
 
-    std::thread::spawn(move || {
         tracing::info!("listening on komorebi.sock");
+
+        // client is unique for every komorebic command
         for client in listener.incoming() {
             match client {
                 Ok(stream) => match read_commands_uds(&wm, stream) {
                     Ok(()) => {}
-                    Err(error) => tracing::error!("{}", error),
+                    Err(error) => {
+                        if cfg!(debug_assertions) {
+                            tracing::error!("{:?}", error)
+                        } else {
+                            tracing::error!("{}", error)
+                        }
+                    }
                 },
                 Err(error) => {
-                    tracing::error!("{}", error);
-                    break;
+                    if cfg!(debug_assertions) {
+                        tracing::error!("{:?}", error)
+                    } else {
+                        tracing::error!("{}", error)
+                    }
                 }
             }
         }
diff --git a/komorebi/src/process_event.rs b/komorebi/src/process_event.rs
index d0f40bf4..a708bf64 100644
--- a/komorebi/src/process_event.rs
+++ b/komorebi/src/process_event.rs
@@ -35,20 +35,17 @@ use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 
 #[tracing::instrument]
 pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
-    let receiver = wm.lock().incoming_events.clone();
-
-    std::thread::spawn(move || {
+    std::thread::spawn(move || loop {
         tracing::info!("listening");
-        loop {
-            if let Ok(event) = receiver.recv() {
-                match wm.lock().process_event(event) {
-                    Ok(()) => {}
-                    Err(error) => {
-                        if cfg!(debug_assertions) {
-                            tracing::error!("{:?}", error)
-                        } else {
-                            tracing::error!("{}", error)
-                        }
+        let receiver = wm.lock().incoming_events.clone();
+        for event in receiver {
+            match wm.lock().process_event(event) {
+                Ok(()) => {}
+                Err(error) => {
+                    if cfg!(debug_assertions) {
+                        tracing::error!("{:?}", error)
+                    } else {
+                        tracing::error!("{}", error)
                     }
                 }
             }
diff --git a/komorebi/src/stackbar.rs b/komorebi/src/stackbar.rs
index 71378e3a..86f0eb21 100644
--- a/komorebi/src/stackbar.rs
+++ b/komorebi/src/stackbar.rs
@@ -1,6 +1,5 @@
 use std::collections::VecDeque;
 use std::sync::atomic::Ordering;
-use std::time::Duration;
 
 use color_eyre::eyre::Result;
 use schemars::JsonSchema;
@@ -163,7 +162,6 @@ impl Stackbar {
                 while GetMessageW(&mut msg, hwnd, 0, 0).into() {
                     TranslateMessage(&msg);
                     DispatchMessageW(&msg);
-                    std::thread::sleep(Duration::from_millis(10));
                 }
             }