refactor: set_error take gui_state

insert into gui_state status when setting error

src/app_data/mod.rs

@@ -1,11 +1,12 @@
 use bollard::models::ContainerSummary;
+use parking_lot::Mutex;
 use core::fmt;
 use ratatui::widgets::{ListItem, ListState};
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::{time::{SystemTime, UNIX_EPOCH}, sync::Arc};
 
 mod container_state;
 
-use crate::{app_error::AppError, parse_args::CliArgs, ui::log_sanitizer, ENTRY_POINT};
+use crate::{app_error::AppError, parse_args::CliArgs, ui::{log_sanitizer, Status, GuiState}, ENTRY_POINT};
 pub use container_state::*;
 
 /// Global app_state, stored in an Arc<Mutex>
@@ -389,7 +390,8 @@ impl AppData {
     }
 
     /// insert single app_state error
-    pub fn set_error(&mut self, error: AppError) {
+    pub fn set_error(&mut self, error: AppError, gui_state: &Arc<Mutex<GuiState>>, status: Status) {
+		gui_state.lock().status_push(status);
         self.error = Some(error);
     }
 

src/docker_data/mod.rs

@@ -289,7 +289,7 @@ impl DockerData {
     /// Animate the loading icon
     fn loading_spin(loading_uuid: Uuid, gui_state: &Arc<Mutex<GuiState>>) -> JoinHandle<()> {
         let gui_state = Arc::clone(gui_state);
-       tokio::spawn(async move {
+        tokio::spawn(async move {
             loop {
                 tokio::time::sleep(std::time::Duration::from_millis(100)).await;
                 gui_state.lock().next_loading(loading_uuid);
@@ -333,8 +333,7 @@ impl DockerData {
         error: DockerControls,
         gui_state: &Arc<Mutex<GuiState>>,
     ) {
-        app_data.lock().set_error(AppError::DockerCommand(error));
-        gui_state.lock().status_push(Status::Error);
+        app_data.lock().set_error(AppError::DockerCommand(error), gui_state, Status::Error);
     }
 
     /// Handle incoming messages, container controls & all container information update

src/input_handler/mod.rs

@@ -95,16 +95,14 @@ impl InputHandler {
             } else {
                 self.app_data
                     .lock()
-                    .set_error(AppError::MouseCapture(false));
-                self.gui_state.lock().status_push(Status::Error);
+                    .set_error(AppError::MouseCapture(false), &self.gui_state, Status::Error);
             }
         } else if Ui::enable_mouse_capture().is_ok() {
             self.gui_state
                 .lock()
                 .set_info_box("✓ mouse capture enabled".to_owned());
         } else {
-            self.app_data.lock().set_error(AppError::MouseCapture(true));
-            self.gui_state.lock().status_push(Status::Error);
+            self.app_data.lock().set_error(AppError::MouseCapture(true), &self.gui_state, Status::Error);
         };
 
         // If the info box sleep handle is currently being executed, as in 'm' is pressed twice within a 4000ms window

src/main.rs

@@ -105,12 +105,10 @@ async fn docker_init(
                 is_running,
             ));
         } else {
-            app_data.lock().set_error(AppError::DockerConnect);
-            gui_state.lock().status_push(Status::DockerConnect);
+            app_data.lock().set_error(AppError::DockerConnect, gui_state, Status::DockerConnect);
         }
     } else {
-        app_data.lock().set_error(AppError::DockerConnect);
-        gui_state.lock().status_push(Status::DockerConnect);
+        app_data.lock().set_error(AppError::DockerConnect, gui_state, Status::DockerConnect);
     }
 }
 
@@ -147,7 +145,6 @@ async fn main() {
     let gui_state = Arc::new(Mutex::new(GuiState::default()));
     let is_running = Arc::new(AtomicBool::new(true));
     let (docker_sx, docker_rx) = tokio::sync::mpsc::channel(32);
-    let (input_sx, input_rx) = tokio::sync::mpsc::channel(32);
 
     docker_init(
         &app_data,
@@ -159,13 +156,13 @@ async fn main() {
     )
     .await;
 
-    handler_init(&app_data, &docker_sx, &gui_state, input_rx, &is_running);
-
     if args.gui {
+        let (input_sx, input_rx) = tokio::sync::mpsc::channel(32);
+        handler_init(&app_data, &docker_sx, &gui_state, input_rx, &is_running);
         Ui::create(app_data, docker_sx, gui_state, is_running, input_sx).await;
     } else {
         info!("in debug mode");
-		// Debug mode for testing, mostly pointless, doesn't take terminal
+        // Debug mode for testing, mostly pointless, doesn't take terminal
         while is_running.load(Ordering::SeqCst) {
             loop {
                 if let Some(err) = app_data.lock().get_error() {