refactor: dead code removed

src/app_data/mod.rs

@@ -490,22 +490,27 @@ impl AppData {
         }
     }
 
-    /// update logs of a given container, based on index not id
+    /// update logs of a given container, based on id
-    pub fn update_log_by_index(&mut self, output: Vec<String>, index: usize) {
+    pub fn update_log_by_id(&mut self, output: Vec<String>, id: String) {
         let tz = self.get_systemtime();
-        if let Some(container) = self.containers.items.get_mut(index) {
+        let color = self.args.color;
+        let raw = self.args.raw;
+
+        if let Some(container) = self.get_container_by_id(&id) {
             container.last_updated = tz;
             let current_len = container.logs.items.len();
+
             output.iter().for_each(|i| {
-                let lines = if self.args.color {
+                let lines = if color {
                     log_sanitizer::colorize_logs(i.to_owned())
-                } else if self.args.raw {
+                } else if raw {
                     log_sanitizer::raw(i.to_owned())
                 } else {
                     log_sanitizer::remove_ansi(i.to_owned())
                 };
                 container.logs.items.push(ListItem::new(lines));
             });
+
             if container.logs.state.selected().is_none()
                 || container.logs.state.selected().unwrap_or_default() + 1 == current_len
             {
@@ -514,11 +519,4 @@ impl AppData {
         }
         self.logs_parsed = true;
     }
-
-    // /// Update all containers logs, should only be used on first initialisation
-    // pub fn update_all_logs(&mut self, all_logs: Vec<Vec<String>>) {
-    //     for (index, output) in all_logs.into_iter().enumerate() {
-    //         self.update_log_by_index(output, index);
-    //     }
-    // }
 }

src/docker_data/mod.rs

@@ -27,11 +27,10 @@ pub struct DockerData {
     docker: Arc<Docker>,
     gui_state: Arc<Mutex<GuiState>>,
     initialised: bool,
-    receiver: Receiver<DockerMessage>,
-    timestamps: bool,
-    spawns: Arc<Mutex<HashMap<String, JoinHandle<()>>>>,
-	// log_spawns: Arc<Mutex<HashMap<String, JoinHandle<Vec<String>>>>>,
     is_running: Arc<AtomicBool>,
+    receiver: Receiver<DockerMessage>,
+    spawns: Arc<Mutex<HashMap<String, JoinHandle<()>>>>,
+    timestamps: bool,
 }
 
 impl DockerData {
@@ -117,8 +116,8 @@ impl DockerData {
                     .lock()
                     .update_stats(id.clone(), None, None, mem_limit, rx, tx);
             }
+            spawns.lock().remove(&id);
         }
-        spawns.lock().remove(&id);
     }
 
     /// Update all stats, spawn each container into own tokio::spawn thread
@@ -131,13 +130,15 @@ impl DockerData {
             let id = id.to_owned();
 
             let spawn_contains_id = spawns.lock().contains_key(&id);
+            let s = tokio::spawn(Self::update_container_stat(
+                docker,
+                id.to_owned(),
+                app_data,
+                is_running,
+                spawns,
+            ));
             if !spawn_contains_id {
-                self.spawns.lock().insert(
+                self.spawns.lock().insert(id, s);
-                    id.to_owned(),
-                    tokio::spawn(Self::update_container_stat(
-                        docker, id, app_data, is_running, spawns,
-                    )),
-                );
             }
         }
     }
@@ -187,9 +188,8 @@ impl DockerData {
         id: String,
         timestamps: bool,
         since: i64,
-		app_data: Arc<Mutex<AppData>>,
+        app_data: Arc<Mutex<AppData>>,
-		spawns: Arc<Mutex<HashMap<String, JoinHandle<()>>>>,
+        spawns: Arc<Mutex<HashMap<String, JoinHandle<()>>>>,
-		index: usize
     ) {
         let options = Some(LogsOptions::<String> {
             stdout: true,
@@ -210,22 +210,24 @@ impl DockerData {
                 }
             }
         }
-
+        spawns.lock().remove(&id);
-		app_data.lock().update_log_by_index(output, index);
+        app_data.lock().update_log_by_id(output, id.to_owned());
-		spawns.lock().remove(&id);
     }
 
     /// Update all logs, spawn each container into own tokio::spawn thread
     async fn init_all_logs(&mut self, all_ids: &[(bool, String)]) {
-        // let mut handles = vec![];
+        for (_, id) in all_ids.iter() {
-
-        for (index, (_, id)) in all_ids.iter().enumerate() {
             let docker = Arc::clone(&self.docker);
             let timestamps = self.timestamps;
             let id = id.to_owned();
-			let app_data = Arc::clone(&self.app_data);
+            let app_data = Arc::clone(&self.app_data);
-			let spawns = Arc::clone(&self.spawns);
+            let spawns = Arc::clone(&self.spawns);
-			self.spawns.lock().insert(id.to_owned(), tokio::spawn(Self::update_log(docker, id, timestamps, 0, app_data, spawns, index)));
+            self.spawns.lock().insert(
+                id.to_owned(),
+                tokio::spawn(Self::update_log(
+                    docker, id, timestamps, 0, app_data, spawns,
+                )),
+            );
         }
     }
 
@@ -233,21 +235,27 @@ impl DockerData {
         let all_ids = self.update_all_containers().await;
         let optional_index = self.app_data.lock().get_selected_log_index();
         if let Some(index) = optional_index {
-			let id = self.app_data.lock().containers.items[index].id.to_owned();
+            let id = self.app_data.lock().containers.items[index].id.to_owned();
 
-			let running = self.spawns.lock().contains_key(&id);
+            let running = self.spawns.lock().contains_key(&id);
 
-			if !running {
+            if !running {
-				let since = self.app_data.lock().containers.items[index].last_updated as i64;
+                let since = self.app_data.lock().containers.items[index].last_updated as i64;
-				let docker = Arc::clone(&self.docker);
+                let docker = Arc::clone(&self.docker);
-				let timestamps = self.timestamps;
+                let timestamps = self.timestamps;
 
-				let app_data = Arc::clone(&self.app_data);
+                let app_data = Arc::clone(&self.app_data);
-				let spawns = Arc::clone(&self.spawns);
+                let spawns = Arc::clone(&self.spawns);
-				self.spawns.lock().insert(id.to_owned(), tokio::spawn(Self::update_log(docker, id, timestamps, since, app_data, spawns, index)));
+                let s = tokio::spawn(Self::update_log(
-			}
+                    docker,
-
+                    id.to_owned(),
-            
+                    timestamps,
+                    since,
+                    app_data,
+                    spawns,
+                ));
+                self.spawns.lock().insert(id, s);
+            }
         };
 
         self.update_all_container_stats(&all_ids).await;