fix(robot-server): Ensure maintenance runs properly cleanup and manage live stream (#20274)

Covers RQA-4810
When a client ends a maintenance run while another run still exists the live stream will be persisted.

Author: CaseyBatten

api/src/opentrons/system/camera.py

@@ -158,7 +158,7 @@ async def update_live_stream_status(
         and camera_enable_settings.liveStreamEnabled
     ):
         # Check to see if the camera device is available
-        raw_device = str(contents["SOURCE"])[1:-1]
+        raw_device = str(contents["SOURCE"])
         if not os.path.exists(raw_device):
             log.error(
                 f"Opentrons Live Stream cannot sample the camera. No video device found with device path: {raw_device}"

robot-server/robot_server/maintenance_runs/maintenance_run_data_manager.py

@@ -19,6 +19,11 @@
 from opentrons.protocol_engine.types import DeckConfigurationType
 
 from robot_server.service.notifications import MaintenanceRunsPublisher
+from opentrons.protocol_engine.resources.camera_provider import (
+    CameraProvider,
+    CameraSettings,
+)
+from opentrons.system import camera
 
 
 def _build_run(
@@ -92,6 +97,7 @@ async def create(
         labware_offsets: Sequence[LabwareOffsetCreate | LegacyLabwareOffsetCreate],
         deck_configuration: DeckConfigurationType,
         notify_publishers: Callable[[], None],
+        camera_provider: CameraProvider,
     ) -> MaintenanceRun:
         """Create a new, current maintenance run.
 
@@ -100,6 +106,7 @@ async def create(
             created_at: Creation datetime.
             labware_offsets: Labware offsets to initialize the engine with.
             notify_publishers: Utilized by the engine to notify publishers of state changes.
+            camera_provider: Utility for accessing image capture and camera settings.
 
         Returns:
             The run resource.
@@ -115,6 +122,13 @@ async def create(
             notify_publishers=notify_publishers,
         )
 
+        await camera.update_live_stream_status(
+            self._run_orchestrator_store._robot_type,
+            True,
+            camera_provider,
+            state_summary.cameraSettings,
+        )
+
         maintenance_run_data = _build_run(
             run_id=run_id,
             created_at=created_at,
@@ -151,11 +165,18 @@ def get(self, run_id: str) -> MaintenanceRun:
             state_summary=state_summary,
         )
 
-    async def delete(self, run_id: str) -> None:
+    async def delete(
+        self,
+        run_id: str,
+        camera_settings: CameraSettings | None,
+        camera_provider: CameraProvider,
+    ) -> None:
         """Delete a maintenance run.
 
         Args:
             run_id: The identifier of the run to remove.
+            camera_settings: Optional set of camera settings form an external run. If None do not attempt to restart the live stream.
+            camera_provider: Utility for accessing image capture and camera settings.
 
         Raises:
             RunConflictError: If deleting the current run, the current run
@@ -166,6 +187,15 @@ async def delete(self, run_id: str) -> None:
             await self._run_orchestrator_store.clear()
             await self._maintenance_runs_publisher.publish_current_maintenance_run_async()
 
+            if camera_settings is not None:
+                # Restart the live stream for the external run when the maintenance run has ended.
+                await camera.update_live_stream_status(
+                    self._run_orchestrator_store._robot_type,
+                    True,
+                    camera_provider,
+                    camera_settings,
+                )
+
         else:
             raise MaintenanceRunNotFoundError(run_id=run_id)
 

robot-server/robot_server/maintenance_runs/router/base_router.py

@@ -35,12 +35,19 @@
 from ..maintenance_run_orchestrator_store import RunConflictError
 from ..maintenance_run_data_manager import MaintenanceRunDataManager
 from ..dependencies import get_maintenance_run_data_manager
+from robot_server.runs.dependencies import get_run_data_manager
+from robot_server.runs.run_data_manager import RunDataManager
 
 from robot_server.deck_configuration.fastapi_dependencies import (
     get_deck_configuration_store,
 )
 from robot_server.deck_configuration.store import DeckConfigurationStore
 from robot_server.service.notifications import get_pe_notify_publishers
+from robot_server.camera.fastapi_dependencies import (
+    get_camera_provider,
+)
+from opentrons.protocol_engine.resources.camera_provider import CameraProvider
+from opentrons.protocol_engine.types import EngineStatus
 
 log = logging.getLogger(__name__)
 base_router = LightRouter()
@@ -157,6 +164,7 @@ async def create_run(
         DeckConfigurationStore, Depends(get_deck_configuration_store)
     ],
     notify_publishers: Annotated[Callable[[], None], Depends(get_pe_notify_publishers)],
+    camera_provider: Annotated[CameraProvider, Depends(get_camera_provider)],
     request_body: Optional[RequestModel[MaintenanceRunCreate]] = None,
 ) -> PydanticResponse[SimpleBody[MaintenanceRun]]:
     """Create a new maintenance run.
@@ -169,6 +177,7 @@ async def create_run(
         is_ok_to_create_maintenance_run: Verify if a maintenance run may be created if a protocol run exists.
         check_estop: Dependency to verify the estop is in a valid state.
         deck_configuration_store: Dependency to fetch the deck configuration.
+        camera_provider: Dependency to provide access to the Camera Settings to the run.
         notify_publishers: Utilized by the engine to notify publishers of state changes.
     """
     if not is_ok_to_create_maintenance_run:
@@ -185,6 +194,7 @@ async def create_run(
         labware_offsets=offsets,
         deck_configuration=deck_configuration,
         notify_publishers=notify_publishers,
+        camera_provider=camera_provider,
     )
 
     log.info(f'Created an empty run "{run_id}"".')
@@ -267,18 +277,36 @@ async def get_run(
 )
 async def remove_run(
     runId: str,
-    run_data_manager: Annotated[
+    maintenance_run_data_manager: Annotated[
         MaintenanceRunDataManager, Depends(get_maintenance_run_data_manager)
     ],
+    run_data_manager: Annotated[RunDataManager, Depends(get_run_data_manager)],
+    camera_provider: Annotated[CameraProvider, Depends(get_camera_provider)],
 ) -> PydanticResponse[SimpleEmptyBody]:
     """Delete a maintenance run by its ID.
 
     Arguments:
         runId: Run ID pulled from URL.
+        maintenance_run_data_manager: Current maintenance run data management.
         run_data_manager: Current run data management.
+        camera_provider: Utility for accessing image capture and camera settings.
     """
     try:
-        await run_data_manager.delete(runId)
+        camera_settings = None
+        if run_data_manager.current_run_id is not None:
+            # Import the camera settings from an external run if one exists
+            state_summary = run_data_manager._get_good_state_summary(
+                run_data_manager.current_run_id
+            )
+            if (
+                state_summary is not None
+                and state_summary.status is not EngineStatus.FINISHING
+            ):
+                camera_settings = state_summary.cameraSettings
+
+        await maintenance_run_data_manager.delete(
+            runId, camera_settings, camera_provider
+        )
 
     except RunConflictError as e:
         raise RunNotIdle().as_error(status.HTTP_409_CONFLICT) from e

robot-server/robot_server/runs/run_data_manager.py

@@ -207,6 +207,7 @@ async def create(
             created_at: Creation datetime.
             labware_offsets: Labware offsets to initialize the engine with.
             deck_configuration: A mapping of fixtures to cutout fixtures the deck will be loaded with.
+            camera_provider: Utility for accessing image capture and camera settings.
             notify_publishers: Utilized by the engine to notify publishers of state changes.
             run_time_param_values: Any runtime parameter values to set.
             run_time_param_paths: Any runtime filepath to set.

robot-server/tests/maintenance_runs/router/conftest.py

@@ -8,6 +8,7 @@
 from robot_server.maintenance_runs.maintenance_run_data_manager import (
     MaintenanceRunDataManager,
 )
+from robot_server.runs.run_data_manager import RunDataManager
 from opentrons.protocol_engine import ProtocolEngine
 from robot_server.deck_configuration.store import DeckConfigurationStore
 
@@ -28,10 +29,16 @@ def mock_protocol_engine(decoy: Decoy) -> ProtocolEngine:
 
 @pytest.fixture
 def mock_maintenance_run_data_manager(decoy: Decoy) -> MaintenanceRunDataManager:
-    """Get a mock RunDataManager."""
+    """Get a mock MaintenanceRunDataManager."""
     return decoy.mock(cls=MaintenanceRunDataManager)
 
 
+@pytest.fixture
+def mock_run_data_manager(decoy: Decoy) -> RunDataManager:
+    """Get a mock RunDataManager."""
+    return decoy.mock(cls=RunDataManager)
+
+
 @pytest.fixture
 def mock_deck_configuration_store(decoy: Decoy) -> DeckConfigurationStore:
     """Get a mock DeckConfigurationStore."""