feat: use gui_status for various gui states

src/app_data/mod.rs

@@ -14,10 +14,8 @@ pub struct AppData {
     args: CliArgs,
     error: Option<AppError>,
     logs_parsed: bool,
-    pub containers: StatefulList<ContainerItem>,
-    // pub init: bool,
-    // pub show_error: bool,
     sorted_by: Option<(Header, SortedOrder)>,
+    pub containers: StatefulList<ContainerItem>,
 }
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]

src/docker_data/mod.rs

@@ -3,7 +3,7 @@ use bollard::{
     service::ContainerSummary,
     Docker,
 };
-use futures_util::StreamExt;
+use futures_util::{Future, StreamExt};
 use parking_lot::Mutex;
 use std::{
     collections::HashMap,
@@ -318,6 +318,7 @@ impl DockerData {
 
     // Initialize docker container data, before any messages are received
     async fn initialise_container_data(&mut self) {
+        self.gui_state.lock().status_push(Status::Init);
         let loading_uuid = Uuid::new_v4();
         let loading_spin = self.loading_spin(loading_uuid).await;
 
@@ -336,8 +337,7 @@ impl DockerData {
             tokio::time::sleep(std::time::Duration::from_millis(100)).await;
             self.initialised = self.app_data.lock().initialised(&all_ids);
         }
-        // self.app_data.lock().init = true;
-        self.gui_state.lock().set_status(Status::Normal);
+        self.gui_state.lock().status_del(Status::Init);
         self.stop_loading_spin(&loading_spin, loading_uuid);
     }
 
@@ -346,57 +346,68 @@ impl DockerData {
         self.app_data
             .lock()
             .set_error(AppError::DockerCommand(error));
-        self.gui_state.lock().set_status(Status::Error);
+        self.gui_state.lock().status_push(Status::Error);
+    }
+
+    /// Execute docker commands, will start and stop the loading spinner
+    async fn exec_docker(
+        &mut self,
+        docker_fn: impl Future<Output = Result<(), bollard::errors::Error>>,
+        uuid: Uuid,
+        control: DockerControls,
+    ) {
+        let loading_spin = self.loading_spin(uuid).await;
+        if docker_fn.await.is_err() {
+            self.set_error(control);
+        };
+        self.stop_loading_spin(&loading_spin, uuid);
     }
 
     /// Handle incoming messages, container controls & all container information update
     async fn message_handler(&mut self) {
         while let Some(message) = self.receiver.recv().await {
-            let docker = Arc::clone(&self.docker);
             let loading_uuid = Uuid::new_v4();
+            let docker = Arc::clone(&self.docker);
             match message {
                 DockerMessage::Pause(id) => {
-                    let loading_spin = self.loading_spin(loading_uuid).await;
-                    if docker.pause_container(id.get()).await.is_err() {
-                        self.set_error(DockerControls::Pause);
-                    };
-                    self.stop_loading_spin(&loading_spin, loading_uuid);
+                    self.exec_docker(
+                        docker.pause_container(id.get()),
+                        loading_uuid,
+                        DockerControls::Pause,
+                    )
+                    .await;
                 }
                 DockerMessage::Restart(id) => {
-                    // DEBUG	
-                    // self.set_error(DockerControls::Restart);
-                    // DEBUG
-
-                    let loading_spin = self.loading_spin(loading_uuid).await;
-                    if docker.restart_container(id.get(), None).await.is_err() {
-                        self.set_error(DockerControls::Restart);
-                    };
-                    self.stop_loading_spin(&loading_spin, loading_uuid);
+                    self.exec_docker(
+                        docker.restart_container(id.get(), None),
+                        loading_uuid,
+                        DockerControls::Restart,
+                    )
+                    .await;
                 }
                 DockerMessage::Start(id) => {
-                    let loading_spin = self.loading_spin(loading_uuid).await;
-                    if docker
-                        .start_container(id.get(), None::<StartContainerOptions<String>>)
-                        .await
-                        .is_err()
-                    {
-                        self.set_error(DockerControls::Start);
-                    };
-                    self.stop_loading_spin(&loading_spin, loading_uuid);
+                    self.exec_docker(
+                        docker.start_container(id.get(), None::<StartContainerOptions<String>>),
+                        loading_uuid,
+                        DockerControls::Start,
+                    )
+                    .await;
                 }
                 DockerMessage::Stop(id) => {
-                    let loading_spin = self.loading_spin(loading_uuid).await;
-                    if docker.stop_container(id.get(), None).await.is_err() {
-                        self.set_error(DockerControls::Stop);
-                    };
-                    self.stop_loading_spin(&loading_spin, loading_uuid);
+                    self.exec_docker(
+                        docker.stop_container(id.get(), None),
+                        loading_uuid,
+                        DockerControls::Stop,
+                    )
+                    .await;
                 }
                 DockerMessage::Unpause(id) => {
-                    let loading_spin = self.loading_spin(loading_uuid).await;
-                    if docker.unpause_container(id.get()).await.is_err() {
-                        self.set_error(DockerControls::Unpause);
-                    };
-                    self.stop_loading_spin(&loading_spin, loading_uuid);
+                    self.exec_docker(
+                        docker.unpause_container(id.get()),
+                        loading_uuid,
+                        DockerControls::Unpause,
+                    )
+                    .await;
                     self.update_everything().await;
                 }
                 DockerMessage::Update => self.update_everything().await,

src/input_handler/mod.rs

@@ -64,11 +64,12 @@ impl InputHandler {
             match message {
                 InputMessages::ButtonPress(key_code) => self.button_press(key_code).await,
                 InputMessages::MouseEvent(mouse_event) => {
-                    // let show_error = self.app_data.lock().show_error;
-                    let status = self.gui_state.lock().get_status();
-                    match status {
-                        Status::Error | Status::Help => (),
-                        _ => self.mouse_press(mouse_event),
+                    let error_or_help = self
+                        .gui_state
+                        .lock()
+                        .status_contains(&[Status::Error, Status::Help]);
+                    if !error_or_help {
+                        self.mouse_press(mouse_event)
                     }
                 }
             }
@@ -133,155 +134,152 @@ impl InputHandler {
     }
 
     /// Send a quit message to docker, to abort all spawns, if an error is return, set is_running to false here instead
-    async fn quit(&self, status: Status) {
-        match status {
-            Status::Error | Status::Init => self.is_running.store(false, Ordering::SeqCst),
-            _ => {
-                if self.docker_sender.send(DockerMessage::Quit).await.is_err() {
-                    self.is_running.store(false, Ordering::SeqCst)
-                }
-            }
+    async fn quit(&self) {
+        let error_init = self
+            .gui_state
+            .lock()
+            .status_contains(&[Status::Error, Status::Init]);
+        if error_init {
+            self.is_running.store(false, Ordering::SeqCst);
+        } else if self.docker_sender.send(DockerMessage::Quit).await.is_err() {
+            self.is_running.store(false, Ordering::SeqCst)
         }
-
-        // match self.docker_sender.send(DockerMessage::Quit).await {
-        //     Ok(_) => (),
-        //     Err(_) => self.is_running.store(false, Ordering::SeqCst),
-        // }
     }
 
     /// Handle any keyboard button events
     #[allow(clippy::too_many_lines)]
     async fn button_press(&mut self, key_code: KeyCode) {
-        let status = self.gui_state.lock().get_status();
+        let contains_error = self.gui_state.lock().status_contains(&[Status::Error]);
+        let contains_help = self.gui_state.lock().status_contains(&[Status::Help]);
 
-        match status {
-            Status::Error => match key_code {
-                KeyCode::Char('q' | 'Q') => self.quit(status).await,
+        if contains_error {
+            match key_code {
+                KeyCode::Char('q' | 'Q') => self.quit().await,
                 KeyCode::Char('c' | 'C') => {
                     self.app_data.lock().remove_error();
-                    self.gui_state.lock().set_status(Status::Normal);
+                    self.gui_state.lock().status_del(Status::Error);
                 }
                 _ => (),
-            },
-            Status::Help => match key_code {
-                KeyCode::Char('q' | 'Q') => self.quit(status).await,
-                KeyCode::Char('h' | 'H') => self.gui_state.lock().set_status(Status::Help),
+            }
+        } else if contains_help {
+            match key_code {
+                KeyCode::Char('q' | 'Q') => self.quit().await,
+                KeyCode::Char('h' | 'H') => self.gui_state.lock().status_del(Status::Help),
                 KeyCode::Char('m' | 'M') => self.m_key(),
                 _ => (),
-            },
-            _ => {
-                match key_code {
-                    KeyCode::Char('0') => self.app_data.lock().set_sorted(None),
-                    KeyCode::Char('1') => self.sort(Header::State),
-                    KeyCode::Char('2') => self.sort(Header::Status),
-                    KeyCode::Char('3') => self.sort(Header::Cpu),
-                    KeyCode::Char('4') => self.sort(Header::Memory),
-                    KeyCode::Char('5') => self.sort(Header::Id),
-                    KeyCode::Char('6') => self.sort(Header::Name),
-                    KeyCode::Char('7') => self.sort(Header::Image),
-                    KeyCode::Char('8') => self.sort(Header::Rx),
-                    KeyCode::Char('9') => self.sort(Header::Tx),
-                    KeyCode::Char('q' | 'Q') => self.quit(status).await,
-                    KeyCode::Char('h' | 'H') => self.gui_state.lock().set_status(Status::Help),
-                    KeyCode::Char('m' | 'M') => self.m_key(),
-                    KeyCode::Tab => {
-                        // Skip control panel if no containers, could be refactored
-                        let has_containers = self.app_data.lock().get_container_len() == 0;
-                        let is_containers =
-                            self.gui_state.lock().selected_panel == SelectablePanel::Containers;
-                        let count = if has_containers && is_containers {
-                            2
-                        } else {
-                            1
-                        };
-                        for _ in 0..count {
-                            self.gui_state.lock().next_panel();
-                        }
+            }
+        } else {
+            match key_code {
+                KeyCode::Char('0') => self.app_data.lock().set_sorted(None),
+                KeyCode::Char('1') => self.sort(Header::State),
+                KeyCode::Char('2') => self.sort(Header::Status),
+                KeyCode::Char('3') => self.sort(Header::Cpu),
+                KeyCode::Char('4') => self.sort(Header::Memory),
+                KeyCode::Char('5') => self.sort(Header::Id),
+                KeyCode::Char('6') => self.sort(Header::Name),
+                KeyCode::Char('7') => self.sort(Header::Image),
+                KeyCode::Char('8') => self.sort(Header::Rx),
+                KeyCode::Char('9') => self.sort(Header::Tx),
+                KeyCode::Char('q' | 'Q') => self.quit().await,
+                KeyCode::Char('h' | 'H') => self.gui_state.lock().status_push(Status::Help),
+                KeyCode::Char('m' | 'M') => self.m_key(),
+                KeyCode::Tab => {
+                    // Skip control panel if no containers, could be refactored
+                    let has_containers = self.app_data.lock().get_container_len() == 0;
+                    let is_containers =
+                        self.gui_state.lock().selected_panel == SelectablePanel::Containers;
+                    let count = if has_containers && is_containers {
+                        2
+                    } else {
+                        1
+                    };
+                    for _ in 0..count {
+                        self.gui_state.lock().next_panel();
                     }
-                    KeyCode::BackTab => {
-                        // Skip control panel if no containers, could be refactored
-                        let has_containers = self.app_data.lock().get_container_len() == 0;
-                        let is_containers =
-                            self.gui_state.lock().selected_panel == SelectablePanel::Logs;
-                        let count = if has_containers && is_containers {
-                            2
-                        } else {
-                            1
-                        };
-                        for _ in 0..count {
-                            self.gui_state.lock().previous_panel();
-                        }
+                }
+                KeyCode::BackTab => {
+                    // Skip control panel if no containers, could be refactored
+                    let has_containers = self.app_data.lock().get_container_len() == 0;
+                    let is_containers =
+                        self.gui_state.lock().selected_panel == SelectablePanel::Logs;
+                    let count = if has_containers && is_containers {
+                        2
+                    } else {
+                        1
+                    };
+                    for _ in 0..count {
+                        self.gui_state.lock().previous_panel();
                     }
-                    KeyCode::Home => {
-                        let mut locked_data = self.app_data.lock();
-                        match self.gui_state.lock().selected_panel {
-                            SelectablePanel::Containers => locked_data.containers.start(),
-                            SelectablePanel::Logs => locked_data.log_start(),
-                            SelectablePanel::Commands => locked_data.docker_command_start(),
-                        }
+                }
+                KeyCode::Home => {
+                    let mut locked_data = self.app_data.lock();
+                    match self.gui_state.lock().selected_panel {
+                        SelectablePanel::Containers => locked_data.containers.start(),
+                        SelectablePanel::Logs => locked_data.log_start(),
+                        SelectablePanel::Commands => locked_data.docker_command_start(),
                     }
-                    KeyCode::End => {
-                        let mut locked_data = self.app_data.lock();
-                        match self.gui_state.lock().selected_panel {
-                            SelectablePanel::Containers => locked_data.containers.end(),
-                            SelectablePanel::Logs => locked_data.log_end(),
-                            SelectablePanel::Commands => locked_data.docker_command_end(),
-                        }
+                }
+                KeyCode::End => {
+                    let mut locked_data = self.app_data.lock();
+                    match self.gui_state.lock().selected_panel {
+                        SelectablePanel::Containers => locked_data.containers.end(),
+                        SelectablePanel::Logs => locked_data.log_end(),
+                        SelectablePanel::Commands => locked_data.docker_command_end(),
                     }
-                    KeyCode::Up | KeyCode::Char('k' | 'K') => self.previous(),
-                    KeyCode::PageUp => {
-                        for _ in 0..=6 {
-                            self.previous();
-                        }
+                }
+                KeyCode::Up | KeyCode::Char('k' | 'K') => self.previous(),
+                KeyCode::PageUp => {
+                    for _ in 0..=6 {
+                        self.previous();
                     }
-                    KeyCode::Down | KeyCode::Char('j' | 'J') => self.next(),
-                    KeyCode::PageDown => {
-                        for _ in 0..=6 {
-                            self.next();
-                        }
+                }
+                KeyCode::Down | KeyCode::Char('j' | 'J') => self.next(),
+                KeyCode::PageDown => {
+                    for _ in 0..=6 {
+                        self.next();
                     }
-                    KeyCode::Enter => {
-                        // This isn't great, just means you can't send docker commands before full initialization of the program
-                        let panel = self.gui_state.lock().selected_panel;
-                        if panel == SelectablePanel::Commands {
-                            let option_command = self.app_data.lock().get_docker_command();
+                }
+                KeyCode::Enter => {
+                    // This isn't great, just means you can't send docker commands before full initialization of the program
+                    let panel = self.gui_state.lock().selected_panel;
+                    if panel == SelectablePanel::Commands {
+                        let option_command = self.app_data.lock().get_docker_command();
 
-                            if let Some(command) = option_command {
-                                let option_id = self.app_data.lock().get_selected_container_id();
-                                if let Some(id) = option_id {
-                                    match command {
-                                        DockerControls::Pause => self
-                                            .docker_sender
-                                            .send(DockerMessage::Pause(id))
-                                            .await
-                                            .unwrap_or(()),
-                                        DockerControls::Unpause => self
-                                            .docker_sender
-                                            .send(DockerMessage::Unpause(id))
-                                            .await
-                                            .unwrap_or(()),
-                                        DockerControls::Start => self
-                                            .docker_sender
-                                            .send(DockerMessage::Start(id))
-                                            .await
-                                            .unwrap_or(()),
-                                        DockerControls::Stop => self
-                                            .docker_sender
-                                            .send(DockerMessage::Stop(id))
-                                            .await
-                                            .unwrap_or(()),
-                                        DockerControls::Restart => self
-                                            .docker_sender
-                                            .send(DockerMessage::Restart(id))
-                                            .await
-                                            .unwrap_or(()),
-                                    }
+                        if let Some(command) = option_command {
+                            let option_id = self.app_data.lock().get_selected_container_id();
+                            if let Some(id) = option_id {
+                                match command {
+                                    DockerControls::Pause => self
+                                        .docker_sender
+                                        .send(DockerMessage::Pause(id))
+                                        .await
+                                        .unwrap_or(()),
+                                    DockerControls::Unpause => self
+                                        .docker_sender
+                                        .send(DockerMessage::Unpause(id))
+                                        .await
+                                        .unwrap_or(()),
+                                    DockerControls::Start => self
+                                        .docker_sender
+                                        .send(DockerMessage::Start(id))
+                                        .await
+                                        .unwrap_or(()),
+                                    DockerControls::Stop => self
+                                        .docker_sender
+                                        .send(DockerMessage::Stop(id))
+                                        .await
+                                        .unwrap_or(()),
+                                    DockerControls::Restart => self
+                                        .docker_sender
+                                        .send(DockerMessage::Restart(id))
+                                        .await
+                                        .unwrap_or(()),
                                 }
                             }
                         }
                     }
-                    _ => (),
                 }
+                _ => (),
             }
         }
     }

src/main.rs

@@ -61,12 +61,12 @@ async fn main() {
             }
             Err(_) => {
                 app_data.lock().set_error(AppError::DockerConnect);
-                docker_gui_state.lock().set_status(Status::DockerConnect)
+                docker_gui_state.lock().status_push(Status::DockerConnect)
             }
         },
         Err(_) => {
             app_data.lock().set_error(AppError::DockerConnect);
-            docker_gui_state.lock().set_status(Status::DockerConnect)
+            docker_gui_state.lock().status_push(Status::DockerConnect)
         }
     }
     let input_app_data = Arc::clone(&app_data);

src/ui/draw_blocks.rs

@@ -216,43 +216,36 @@ pub fn logs<B: Backend>(
     loading_icon: &str,
 ) {
     let block = generate_block(app_data, area, gui_state, SelectablePanel::Logs);
-    let status = gui_state.lock().get_status();
-    match status {
-        Status::Init => {
-            let paragraph = Paragraph::new(format!("parsing logs {}", loading_icon))
-                .style(Style::default())
-                .block(block)
-                .alignment(Alignment::Center);
-            f.render_widget(paragraph, area);
-        }
+    let contains_init = gui_state.lock().status_contains(&[Status::Init]);
+    if contains_init {
+        let paragraph = Paragraph::new(format!("parsing logs {}", loading_icon))
+            .style(Style::default())
+            .block(block)
+            .alignment(Alignment::Center);
+        f.render_widget(paragraph, area);
+    } else if let Some(index) = index {
+        let items = app_data.lock().containers.items[index]
+            .logs
+            .items
+            .iter()
+            .enumerate()
+            .map(|i| i.1.clone())
+            .collect::<Vec<_>>();
 
-        _ => {
-            if let Some(index) = index {
-                let items = app_data.lock().containers.items[index]
-                    .logs
-                    .items
-                    .iter()
-                    .enumerate()
-                    .map(|i| i.1.clone())
-                    .collect::<Vec<_>>();
-
-                let items = List::new(items)
-                    .block(block)
-                    .highlight_symbol(ARROW)
-                    .highlight_style(Style::default().add_modifier(Modifier::BOLD));
-                f.render_stateful_widget(
-                    items,
-                    area,
-                    &mut app_data.lock().containers.items[index].logs.state,
-                );
-            } else {
-                let paragraph = Paragraph::new("no logs found")
-                    .block(block)
-                    .alignment(Alignment::Center);
-                f.render_widget(paragraph, area);
-                // }
-            }
-        }
+        let items = List::new(items)
+            .block(block)
+            .highlight_symbol(ARROW)
+            .highlight_style(Style::default().add_modifier(Modifier::BOLD));
+        f.render_stateful_widget(
+            items,
+            area,
+            &mut app_data.lock().containers.items[index].logs.state,
+        );
+    } else {
+        let paragraph = Paragraph::new("no logs found")
+            .block(block)
+            .alignment(Alignment::Center);
+        f.render_widget(paragraph, area);
     }
 }
 
@@ -356,7 +349,7 @@ pub fn heading_bar<B: Backend>(
     gui_state: &Arc<Mutex<GuiState>>,
 ) {
     let block = |fg: Color| Block::default().style(Style::default().bg(Color::Magenta).fg(fg));
-    let info_visible = gui_state.lock().get_status() == Status::Help;
+    let help_visible = gui_state.lock().status_contains(&[Status::Help]);
 
     f.render_widget(block(Color::Black), area);
 
@@ -436,13 +429,8 @@ pub fn heading_bar<B: Backend>(
         })
         .collect::<Vec<_>>();
 
-    let suffix = if info_visible { "exit" } else { "show" };
-    let info_text = format!(
-        "( h ) {} help {} {:?}",
-        suffix,
-        MARGIN,
-        gui_state.lock().get_status()
-    );
+    let suffix = if help_visible { "exit" } else { "show" };
+    let info_text = format!("( h ) {} help {}", suffix, MARGIN,);
     let info_width = info_text.chars().count();
 
     let column_width = usize::from(area.width) - info_width;
@@ -484,10 +472,10 @@ pub fn heading_bar<B: Backend>(
     }
 
     // show/hide help
-    let color = if info_visible {
-        Color::White
-    } else {
+    let color = if help_visible {
         Color::Black
+    } else {
+        Color::White
     };
     let help_paragraph = Paragraph::new(info_text)
         .block(block(color))

src/ui/gui_state.rs

@@ -181,7 +181,6 @@ pub enum Status {
     Help,
     DockerConnect,
     Error,
-    Normal,
 }
 
 /// Global gui_state, stored in an Arc<Mutex>
@@ -191,7 +190,7 @@ pub struct GuiState {
     heading_map: HashMap<Header, Rect>,
     loading_icon: Loading,
     is_loading: HashSet<Uuid>,
-    status: Status,
+    status: HashSet<Status>,
     pub selected_panel: SelectablePanel,
     pub info_box_text: Option<String>,
 }
@@ -205,7 +204,7 @@ impl GuiState {
             selected_panel: SelectablePanel::Containers,
             is_loading: HashSet::new(),
             info_box_text: None,
-            status: Status::Init,
+            status: HashSet::new(),
         }
     }
 
@@ -253,12 +252,16 @@ impl GuiState {
         };
     }
 
-    pub fn set_status(&mut self, status: Status) {
-        self.status = status
+    pub fn status_push(&mut self, status: Status) {
+        self.status.insert(status);
     }
 
-    pub fn get_status(&self) -> Status {
-        self.status
+    pub fn status_del(&mut self, status: Status) {
+        self.status.remove(&status);
+    }
+
+    pub fn status_contains(&self, status: &[Status]) -> bool {
+        status.iter().any(|i| self.status.contains(i))
     }
 
     /// Change to next selectable panel

src/ui/mod.rs

@@ -85,9 +85,9 @@ async fn run_app<B: Backend + Send>(
     let input_poll_rate = std::time::Duration::from_millis(75);
 
     // Check for docker connect errors before attempting to draw the gui
-    let status = gui_state.lock().get_status();
+    let status_dockerconnect = gui_state.lock().status_contains(&[Status::DockerConnect]);
 
-    if status == Status::DockerConnect {
+    if status_dockerconnect {
         let mut seconds = 5;
         loop {
             if seconds < 1 {
@@ -159,7 +159,7 @@ fn ui<B: Backend>(
     let log_index = app_data.lock().get_selected_log_index();
     let sorted_by = app_data.lock().get_sorted();
 
-    let show_help = gui_state.lock().get_status() == Status::Help;
+    let show_help = gui_state.lock().status_contains(&[Status::Help]);
     let info_text = gui_state.lock().info_box_text.clone();
     let loading_icon = gui_state.lock().get_loading();