join router threads on exit

zellij-client/src/lib.rs

@@ -241,12 +241,10 @@ pub fn start_client(
         err_ctx.add_call(ContextType::Client((&client_instruction).into()));
         match client_instruction {
             ClientInstruction::Exit(reason) => {
-                match reason {
+                os_input.send_to_server(ClientToServerMsg::ClientExited);
-                    ExitReason::Error(_) => handle_error(format!("{}", reason)),
+
-                    ExitReason::ForceDetached => {
+                if let ExitReason::Error(_) = reason {
-                        os_input.send_to_server(ClientToServerMsg::ClientDetached);
+                    handle_error(format!("{}", reason));
-                    }
-                    _ => {}
                 }
                 exit_msg = format!("{}", reason);
                 break;

zellij-server/src/lib.rs

@@ -11,7 +11,7 @@ mod wasm_vm;
 
 use zellij_utils::zellij_tile;
 
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
 use std::{path::PathBuf, sync::mpsc};
 use wasmer::Store;
@@ -132,7 +132,10 @@ pub fn start_server(os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
         })
     });
 
+    let thread_handles = Arc::new(Mutex::new(Vec::new()));
+
     #[cfg(any(feature = "test", test))]
+    thread_handles.lock().unwrap().push(
         thread::Builder::new()
             .name("server_router".to_string())
             .spawn({
@@ -143,7 +146,8 @@ pub fn start_server(os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
 
                 move || route_thread_main(session_data, session_state, os_input, to_server)
             })
-        .unwrap();
+            .unwrap(),
+    );
     #[cfg(not(any(feature = "test", test)))]
     let _ = thread::Builder::new()
         .name("server_listener".to_string())
@@ -157,6 +161,7 @@ pub fn start_server(os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
             let session_state = session_state.clone();
             let to_server = to_server.clone();
             let socket_path = socket_path.clone();
+            let thread_handles = thread_handles.clone();
             move || {
                 drop(std::fs::remove_file(&socket_path));
                 let listener = LocalSocketListener::bind(&*socket_path).unwrap();
@@ -169,6 +174,7 @@ pub fn start_server(os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
                             let session_data = session_data.clone();
                             let session_state = session_state.clone();
                             let to_server = to_server.clone();
+                            thread_handles.lock().unwrap().push(
                                 thread::Builder::new()
                                     .name("server_router".to_string())
                                     .spawn({
@@ -185,7 +191,8 @@ pub fn start_server(os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
                                             )
                                         }
                                     })
-                                .unwrap();
+                                    .unwrap(),
+                            );
                         }
                         Err(err) => {
                             panic!("err {:?}", err);
@@ -274,6 +281,11 @@ pub fn start_server(os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
             }
         }
     }
+    thread_handles
+        .lock()
+        .unwrap()
+        .drain(..)
+        .for_each(|h| drop(h.join()));
     #[cfg(not(any(feature = "test", test)))]
     drop(std::fs::remove_file(&socket_path));
 }

zellij-server/src/route.rs

@@ -233,20 +233,20 @@ pub(crate) fn route_thread_main(
                     os_input.send_to_temp_client(ServerToClientMsg::Exit(ExitReason::Error(
                         "Cannot add new client".into(),
                     )));
-                    break;
+                } else {
-                }
                     os_input.add_client_sender();
                     to_server.send(instruction.into()).unwrap();
                 }
+            }
             ClientToServerMsg::AttachClient(_, force) => {
                 if *session_state.read().unwrap() == SessionState::Attached && !force {
                     os_input.send_to_temp_client(ServerToClientMsg::Exit(ExitReason::CannotAttach));
-                    break;
+                } else {
-                }
                     os_input.add_client_sender();
                     to_server.send(instruction.into()).unwrap();
                 }
-            ClientToServerMsg::ClientDetached => break,
+            }
+            ClientToServerMsg::ClientExited => break,
         }
     }
 }

zellij-utils/src/ipc.rs

@@ -59,7 +59,7 @@ pub enum ClientToServerMsg {
     NewClient(ClientAttributes, Box<CliArgs>, Box<Options>),
     AttachClient(ClientAttributes, bool),
     Action(Action),
-    ClientDetached,
+    ClientExited,
 }
 
 // Types of messages sent from the server to the client