More clear worker thread loop {} breaks.

Author: nullstalgia

src/buffer/defmt/elf_watcher.rs

@@ -158,26 +158,25 @@ impl ElfWatchWorker {
                     }
                 }
                 Err(TryRecvError::Empty) => (),
-                Err(TryRecvError::Disconnected) => return Err(ElfWatchError::WatcherDisconnect),
+                Err(TryRecvError::Disconnected) => break Err(ElfWatchError::WatcherDisconnect),
             }
 
             match self.command_rx.try_recv() {
                 Ok(ElfWatchCommand::Shutdown(shutdown_tx)) => {
                     if let Err(_) = shutdown_tx.send(()) {
                         error!("Failed to reply to shutdown request!");
-                        return Err(ElfWatchError::ShutdownReply);
+                        break Err(ElfWatchError::ShutdownReply);
+                    } else {
+                        return Ok(());
                     }
                 }
                 Ok(command) => {
                     self.handle_command(command)?;
                 }
                 Err(TryRecvError::Empty) => (),
-                Err(TryRecvError::Disconnected) => return Err(ElfWatchError::HandleDropped),
+                Err(TryRecvError::Disconnected) => break Err(ElfWatchError::HandleDropped),
             }
-            break;
         }
-
-        Ok(())
     }
     fn event_matches_watched_file(&self, event: &notify::Event) -> bool {
         if let Some(watched_path) = &self.file_under_watch

src/buffer/logging.rs

@@ -86,6 +86,8 @@ enum LoggingError {
     EventSend,
     #[error("failed to reply to shutdown request in time")]
     ShutdownReply,
+    #[error("handle dropped, can't recieve commands")]
+    HandleDropped,
 }
 
 impl<T> From<SendError<T>> for LoggingError {
@@ -294,17 +296,15 @@ impl LoggingWorker {
                     self.close_files(true)?;
                     if let Err(_) = shutdown_tx.send(()) {
                         error!("Failed to reply to shutdown request!");
-                        return Err(LoggingError::ShutdownReply);
+                        break Err(LoggingError::ShutdownReply);
+                    } else {
+                        break Ok(());
                     }
-
-                    break;
                 }
                 Ok(cmd) => self.handle_command(cmd)?,
-                Err(RecvError) => {}
+                Err(RecvError) => break Err(LoggingError::HandleDropped),
             }
         }
-
-        Ok(())
     }
     fn log_connection_event(
         &mut self,

src/event_carousel.rs

@@ -141,9 +141,9 @@ impl CarouselWorker {
                     if let Err(_) = shutdown_tx.send(()) {
                         error!("Failed to reply to shutdown request!");
                         return Err(CarouselError::ShutdownReply);
+                    } else {
+                        break Ok(());
                     }
-
-                    break;
                 }
                 Err(RecvTimeoutError::Timeout) => (),
                 Err(RecvTimeoutError::Disconnected) => {
@@ -186,20 +186,14 @@ impl CarouselWorker {
                     shortest.min(until_next_send)
                 });
 
-            // Removing any expired oneshots
-            self.events
-                .retain(|e| e.event_type != EventType::ExpiredOneshot);
-
             if send_error {
-                break;
+                break Err(CarouselError::EventTrigger);
             }
 
+            // Removing any expired oneshots
+            self.events
+                .retain(|e| e.event_type != EventType::ExpiredOneshot);
             // info!("Waiting for {sleep_time:?}");
         }
-        if send_error {
-            Err(CarouselError::EventTrigger)
-        } else {
-            Ok(())
-        }
     }
 }

src/serial/worker.rs

@@ -154,9 +154,9 @@ impl SerialWorker {
 
                     if let Err(_) = shutdown_tx.send(()) {
                         error!("Failed to reply to shutdown request!");
-                        return Err(WorkerError::ShutdownReply);
+                        break Err(WorkerError::ShutdownReply);
                     } else {
-                        break;
+                        break Ok(());
                     }
                 }
                 Ok(SerialWorkerCommand::PortCommand(port_cmd)) => {
@@ -173,14 +173,11 @@ impl SerialWorker {
                 Err(crossbeam::channel::RecvTimeoutError::Timeout) => (),
                 Err(crossbeam::channel::RecvTimeoutError::Disconnected) => {
                     error!("Serial worker handle got dropped! Shutting down!");
-                    break;
+                    break Err(WorkerError::HandleDropped);
                 }
             }
 
             if let Some(port) = self.port.as_mut_port() {
-                // if port.bytes_to_read().unwrap() == 0 {
-                //     continue;
-                // }
                 // info!(
                 //     "bytes incoming: {}, bytes outcoming: {}",
                 //     port.bytes_to_read().unwrap(),
@@ -215,8 +212,6 @@ impl SerialWorker {
                 }
             }
         }
-
-        Ok(())
     }
 
     fn unhealthy_disconnection(&mut self) {
@@ -658,7 +653,6 @@ impl SerialWorker {
     // and the connection needs to be re-established.
     fn handle_esp_command(&mut self, esp_command: EspCommand) -> Result<(), WorkerError> {
         if !self.port.is_native() {
-            // TODO decide if i wanna keep this or just return Ok(())
             error!("ESP Command given when we don't own native port!");
             return Err(WorkerError::MissingPort);
         }
@@ -1001,6 +995,8 @@ pub(crate) enum WorkerError {
     FailedSend,
     #[error("failed to reply to shutdown request in time")]
     ShutdownReply,
+    #[error("handle dropped, can't recieve commands")]
+    HandleDropped,
 
     #[cfg(feature = "espflash")]
     #[error("espflash error: {0}")]