Coverage for src/robot_dispatch/workers/dispatcher_worker.py: 88%

59 statements  

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

1from __future__ import annotations 

2 

3import asyncio 

4 

5from robot_dispatch.config import Settings, get_settings 

6from robot_dispatch.infra.redis_lock import NullLock, RedisLock 

7from robot_dispatch.logging_setup import get_logger 

8from robot_dispatch.messaging.outbox_relay import HeartbeatWatchdog, OutboxRelay 

9from robot_dispatch.services.dispatcher import DispatcherService, LeaseReaper 

10from robot_dispatch.services.task_service import RobotService 

11from robot_dispatch.workers.runtime import ( 

12 install_signal_handlers, 

13 periodic, 

14 run, 

15 runtime, 

16) 

17 

18logger = get_logger("dispatcher-worker") 

19 

20 

21class LeadershipGate: 

22 """Keeps the dispatcher single-writer when several replicas run.""" 

23 

24 def __init__(self, lock: RedisLock | NullLock, ttl_ms: int = 10_000) -> None: 

25 self._lock = lock 

26 self._ttl_ms = ttl_ms 

27 self._holding = False 

28 

29 @property 

30 def is_leader(self) -> bool: 

31 return self._holding or not self._lock.available 

32 

33 async def maintain(self, stop: asyncio.Event) -> None: 

34 while not stop.is_set(): 

35 if self._holding: 

36 self._holding = await self._lock.extend() 

37 else: 

38 self._holding = await self._lock.acquire() 

39 if self._holding: 

40 logger.debug("leadership renewed") 

41 try: 

42 await asyncio.wait_for(stop.wait(), timeout=self._ttl_ms / 3000) 

43 except TimeoutError: 

44 continue 

45 if self._holding: 

46 await self._lock.release() 

47 

48 

49async def main() -> None: 

50 settings: Settings = get_settings() 

51 async with runtime(settings) as rt: 

52 dispatcher = DispatcherService(rt.uow_factory, settings) 

53 relay = OutboxRelay(rt.uow_factory, rt.broker, settings) 

54 reaper = LeaseReaper(rt.uow_factory, settings) 

55 watchdog = HeartbeatWatchdog(RobotService(rt.uow_factory), settings) 

56 

57 lock: RedisLock | NullLock = RedisLock(settings.redis_url, ttl_ms=10_000) 

58 if settings.redis_url: 

59 await lock.connect() 

60 else: 

61 lock = NullLock() 

62 gate = LeadershipGate(lock) 

63 

64 stop = asyncio.Event() 

65 install_signal_handlers(stop) 

66 

67 async def dispatch_step() -> None: 

68 if not gate.is_leader: 

69 return 

70 for _ in range(50): 

71 outcome = await dispatcher.dispatch_once() 

72 if not outcome.dispatched: 

73 break 

74 

75 try: 

76 await asyncio.gather( 

77 periodic("dispatch", dispatch_step, settings.dispatcher_poll_interval_ms, stop), 

78 periodic("outbox", relay.relay_once, settings.outbox_poll_interval_ms, stop), 

79 periodic("reaper", reaper.reap_once, settings.reaper_interval_ms, stop), 

80 periodic( 

81 "watchdog", 

82 watchdog.sweep_once, 

83 settings.robot_offline_after_seconds * 1000, 

84 stop, 

85 ), 

86 gate.maintain(stop), 

87 ) 

88 finally: 

89 await lock.close() 

90 

91 

92def cli() -> None: 

93 run(main) 

94 

95 

96if __name__ == "__main__": 

97 cli()