fix(robot-server): Refactor hardware wrapper and other lifetime dependencies

robot-server/.flake8

@@ -34,5 +34,4 @@ per-file-ignores =
  tests/service/*:ANN,D
  tests/conftest.py:ANN,D
  tests/test_app.py:ANN,D
- tests/test_hardware_wrapper.py:ANN,D
  tests/test_util.py:ANN,D

robot-server/robot_server/__init__.py

@@ -3,7 +3,7 @@
 This server provides the main control interface for an Opentrons robot.
 """
 
-from .app import app
+from .app_setup import app
 
 __all__ = [
  "app",

robot-server/robot_server/app.py → robot-server/robot_server/app_setup.py

@@ -1,5 +1,5 @@
 """Main FastAPI application."""
-import logging
+
 
 from opentrons import __version__
 from fastapi import FastAPI
@@ -8,21 +8,15 @@
 from starlette.requests import Request
 from starlette.middleware.base import RequestResponseEndpoint
 
-from .service.dependencies import (
- get_rpc_server,
- get_protocol_manager,
- get_hardware_wrapper,
- get_session_manager,
-)
-
 from .errors import exception_handlers
 from .router import router
 from .service import initialize_logging
+from . import lifetime_dependencies
 from . import constants
 
-log = logging.getLogger(__name__)
-
 
+# Our global ASGI app object. Our ASGI server (currently Uvicorn) finds this and
+# sends web requests to it.
 app = FastAPI(
  title="Opentrons OT-2 HTTP API Spec",
  description=(
@@ -35,13 +29,15 @@
  version=__version__,
 )
 
+
 # exception handlers
 # TODO(mc, 2021-05-10): after upgrade to FastAPI > 0.61.2, we can pass these
 # to FastAPI's `exception_handlers` arg instead. Current version has bug, see:
 # https://github.com/tiangolo/fastapi/pull/1924
 for exc_cls, handler in exception_handlers.items():
  app.add_exception_handler(exc_cls, handler)
 
+
 # cors
 app.add_middleware(
  CORSMiddleware,
@@ -51,31 +47,9 @@
  allow_headers=["*"],
 )
 
-# main router
-app.include_router(router=router)
-
-
-@app.on_event("startup")
-async def on_startup() -> None:
- """Handle app startup."""
- initialize_logging()
- # Initialize api
- (await get_hardware_wrapper()).async_initialize()
-
-
-@app.on_event("shutdown")
-async def on_shutdown() -> None:
- """Handle app shutdown."""
- s = await get_rpc_server()
- await s.on_shutdown()
- # Remove all sessions
- await (await get_session_manager()).remove_all()
- # Remove all uploaded protocols
- (await get_protocol_manager()).remove_all()
-
 
 @app.middleware("http")
-async def api_version_response_header(
+async def _api_version_response_header(
  request: Request,
  call_next: RequestResponseEndpoint,
 ) -> Response:
@@ -90,3 +64,14 @@ async def api_version_response_header(
  response.headers[constants.API_VERSION_HEADER] = str(request.state.api_version)
  response.headers[constants.MIN_API_VERSION_HEADER] = str(constants.MIN_API_VERSION)
  return response
+
+
+# main router
+app.include_router(router=router)
+
+
+app.on_event("startup")(initialize_logging)
+lifetime_dependencies.install_startup_shutdown_handlers(app)
+
+
+__all__ = ["app"]

robot-server/robot_server/hardware_initialization.py

@@ -0,0 +1,83 @@
+"""Utilities for initializing the hardware interface."""
+
+
+import logging
+from pathlib import Path
+
+from opentrons import ThreadManager, initialize as initialize_api
+from opentrons.hardware_control.simulator_setup import load_simulator
+from opentrons.hardware_control.types import HardwareEvent, HardwareEventType
+from opentrons.util.helpers import utc_now
+
+from notify_server.clients.publisher import Publisher
+from notify_server.models import event, topics
+from notify_server.models.hardware_event import DoorStatePayload
+
+from .settings import get_settings
+
+
+log = logging.getLogger(__name__)
+
+
+async def initialize(event_publisher: Publisher) -> ThreadManager:
+ """Initialize the API."""
+ # todo(mm, 2021-08-12): It would be easier for tests to check that this function
+ # can successfully initialize simulating hardware if app_settings were passed in
+ # as an argument, instead of being fetched here.
+ app_settings = get_settings()
+ thread_manager: ThreadManager
+ if app_settings.simulator_configuration_file_path:
+ log.info(
+ f"Loading simulator from "
+ f"{app_settings.simulator_configuration_file_path}"
+ )
+ # A path to a simulation configuration is defined. Let's use it.
+ thread_manager = ThreadManager(
+ load_simulator, Path(app_settings.simulator_configuration_file_path)
+ )
+ else:
+ # Create the hardware
+ thread_manager = await initialize_api()
+
+ log.info("Starting hardware-event-notify publisher")
+ door_event_forwarder = DoorEventForwarder(event_publisher)
+ # fixme(mm, 2021-08-12): This might be a typing error. forward() can only
+ # take a HardwareEvent, but it looks like ThreadManager can also pass
+ # other things as the argument to a callback?
+ await thread_manager.register_callback(door_event_forwarder.forward)
+
+ log.info("Opentrons API initialized")
+ return thread_manager
+
+
+class DoorEventForwarder:
+ """Forwards front door open/close events to a notify-server publisher."""
+
+ def __init__(self, publisher: Publisher) -> None:
+ """Initialize the `DoorEventForwarder`.
+
+ Params:
+
+ publisher: Where subsequent calls to `forward_hardware_event` will forward
+ to.
+ """
+ self.publisher = publisher
+
+ def forward(self, hardware_event: HardwareEvent) -> None:
+ """Forward `hardware_event` if it's a door event.
+
+ Otherwise, no-op.
+ """
+ if hardware_event.event == HardwareEventType.DOOR_SWITCH_CHANGE:
+ payload = DoorStatePayload(state=hardware_event.new_state)
+ else:
+ return
+ topic = topics.RobotEventTopics.HARDWARE_EVENTS
+ publisher = "robot_server_event_publisher"
+ event_to_publish = event.Event(
+ createdOn=utc_now(), publisher=publisher, data=payload
+ )
+ self.publisher.send_nowait(topic, event_to_publish)
+
+
+__all__ = ["initialize", "DoorEventForwarder"]