Coverage for src/robot_dispatch/workers/runtime.py: 97%

64 statements  

« prev     ^ index     » next       coverage.py v7.17.2, created at 2026-11-07 17:18 +0000

1from __future__ import annotations 

2 

3import asyncio 

4import signal 

5import sys 

6from collections.abc import Awaitable, Callable, Coroutine 

7from contextlib import asynccontextmanager 

8from dataclasses import dataclass 

9from typing import Any 

10 

11from sqlalchemy.ext.asyncio import AsyncEngine 

12 

13from robot_dispatch.config import Settings 

14from robot_dispatch.db.session import create_engine, create_session_factory 

15from robot_dispatch.db.uow import make_sql_uow_factory 

16from robot_dispatch.logging_setup import configure_logging, get_logger 

17from robot_dispatch.messaging.broker import Broker 

18 

19logger = get_logger("worker") 

20 

21 

22@dataclass 

23class Runtime: 

24 settings: Settings 

25 engine: AsyncEngine 

26 uow_factory: Callable 

27 broker: Broker 

28 

29 

30@asynccontextmanager 

31async def runtime(settings: Settings): 

32 configure_logging(settings.log_level, settings.log_json) 

33 engine = create_engine(settings.database_url) 

34 uow_factory = make_sql_uow_factory(create_session_factory(engine)) 

35 broker = Broker( 

36 settings.rabbitmq_url, 

37 prefetch=settings.consumer_prefetch, 

38 connect_retries=settings.rabbitmq_connect_retries, 

39 connect_delay=settings.rabbitmq_connect_delay_seconds, 

40 ) 

41 await broker.connect() 

42 

43 try: 

44 async with uow_factory() as uow: 

45 robot_ids = [robot.id for robot in await uow.robots.list()] 

46 for robot_id in robot_ids: 

47 await broker.ensure_robot_queue(robot_id) 

48 logger.info("robot queues ensured", count=len(robot_ids)) 

49 except Exception as exc: # noqa: BLE001 - schema may not be migrated yet 

50 logger.warning("cannot pre-declare robot queues", error=str(exc)) 

51 

52 try: 

53 yield Runtime(settings=settings, engine=engine, uow_factory=uow_factory, broker=broker) 

54 finally: 

55 await broker.close() 

56 await engine.dispose() 

57 

58 

59def install_signal_handlers(stop: asyncio.Event) -> None: 

60 try: 

61 loop = asyncio.get_running_loop() 

62 for sig in (signal.SIGINT, signal.SIGTERM): 

63 loop.add_signal_handler(sig, stop.set) 

64 except (NotImplementedError, RuntimeError, AttributeError): 

65 # Windows event loop has no add_signal_handler; KeyboardInterrupt ends the run. 

66 pass 

67 

68 

69async def periodic( 

70 name: str, 

71 step: Callable[[], Awaitable[object]], 

72 interval_ms: int, 

73 stop: asyncio.Event, 

74) -> None: 

75 """Run `step` forever, swallowing per-iteration failures with a log entry.""" 

76 logger.info("loop started", loop=name, interval_ms=interval_ms) 

77 while not stop.is_set(): 

78 try: 

79 await step() 

80 except asyncio.CancelledError: 

81 raise 

82 except Exception: # noqa: BLE001 - a loop must survive a single bad iteration 

83 logger.exception("loop iteration failed", loop=name) 

84 try: 

85 await asyncio.wait_for(stop.wait(), timeout=max(interval_ms, 1) / 1000) 

86 except TimeoutError: 

87 continue 

88 logger.info("loop stopped", loop=name) 

89 

90 

91def run(main_coro_factory: Callable[[], Coroutine[Any, Any, None]]) -> None: 

92 try: 

93 asyncio.run(main_coro_factory()) 

94 except KeyboardInterrupt: # pragma: no cover - interactive shutdown 

95 sys.exit(0)