Files
mtusi2026lab5/src/messenger/shared/application/messagebus.py
T

117 lines
3.7 KiB
Python

import asyncio
from collections.abc import Awaitable, Callable, Mapping, Sequence
from contextlib import suppress
from typing import Any
from messenger.shared.application.commands import Command
from messenger.shared.application.ports import EventPublisher, Logger, UnitOfWork
from messenger.shared.domain.events import DomainEvent
type CommandHandler = Callable[[Any], Awaitable[Any]]
type EventHandler[EventT: DomainEvent] = Callable[[EventT], Awaitable[None]]
class CommandBus:
__slots__ = ("_handlers", "_publisher", "_uow")
def __init__(
self,
handlers: Mapping[type[Command], CommandHandler],
uow: UnitOfWork,
publisher: EventPublisher,
) -> None:
self._handlers = handlers
self._uow = uow
self._publisher = publisher
async def execute(self, command: Command) -> Any:
handler = self._handlers.get(type(command))
if handler is None:
raise LookupError(f"нет обработчика для команды {type(command).__name__}")
try:
return await handler(command)
finally:
events = self._uow.collect_new_events()
if events:
await self._publisher.publish(events)
class EventBus:
__slots__ = ("_deferred", "_dropped", "_logger", "_queue", "_worker")
def __init__(self, logger: Logger, *, max_queue: int = 10_000) -> None:
self._logger = logger
self._queue: asyncio.Queue[DomainEvent] = asyncio.Queue(maxsize=max_queue)
self._deferred: dict[type[DomainEvent], list[Any]] = {}
self._worker: asyncio.Task[None] | None = None
self._dropped = 0
def subscribe[EventT: DomainEvent](
self, event_type: type[EventT], handler: EventHandler[EventT]
) -> None:
self._deferred.setdefault(event_type, []).append(handler)
async def emit(self, event: DomainEvent) -> bool:
if not self._deferred.get(type(event)):
return True
try:
self._queue.put_nowait(event)
except asyncio.QueueFull:
self._dropped += 1
self._logger.warning(
"event.dropped", event_name=event.name, dropped_total=self._dropped
)
return False
return True
@property
def dropped(self) -> int:
return self._dropped
@property
def pending(self) -> int:
return self._queue.qsize()
def start(self) -> None:
if self._worker is None:
self._worker = asyncio.create_task(self._drain())
async def stop(self) -> None:
if self._worker is None:
return
await self._queue.join()
self._worker.cancel()
with suppress(asyncio.CancelledError):
await self._worker
self._worker = None
async def _drain(self) -> None:
while True:
event = await self._queue.get()
try:
await self._run(self._deferred.get(type(event), []), event)
finally:
self._queue.task_done()
async def _run(self, handlers: Sequence[Any], event: DomainEvent) -> None:
for handler in handlers:
try:
await handler(event)
except Exception as error:
self._logger.error(
"event.handler_failed",
event_name=event.name,
error=type(error).__name__,
)
class InMemoryEventPublisher:
__slots__ = ("_bus",)
def __init__(self, bus: EventBus) -> None:
self._bus = bus
async def publish(self, events: Sequence[DomainEvent]) -> None:
for event in events:
await self._bus.emit(event)