aury-boot 0.0.29__py3-none-any.whl → 0.0.31__py3-none-any.whl

aury/boot/infrastructure/channel/manager.py

@@ -9,8 +9,7 @@ from collections.abc import AsyncIterator
 
 from aury.boot.common.logging import logger
 
-from .backends.memory import MemoryChannel
-from .backends.redis import RedisChannel
+from .backends.broadcaster import BroadcasterChannel
 from .base import ChannelBackend, ChannelMessage, IChannel
 
 
@@ -51,7 +50,6 @@ class ChannelManager:
         self._backend: IChannel | None = None
         self._backend_type: ChannelBackend | None = None
         self._initialized: bool = False
-        self._redis_client = None
         self._url: str | None = None
 
     @classmethod
@@ -84,17 +82,19 @@ class ChannelManager:
 
     async def initialize(
         self,
-        backend: ChannelBackend | str = ChannelBackend.MEMORY,
+        backend: ChannelBackend | str = ChannelBackend.BROADCASTER,
         *,
-        url: str | None = None,
-        max_subscribers: int = 1000,
+        url: str = "memory://",
     ) -> ChannelManager:
         """初始化通道（链式调用）。
 
         Args:
-            backend: 后端类型
-            url: Redis 连接 URL（当 backend=redis 时需要）
-            max_subscribers: 内存后端的最大订阅者数量
+            backend: 后端类型，默认 broadcaster
+            url: 连接 URL，支持：
+                - memory:// - 内存后端（单进程，默认）
+                - redis://host:port/db - Redis Pub/Sub
+                - kafka://host:port - Apache Kafka
+                - postgres://user:pass@host/db - PostgreSQL
 
         Returns:
             self: 支持链式调用
@@ -110,24 +110,28 @@ class ChannelManager:
         self._backend_type = backend
         self._url = url
 
-        if backend == ChannelBackend.MEMORY:
-            self._backend = MemoryChannel(max_subscribers=max_subscribers)
-        elif backend == ChannelBackend.REDIS:
-            if url is None:
-                raise ValueError("Redis 通道需要提供 url 参数")
-            # 内部创建 RedisClient
-            from aury.boot.infrastructure.clients.redis import RedisClient
-
-            self._redis_client = RedisClient()
-            await self._redis_client.configure(url=url).initialize()
-            self._backend = RedisChannel(self._redis_client)
+        if backend == ChannelBackend.BROADCASTER:
+            self._backend = BroadcasterChannel(url)
+        elif backend in (ChannelBackend.RABBITMQ, ChannelBackend.ROCKETMQ):
+            raise NotImplementedError(f"{backend.value} 后端暂未实现")
         else:
             raise ValueError(f"不支持的通道后端: {backend}")
 
         self._initialized = True
-        logger.info(f"通道管理器 [{self.name}] 初始化完成: {backend.value}")
+        logger.info(f"通道管理器 [{self.name}] 初始化完成: {backend.value}, url={self._mask_url(url)}")
         return self
 
+    def _mask_url(self, url: str) -> str:
+        """URL 脱敏（隐藏密码）。"""
+        if "@" in url:
+            parts = url.split("@")
+            prefix = parts[0]
+            suffix = parts[1]
+            if ":" in prefix:
+                scheme_and_user = prefix.rsplit(":", 1)[0]
+                return f"{scheme_and_user}:***@{suffix}"
+        return url
+
     @property
     def backend(self) -> IChannel:
         """获取通道后端。"""
@@ -218,9 +222,6 @@ class ChannelManager:
         if self._backend:
             await self._backend.close()
             self._backend = None
-        if self._redis_client:
-            await self._redis_client.cleanup()
-            self._redis_client = None
         self._initialized = False
         logger.info(f"通道管理器 [{self.name}] 已关闭")
 

aury/boot/infrastructure/database/query_tools/__init__.py

@@ -12,8 +12,8 @@ import time
 
 from aury.boot.common.logging import logger
 
-# 查询性能监控配置
-QUERY_SLOW_THRESHOLD = 1.0  # 慢查询阈值（秒）
+# 默认慢查询阈值（秒）
+DEFAULT_SLOW_QUERY_THRESHOLD = 1.0
 
 
 def cache_query(
@@ -86,7 +86,7 @@ def cache_query(
 
 
 def monitor_query(
-    slow_threshold: float = QUERY_SLOW_THRESHOLD,
+    slow_threshold: float = DEFAULT_SLOW_QUERY_THRESHOLD,
     enable_explain: bool = False,
 ) -> Callable:
     """查询性能监控装饰器。
