From 28bf0e603daa623f96e4bae6768f2caecdff40b0 Mon Sep 17 00:00:00 2001 From: Jack Wills <32690432+mrjackwills@users.noreply.github.com> Date: Fri, 29 Apr 2022 17:03:34 +0000 Subject: [PATCH] refactor: docker functions --- src/docker_data/mod.rs | 118 ++++++++++++++++++----------------------- src/ui/draw_blocks.rs | 4 +- src/ui/gui_state.rs | 4 +- src/ui/mod.rs | 9 ++-- 4 files changed, 60 insertions(+), 75 deletions(-) diff --git a/src/docker_data/mod.rs b/src/docker_data/mod.rs index bf68656..c674129 100644 --- a/src/docker_data/mod.rs +++ b/src/docker_data/mod.rs @@ -183,8 +183,7 @@ impl DockerData { } /// Update all logs, spawn each container into own tokio::spawn thread - // rename init all logs, as only gets run once - async fn update_all_logs(&mut self, all_ids: &[(bool, String)]) { + async fn init_all_logs(&mut self, all_ids: &[(bool, String)]) { let mut handles = vec![]; for (_, id) in all_ids.iter() { @@ -212,7 +211,9 @@ impl DockerData { self.update_all_container_stats(&all_ids).await; } - async fn loading_spin(gui_state: Arc>) -> JoinHandle<()> { + /// Animate the loading icon + async fn loading_spin(&mut self ) -> JoinHandle<()> { + let gui_state = Arc::clone(&self.gui_state); tokio::spawn(async move { loop { tokio::time::sleep(std::time::Duration::from_millis(100)).await; @@ -221,20 +222,22 @@ impl DockerData { }) } - fn stop_loading_spin(handle: JoinHandle<()>, gui_state: &Arc>) { + /// Stop the loading_spin fn, and reset gui loading status + fn stop_loading_spin(&mut self, handle: JoinHandle<()>) { handle.abort(); - gui_state.lock().reset_loading(); + self.gui_state.lock().reset_loading(); } + + // Initialize docker container data, before any messages are received async fn initialise_container_data(&mut self) { - let gui_state = Arc::clone(&self.gui_state); - let loading_spin = Self::loading_spin(gui_state).await; + let loading_spin = self.loading_spin().await; let all_ids = self.update_all_containers().await; self.update_all_container_stats(&all_ids).await; // Maybe only do a single one at first? - self.update_all_logs(&all_ids).await; + self.init_all_logs(&all_ids).await; if all_ids.is_empty() { self.initialised = true; @@ -246,7 +249,7 @@ impl DockerData { self.initialised = self.app_data.lock().initialised(&all_ids); } self.app_data.lock().init = true; - Self::stop_loading_spin(loading_spin, &self.gui_state); + self.stop_loading_spin(loading_spin); } /// Handle incoming messages, container controls & all container information update @@ -254,80 +257,65 @@ impl DockerData { while let Some(message) = self.receiver.recv().await { let docker = Arc::clone(&self.docker); let app_data = Arc::clone(&self.app_data); - let gui_state = Arc::clone(&self.gui_state); match message { DockerMessage::Pause(id) => { - let spin_gui = Arc::clone(&gui_state); - let loading_spin = Self::loading_spin(gui_state).await; - tokio::spawn(async move { - docker.pause_container(&id).await.unwrap_or_else(|_| { - app_data - .lock() - .set_error(AppError::DockerCommand(DockerControls::Pause)) - }); - Self::stop_loading_spin(loading_spin, &spin_gui); + let loading_spin =self.loading_spin().await; + docker.pause_container(&id).await.unwrap_or_else(|_| { + app_data + .lock() + .set_error(AppError::DockerCommand(DockerControls::Pause)) }); + self.stop_loading_spin(loading_spin); } DockerMessage::Restart(id) => { - let spin_gui = Arc::clone(&gui_state); - let loading_spin = Self::loading_spin(gui_state).await; - tokio::spawn(async move { - docker - .restart_container(&id, None) - .await - .unwrap_or_else(|_| { - app_data - .lock() - .set_error(AppError::DockerCommand(DockerControls::Restart)) - }); - Self::stop_loading_spin(loading_spin, &spin_gui); - }); + let loading_spin =self.loading_spin().await; + docker + .restart_container(&id, None) + .await + .unwrap_or_else(|_| { + app_data + .lock() + .set_error(AppError::DockerCommand(DockerControls::Restart)) + }); + self.stop_loading_spin(loading_spin); } DockerMessage::Start(id) => { - let spin_gui = Arc::clone(&gui_state); - let loading_spin = Self::loading_spin(gui_state).await; - tokio::spawn(async move { - docker - .start_container(&id, None::>) - .await - .unwrap_or_else(|_| { - app_data - .lock() - .set_error(AppError::DockerCommand(DockerControls::Start)) - }); - Self::stop_loading_spin(loading_spin, &spin_gui); - }); + let loading_spin =self.loading_spin().await; + docker + .start_container(&id, None::>) + .await + .unwrap_or_else(|_| { + app_data + .lock() + .set_error(AppError::DockerCommand(DockerControls::Start)) + }); + self.stop_loading_spin(loading_spin); } DockerMessage::Stop(id) => { - let spin_gui = Arc::clone(&gui_state); - let loading_spin = Self::loading_spin(gui_state).await; - tokio::spawn(async move { - docker.stop_container(&id, None).await.unwrap_or_else(|_| { - app_data - .lock() - .set_error(AppError::DockerCommand(DockerControls::Stop)) - }); - Self::stop_loading_spin(loading_spin, &spin_gui); + let loading_spin =self.loading_spin().await; + docker.stop_container(&id, None).await.unwrap_or_else(|_| { + app_data + .lock() + .set_error(AppError::DockerCommand(DockerControls::Stop)) }); + self.stop_loading_spin(loading_spin); } DockerMessage::Unpause(id) => { - let spin_gui = Arc::clone(&gui_state); - let loading_spin = Self::loading_spin(gui_state).await; - tokio::spawn(async move { - docker.unpause_container(&id).await.unwrap_or_else(|_| { - app_data - .lock() - .set_error(AppError::DockerCommand(DockerControls::Unpause)) - }); - Self::stop_loading_spin(loading_spin, &spin_gui); + let loading_spin =self.loading_spin().await; + docker.unpause_container(&id).await.unwrap_or_else(|_| { + app_data + .lock() + .set_error(AppError::DockerCommand(DockerControls::Unpause)) }); + self.stop_loading_spin(loading_spin); + self.update_everything().await } DockerMessage::Update => self.update_everything().await, } } } - /// Initialise self, and start the updated loop + /// Initialise self, and start the message receiving loop pub async fn init( args: CliArgs, app_data: Arc>, @@ -346,8 +334,6 @@ impl DockerData { }; inner.initialise_container_data().await; - // todo!(" change this to recv.next()"); - // inner.update_loop().await; inner.message_handler().await; } } diff --git a/src/ui/draw_blocks.rs b/src/ui/draw_blocks.rs index 2aeb768..182462c 100644 --- a/src/ui/draw_blocks.rs +++ b/src/ui/draw_blocks.rs @@ -223,7 +223,7 @@ pub fn draw_logs( f: &mut Frame<'_, B>, gui_state: &Arc>, index: Option, - loading_icon: String, + loading_icon: String, selected_panel: &SelectablePanel, ) { let panel = SelectablePanel::Logs; @@ -368,7 +368,7 @@ pub fn draw_heading_bar( columns: &Columns, f: &mut Frame<'_, B>, has_containers: bool, - loading_icon: String, + loading_icon: String, info_visible: bool, ) { let block = || Block::default().style(Style::default().bg(Color::Magenta).fg(Color::Black)); diff --git a/src/ui/gui_state.rs b/src/ui/gui_state.rs index 5a99a51..97983da 100644 --- a/src/ui/gui_state.rs +++ b/src/ui/gui_state.rs @@ -167,8 +167,8 @@ pub struct GuiState { // If a BMapTree think it would mean have to implement ordering for SelectablePanel area_map: HashMap, loading_icon: Loading, - // Should be a vec, each time loading add a new to the vec, and reset remove from vec - // for for if is_loading just check if vec is empty or not + // Should be a vec, each time loading add a new to the vec, and reset remove from vec + // for for if is_loading just check if vec is empty or not is_loading: bool, pub selected_panel: SelectablePanel, pub show_help: bool, diff --git a/src/ui/mod.rs b/src/ui/mod.rs index 33dafc6..a71a244 100644 --- a/src/ui/mod.rs +++ b/src/ui/mod.rs @@ -14,7 +14,6 @@ use std::{ time::{Duration, Instant}, }; use tokio::sync::mpsc::Sender; -use tracing::error; use tui::{ backend::{Backend, CrosstermBackend}, layout::{Constraint, Direction, Layout}, @@ -68,7 +67,7 @@ pub async fn create_ui( terminal.show_cursor().unwrap(); if let Err(err) = res { - error!(%err); + println!("{}", err); } Ok(()) } @@ -157,7 +156,7 @@ fn ui( let selected_panel = gui_state.lock().selected_panel; let show_help = gui_state.lock().show_help; let info_text = gui_state.lock().info_box_text.clone(); - let loading_icon = gui_state.lock().get_loading(); + let loading_icon = gui_state.lock().get_loading(); let whole_layout = Layout::default() .direction(Direction::Vertical) @@ -219,7 +218,7 @@ fn ui( f, gui_state, log_index, - loading_icon.to_owned(), + loading_icon.to_owned(), &selected_panel, ); @@ -228,7 +227,7 @@ fn ui( &column_widths, f, has_containers, - loading_icon, + loading_icon, show_help, );