refactor: better error reporting

Author: robgee86

src/arduino/app_peripherals/camera/base_camera.py

@@ -95,6 +95,9 @@ def start(self) -> None:
                     self._is_started = True
                     self._last_capture_time = time.monotonic()
                     self.logger.info(f"Successfully started {self.name}")
+                except CameraOpenError as e:  # We consider this a fatal error so we don't retry
+                    self.logger.error(f"Fatal error while starting {self.name}: {e}")
+                    raise
                 except Exception as e:
                     if not self.auto_reconnect:
                         raise
@@ -106,7 +109,8 @@ def start(self) -> None:
 
                     delay = min(self.auto_reconnect_delay * (2 ** (attempt - 1)), 60)  # Exponential backoff
                     self.logger.warning(
-                        f"Failed to start camera {self.name} (attempt {attempt}/{self.first_connection_max_retries}). Retrying in {delay:.1f}s..."
+                        f"Failed attempt {attempt}/{self.first_connection_max_retries} at starting camera {self.name}: {e}. "
+                        f"Retrying in {delay:.1f}s..."
                     )
                     time.sleep(delay)
 

src/arduino/app_peripherals/camera/ip_camera.py

@@ -82,22 +82,17 @@ def _open_camera(self) -> None:
         try:
             self._cap = cv2.VideoCapture(url)
             if not self._cap.isOpened():
-                raise CameraOpenError(f"Failed to open IP camera at {self.url}")
+                raise RuntimeError(f"Failed to open IP camera at {self.url}")
 
             self._cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)  # Reduce buffer to minimize latency
 
             # Test by reading one frame
             ret, frame = self._cap.read()
             if not ret and frame is None:
-                raise CameraOpenError(f"Read test failed for IP camera at {self.url}")
+                raise RuntimeError(f"Read test failed for IP camera at {self.url}")
 
             self._set_status("connected", {"camera_url": self.url})
 
-        except CameraOpenError:
-            if self._cap is not None:
-                self._cap.release()
-                self._cap = None
-            raise
         except Exception as e:
             logger.error(f"Unexpected error opening IP camera at {self.url}: {e}")
             if self._cap is not None:
@@ -130,10 +125,10 @@ def _test_http_connectivity(self) -> None:
             response = requests.head(self.url, auth=auth, timeout=self.timeout, allow_redirects=True)
 
             if response.status_code not in [200, 206]:  # 206 for partial content
-                raise CameraOpenError(f"HTTP camera returned status {response.status_code}: {self.url}")
+                raise RuntimeError(f"HTTP camera returned status {response.status_code}: {self.url}")
 
         except requests.RequestException as e:
-            raise CameraOpenError(f"Cannot connect to HTTP camera {self.url}: {e}")
+            raise RuntimeError(f"Cannot connect to HTTP camera {self.url}: {e}")
 
     def _close_camera(self) -> None:
         """Close the IP camera connection."""

src/arduino/app_peripherals/camera/v4l_camera.py

@@ -152,12 +152,12 @@ def _open_camera(self) -> None:
         self._close_camera()
 
         if not os.path.exists(self.v4l_path):
-            raise CameraOpenError(f"No device found at {self.v4l_path}")
+            raise RuntimeError(f"No device found at {self.v4l_path}")
 
         try:
             self._cap = cv2.VideoCapture(self.v4l_path)
             if not self._cap.isOpened():
-                raise CameraOpenError(f"Failed to open camera {self.name}")
+                raise RuntimeError(f"Failed to open camera {self.name}")
 
             self._cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)  # Reduce buffer to minimize latency
 
@@ -186,15 +186,10 @@ def _open_camera(self) -> None:
             # Verify camera with a test read
             ret, frame = self._cap.read()
             if not ret and frame is None:
-                raise CameraOpenError(f"Read test failed for camera {self.name}")
+                raise RuntimeError(f"Read test failed for camera {self.name}")
 
             self._set_status("connected", {"camera_name": self.name, "camera_path": self.v4l_path})
 
-        except CameraOpenError:
-            if self._cap is not None:
-                self._cap.release()
-                self._cap = None
-            raise
         except Exception as e:
             logger.error(f"Unexpected error opening camera {self.name}: {e}")
             if self._cap is not None:

src/arduino/app_peripherals/camera/websocket_camera.py

@@ -13,7 +13,7 @@
 import websockets
 import asyncio
 from collections.abc import Callable
-from concurrent.futures import CancelledError, TimeoutError
+from concurrent.futures import CancelledError, TimeoutError, Future
 
 from arduino.app_internal.core.peripherals import BPPCodec
 from arduino.app_utils import Logger
@@ -138,37 +138,33 @@ def security_mode(self) -> str:
 
     def _open_camera(self) -> None:
         """Start the WebSocket server."""
-        self._server_thread = threading.Thread(target=self._start_server_thread, daemon=True)
-        self._server_thread.start()
-
-        # Wait for server to start
-        start_time = time.time()
-        while time.time() - start_time < self.timeout:
-            if self._server is not None:
-                self.logger.info(f"WebSocket camera server started on {self.url}, security: {self.security_mode}")
-                return
-            time.sleep(0.1)
+        server_future = Future()
 
-        # Cleanup server thread if it failed to start in time
-        if self._server_thread.is_alive():
-            self._server_thread.join(timeout=1.0)
-
-        raise CameraOpenError(f"Failed to start WebSocket server on {self.url}")
+        self._server_thread = threading.Thread(target=self._start_server_thread, args=(server_future,), daemon=True)
+        self._server_thread.start()
 
-    def _start_server_thread(self) -> None:
+        try:
+            server_future.result(timeout=self.timeout)
+            self.logger.info(f"WebSocket camera server available on {self.url}, security: {self.security_mode}")
+        except (PermissionError, Exception) as e:
+            if self._server_thread.is_alive():
+                self._server_thread.join(timeout=1.0)
+            if isinstance(e, PermissionError):
+                raise CameraOpenError(f"Permission denied when attempting to bind WebSocket server on {self.url}")
+            raise
+            
+    def _start_server_thread(self, future: Future) -> None:
         """Run WebSocket server in its own thread with event loop."""
         try:
             self._loop = asyncio.new_event_loop()
             asyncio.set_event_loop(self._loop)
-            self._loop.run_until_complete(self._start_server())
-        except Exception as e:
-            self.logger.error(f"WebSocket server thread error: {e}")
+            self._loop.run_until_complete(self._start_server(future))
         finally:
             if self._loop and not self._loop.is_closed():
                 self._loop.close()
                 self._loop = None
 
-    async def _start_server(self) -> None:
+    async def _start_server(self, future: Future) -> None:
         """Start the WebSocket server."""
         try:
             self._server = await asyncio.wait_for(
@@ -191,14 +187,12 @@ async def _start_server(self) -> None:
                 server_socket = list(self._server.sockets)[0]
                 self.port = server_socket.getsockname()[1]
 
+            future.set_result(True)
+
             await self._server.wait_closed()
 
-        except TimeoutError as e:
-            self.logger.error(f"Failed to start WebSocket server within {self.timeout}s: {e}")
-            raise
         except Exception as e:
-            self.logger.error(f"Failed to start WebSocket server: {e}")
-            raise
+            future.set_exception(e)
         finally:
             self._server = None