@@ -104,7 +104,6 @@ def monitor_query(
             async def list(self, **filters):
                 return await super().list(**filters)
     """
-    
     def decorator(func: Callable) -> Callable:
         @wraps(func)
         async def wrapper(self, *args, **kwargs):
@@ -154,7 +153,6 @@ def monitor_query(
     
     return decorator
 
-
 __all__ = [
     "cache_query",
     "monitor_query",

aury/boot/infrastructure/events/__init__.py

@@ -3,12 +3,11 @@
 提供发布/订阅模式的事件总线功能，用于模块间解耦通信。
 
 支持的后端:
-- memory: 内存事件总线（单进程）
-- redis: Redis Pub/Sub（多进程/多实例）
-- rabbitmq: RabbitMQ Exchange（分布式）
+- broadcaster: 基于 broadcaster 库（推荐，支持 memory/redis/kafka/postgres）
+- rabbitmq: RabbitMQ Exchange（复杂消息场景）
 """
 
-from .backends import MemoryEventBus, RabbitMQEventBus, RedisEventBus
+from .backends import BroadcasterEventBus, RabbitMQEventBus
 from .base import Event, EventBackend, EventHandler, EventType, IEventBus
 from .manager import EventBusManager
 
@@ -22,9 +21,8 @@ __all__ = [
     "EventType",
     "IEventBus",
     # 后端实现
-    "MemoryEventBus",
+    "BroadcasterEventBus",
     "RabbitMQEventBus",
-    "RedisEventBus",
 ]
 
 

aury/boot/infrastructure/events/backends/__init__.py

@@ -1,11 +1,9 @@
 """事件总线后端实现。"""
 
-from .memory import MemoryEventBus
+from .broadcaster import BroadcasterEventBus
 from .rabbitmq import RabbitMQEventBus
-from .redis import RedisEventBus
 
 __all__ = [
-    "MemoryEventBus",
+    "BroadcasterEventBus",
     "RabbitMQEventBus",
-    "RedisEventBus",
 ]

aury/boot/infrastructure/events/backends/broadcaster.py

@@ -0,0 +1,189 @@
+"""Broadcaster 事件总线后端。
+
+使用 broadcaster 库实现事件发布/订阅，支持多种后端：
+- memory://  内存（单进程）
+- redis://   Redis Pub/Sub（多进程/多实例）
+- kafka://   Apache Kafka
+- postgres:// PostgreSQL LISTEN/NOTIFY
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+
+from broadcaster import Broadcast
+
+from aury.boot.common.logging import logger
+
+from ..base import Event, EventHandler, IEventBus
+
+# 框架默认前缀
+DEFAULT_CHANNEL_PREFIX = "aury:event:"
+
+
+class BroadcasterEventBus(IEventBus):
+    """Broadcaster 事件总线实现。
+
+    使用 broadcaster 库实现事件发布/订阅。
+    
+    频道命名格式：{channel_prefix}{event_name}
+    默认：aury:event:user.created
+    
+    优点：
+    - 统一接口支持多种后端
+    - 内置连接池管理
+    - 自动重连机制
+    """
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        channel_prefix: str = DEFAULT_CHANNEL_PREFIX,
+    ) -> None:
+        """初始化 Broadcaster 事件总线。
+
+        Args:
+            url: 连接 URL，格式：
+                - memory://          内存（单进程）
+                - redis://host:port  Redis Pub/Sub
+                - kafka://host:port  Apache Kafka
+                - postgres://...     PostgreSQL
+            channel_prefix: 频道名称前缀，默认 "aury:event:"
+
+        """
+        self._url = url
+        self._channel_prefix = channel_prefix
+        self._broadcast: Broadcast | None = None
+        # event_name -> list of handlers (本地订阅)
+        self._handlers: dict[str, list[EventHandler]] = {}
+        self._listener_tasks: dict[str, asyncio.Task] = {}
+        self._running = False
+
+    async def _ensure_connected(self) -> None:
+        """确保已连接。"""
+        if self._broadcast is None:
+            self._broadcast = Broadcast(self._url)
+            await self._broadcast.connect()
+            logger.debug(f"Broadcaster 事件总线已连接: {self._url}")
+
+    def _get_event_name(self, event_type: type[Event] | str) -> str:
+        """获取事件名称。"""
+        if isinstance(event_type, str):
+            return event_type
+        return event_type.__name__
+
+    def _get_channel(self, event_name: str) -> str:
+        """获取频道名称。"""
+        return f"{self._channel_prefix}{event_name}"
+
+    def subscribe(
+        self,
+        event_type: type[Event] | str,
+        handler: EventHandler,
+    ) -> None:
+        """订阅事件。
+
+        注意：这是同步注册 handler，真正的监听在 start_listening() 中启动。
+        """
+        event_name = self._get_event_name(event_type)
+        if event_name not in self._handlers:
+            self._handlers[event_name] = []
+        if handler not in self._handlers[event_name]:
+            self._handlers[event_name].append(handler)
+            logger.debug(f"订阅事件: {event_name} -> {handler.__name__}")
+
+            # 如果已经在运行，立即为新事件启动监听
+            if self._running and event_name not in self._listener_tasks:
+                task = asyncio.create_task(self._listen_event(event_name))
+                self._listener_tasks[event_name] = task
+
+    def unsubscribe(
+        self,
+        event_type: type[Event] | str,
+        handler: EventHandler,
+    ) -> None:
+        """取消订阅事件。"""
+        event_name = self._get_event_name(event_type)
+        if event_name in self._handlers:
+            try:
+                self._handlers[event_name].remove(handler)
+                logger.debug(f"取消订阅事件: {event_name} -> {handler.__name__}")
+                
+                # 如果该事件没有处理器了，停止监听
+                if not self._handlers[event_name] and event_name in self._listener_tasks:
+                    self._listener_tasks[event_name].cancel()
+                    del self._listener_tasks[event_name]
+            except ValueError:
+                pass
+
+    async def publish(self, event: Event) -> None:
+        """发布事件。"""
+        await self._ensure_connected()
+        event_name = event.event_name
+        channel = self._get_channel(event_name)
+        data = json.dumps(event.to_dict())
+        await self._broadcast.publish(channel=channel, message=data)
+
+    async def _listen_event(self, event_name: str) -> None:
+        """监听单个事件的消息。"""
+        channel = self._get_channel(event_name)
+        try:
+            async with self._broadcast.subscribe(channel=channel) as subscriber:
+                async for event_data in subscriber:
+                    if not self._running:
+                        break
+                    try:
+                        data = json.loads(event_data.message)
+                        handlers = self._handlers.get(event_name, [])
+                        for handler in handlers:
+                            try:
+                                event = Event.from_dict(data)
+                                result = handler(event)
+                                if asyncio.iscoroutine(result):
+                                    await result
+                            except Exception as e:
+                                logger.error(f"处理事件 {event_name} 失败: {e}")
+                    except (json.JSONDecodeError, KeyError) as e:
+                        logger.warning(f"解析事件消息失败: {e}")
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"事件监听异常 {event_name}: {e}")
+
+    async def start_listening(self) -> None:
+        """开始监听事件（需要在后台任务中运行）。"""
+        if self._running:
+            return
+
+        await self._ensure_connected()
+        self._running = True
+
+        # 为每个已订阅的事件启动监听任务
+        for event_name in self._handlers:
+            if event_name not in self._listener_tasks:
+                task = asyncio.create_task(self._listen_event(event_name))
+                self._listener_tasks[event_name] = task
+
+        logger.debug(f"Broadcaster 事件总线开始监听，事件数: {len(self._handlers)}")
+
+    async def close(self) -> None:
+        """关闭事件总线。"""
+        self._running = False
+
+        # 取消所有监听任务
+        for task in self._listener_tasks.values():
+            task.cancel()
+        self._listener_tasks.clear()
+
+        # 关闭连接
+        if self._broadcast:
+            await self._broadcast.disconnect()
+            self._broadcast = None
+
+        self._handlers.clear()
+        logger.debug("Broadcaster 事件总线已关闭")
+
+
+__all__ = ["BroadcasterEventBus"]

aury/boot/infrastructure/events/base.py

@@ -15,11 +15,16 @@ import uuid
 
 
 class EventBackend(Enum):
-    """事件总线后端类型。"""
-
-    MEMORY = "memory"
-    REDIS = "redis"
+    """事件总线后端类型。
+    
+    - BROADCASTER: 基于 broadcaster 库，支持 memory/redis/kafka/postgres
+    - RABBITMQ: 专用 RabbitMQ 实现（复杂消息场景）
+    - ROCKETMQ: 专用 RocketMQ 实现（预留）
+    """
+
+    BROADCASTER = "broadcaster"
     RABBITMQ = "rabbitmq"
+    ROCKETMQ = "rocketmq"
 
 
 @dataclass

aury/boot/infrastructure/events/manager.py

@@ -10,14 +10,12 @@ from typing import TYPE_CHECKING, Any
 
 from aury.boot.common.logging import logger
 
-from .backends.memory import MemoryEventBus
+from .backends.broadcaster import BroadcasterEventBus
 from .backends.rabbitmq import RabbitMQEventBus
-from .backends.redis import RedisEventBus
 from .base import Event, EventBackend, EventHandler, IEventBus
 
 if TYPE_CHECKING:
     from aury.boot.application.config import EventInstanceConfig
-    from aury.boot.infrastructure.clients.redis import RedisClient
 
 
 class EventBusManager:
@@ -25,19 +23,19 @@ class EventBusManager:
 
     提供统一的事件总线管理接口，支持：
     - 多实例管理（如 local、distributed 各自独立）
-    - 多后端支持（memory、redis、rabbitmq）
+    - 多后端支持（broadcaster、rabbitmq）
     - 发布/订阅模式
 
     使用示例:
         # 默认实例（内存）
         events = EventBusManager.get_instance()
-        await events.initialize(backend="memory")
+        await events.initialize(backend="broadcaster", url="memory://")
 
-        # 分布式实例
+        # 分布式实例（Redis）
         distributed = EventBusManager.get_instance("distributed")
         await distributed.initialize(
-            backend="redis",
-            redis_client=redis_client,
+            backend="broadcaster",
+            url="redis://localhost:6379/2",
         )
 
         # 订阅事件
@@ -92,10 +90,9 @@ class EventBusManager:
 
     async def initialize(
         self,
-        backend: EventBackend | str = EventBackend.MEMORY,
+        backend: EventBackend | str = EventBackend.BROADCASTER,
         *,
         config: EventInstanceConfig | None = None,
-        redis_client: RedisClient | None = None,
         url: str | None = None,
         channel_prefix: str | None = None,
         exchange_name: str = "aury.events",
@@ -105,9 +102,13 @@ class EventBusManager:
         Args:
             backend: 后端类型（当 config 不为 None 时忽略）
             config: Event 实例配置（推荐，自动根据 backend 初始化）
-            redis_client: Redis 客户端（当 backend=redis 且 config=None 时需要）
-            url: 连接 URL（当 config=None 时需要）
-            channel_prefix: Redis 频道前缀，默认 "aury:event:"
+            url: 连接 URL，格式：
+                - memory://           内存（单进程，默认）
+                - redis://host:port   Redis Pub/Sub
+                - kafka://host:port   Apache Kafka
+                - postgres://...      PostgreSQL
+                - amqp://...          RabbitMQ（需 backend=rabbitmq）
+            channel_prefix: 事件频道前缀，默认 "aury:event:"
             exchange_name: RabbitMQ 交换机名称，默认 "aury.events"
 
         Returns:
@@ -132,17 +133,20 @@ class EventBusManager:
 
         self._backend_type = backend
 
-        # 根据后端类型创建实例，参数校验由后端自己处理
-        if backend == EventBackend.MEMORY:
-            self._backend = MemoryEventBus()
-        elif backend == EventBackend.REDIS:
-            # channel_prefix 为 None 时使用 RedisEventBus 的默认值
-            kwargs = {"url": url, "redis_client": redis_client}
+        # 根据后端类型创建实例
+        if backend == EventBackend.BROADCASTER:
+            # 默认使用内存
+            effective_url = url or "memory://"
+            kwargs: dict[str, Any] = {"url": effective_url}
             if channel_prefix is not None:
                 kwargs["channel_prefix"] = channel_prefix
-            self._backend = RedisEventBus(**kwargs)
+            self._backend = BroadcasterEventBus(**kwargs)
         elif backend == EventBackend.RABBITMQ:
+            if not url:
+                raise ValueError("RabbitMQ 后端需要提供 url 参数")
             self._backend = RabbitMQEventBus(url=url, exchange_name=exchange_name)
+        elif backend == EventBackend.ROCKETMQ:
+            raise NotImplementedError("RocketMQ 后端尚未实现")
         else:
             supported = ", ".join(b.value for b in EventBackend)
             raise ValueError(f"不支持的事件总线后端: {backend}。支持: {supported}")