aury-boot 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

aury/boot/infrastructure/database/manager.py

@@ -14,7 +14,6 @@ from sqlalchemy.exc import DisconnectionError, OperationalError
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
 
 from aury.boot.common.logging import logger
-from aury.boot.infrastructure.database.config import DatabaseConfig
 
 
 class DatabaseManager:
@@ -55,7 +54,6 @@ class DatabaseManager:
         """
         self.name = name
         self._initialized: bool = False
-        self._config: DatabaseConfig | None = None
         self._engine: AsyncEngine | None = None
         self._session_factory: async_sessionmaker | None = None
         self._max_retries: int = 3
@@ -89,14 +87,6 @@ class DatabaseManager:
         elif name in cls._instances:
             del cls._instances[name]
     
-    def configure(self, config: DatabaseConfig) -> None:
-        """配置数据库管理器。
-        
-        Args:
-            config: 数据库配置
-        """
-        self._config = config
-    
     @property
     def engine(self) -> AsyncEngine:
         """获取数据库引擎。"""
@@ -142,33 +132,21 @@ class DatabaseManager:
             logger.warning("数据库管理器已初始化，跳过重复初始化")
             return
         
-        # 使用提供的参数或配置中的默认值
-        db_isolation_level: str | None = None
-        if self._config is not None:
-            database_url = url or self._config.url
-            db_echo = echo if echo is not None else self._config.echo
-            db_pool_size = pool_size or self._config.pool_size
-            db_max_overflow = max_overflow or self._config.max_overflow
-            db_pool_timeout = pool_timeout or self._config.pool_timeout
-            db_pool_recycle = pool_recycle or self._config.pool_recycle
-            db_isolation_level = isolation_level or self._config.isolation_level
-        else:
-            # 如果没有配置，使用环境变量
-            import os
-            database_url = url or os.getenv("DATABASE_URL")
-            if not database_url:
-                raise ValueError(
-                    "数据库 URL 未配置。请通过以下方式之一提供："
-                    "1. 使用 DatabaseManager.configure() 设置配置"
-                    "2. 通过 initialize(url=...) 参数传入"
-                    "3. 设置环境变量 DATABASE_URL"
-                )
-            db_echo = echo if echo is not None else os.getenv("DB_ECHO", "false").lower() == "true"
-            db_pool_size = pool_size or int(os.getenv("DB_POOL_SIZE", "5"))
-            db_max_overflow = max_overflow or int(os.getenv("DB_MAX_OVERFLOW", "10"))
-            db_pool_timeout = pool_timeout or int(os.getenv("DB_POOL_TIMEOUT", "30"))
-            db_pool_recycle = pool_recycle or int(os.getenv("DB_POOL_RECYCLE", "1800"))
-            db_isolation_level = isolation_level or os.getenv("DATABASE_ISOLATION_LEVEL")
+        # 使用提供的参数或环境变量默认值
+        import os
+        database_url = url or os.getenv("DATABASE_URL")
+        if not database_url:
+            raise ValueError(
+                "数据库 URL 未配置。请通过以下方式之一提供："
+                "1. 通过 initialize(url=...) 参数传入"
+                "2. 设置环境变量 DATABASE_URL"
+            )
+        db_echo = echo if echo is not None else os.getenv("DB_ECHO", "false").lower() == "true"
+        db_pool_size = pool_size or int(os.getenv("DB_POOL_SIZE", "5"))
+        db_max_overflow = max_overflow or int(os.getenv("DB_MAX_OVERFLOW", "10"))
+        db_pool_timeout = pool_timeout or int(os.getenv("DB_POOL_TIMEOUT", "30"))
+        db_pool_recycle = pool_recycle or int(os.getenv("DB_POOL_RECYCLE", "1800"))
+        db_isolation_level = isolation_level or os.getenv("DATABASE_ISOLATION_LEVEL")
         
         # 构建引擎参数
         engine_kwargs: dict = {
@@ -279,7 +257,7 @@ class DatabaseManager:
         await self._check_session_connection(session)
         return session
     
-    async def get_session(self) -> AsyncGenerator[AsyncSession, None]:
+    async def get_session(self) -> AsyncGenerator[AsyncSession]:
         """FastAPI 依赖注入专用的会话获取器。
         
         Yields:

aury/boot/infrastructure/events/__init__.py

@@ -1,33 +1,30 @@
-"""事件系统 - 基于 Kombu 消息队列的分布式事件总线。
+"""事件总线模块。
 
-提供事件基础定义、发布/订阅机制，实现模块间的解耦。
-支持本地模式（内存）和分布式模式（Kombu 消息队列）。
+提供发布/订阅模式的事件总线功能，用于模块间解耦通信。
 
-**架构说明**：
-Event 基类定义在 infrastructure 层，这是最底层的公共数据结构。
-Domain 层依赖 infrastructure.events 获取 Event 基类。
-这样完全断开了 infrastructure 对 domain 的循环依赖。
-
-事件模型定义在单独的 models.py 文件中，避免循环导入问题。
+支持的后端:
+- memory: 内存事件总线（单进程）
+- redis: Redis Pub/Sub（多进程/多实例）
+- rabbitmq: RabbitMQ Exchange（分布式）
 """
 
-from __future__ import annotations
-
-from .bus import EventBus
-from .config import EventConfig
-from .consumer import EventConsumer
-from .middleware import EventLoggingMiddleware, EventMiddleware
-from .models import Event, EventHandler, EventType
+from .backends import MemoryEventBus, RabbitMQEventBus, RedisEventBus
+from .base import Event, EventBackend, EventHandler, EventType, IEventBus
+from .manager import EventBusManager
 
 __all__ = [
+    # 接口和类型
     "Event",
-    "EventBus",
-    "EventConfig",
-    "EventConsumer",
+    "EventBackend",
+    # 管理器
+    "EventBusManager",
     "EventHandler",
-    "EventLoggingMiddleware",
-    "EventMiddleware",
     "EventType",
+    "IEventBus",
+    # 后端实现
+    "MemoryEventBus",
+    "RabbitMQEventBus",
+    "RedisEventBus",
 ]
 
 

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

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

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

@@ -0,0 +1,86 @@
+"""内存事件总线后端。
+
+适用于单进程场景，如开发环境或简单应用。
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from typing import Any
+
+from aury.boot.common.logging import logger
+
+from ..base import Event, EventHandler, IEventBus
+
+
+class MemoryEventBus(IEventBus):
+    """内存事件总线实现。
+
+    使用内存中的字典存储订阅关系，支持同步和异步处理器。
+
+    注意：仅适用于单进程，不支持跨进程事件传递。
+    """
+
+    def __init__(self) -> None:
+        """初始化内存事件总线。"""
+        # event_name -> list of handlers
+        self._handlers: dict[str, list[EventHandler]] = {}
+
+    def _get_event_name(self, event_type: type[Event] | str) -> str:
+        """获取事件名称。"""
+        if isinstance(event_type, str):
+            return event_type
+        return event_type.__name__
+
+    def subscribe(
+        self,
+        event_type: type[Event] | str,
+        handler: EventHandler,
+    ) -> None:
+        """订阅事件。"""
+        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__}")
+
+    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__}")
+            except ValueError:
+                pass
+
+    async def publish(self, event: Event) -> None:
+        """发布事件。"""
+        event_name = event.event_name
+        handlers = self._handlers.get(event_name, [])
+
+        if not handlers:
+            logger.debug(f"事件 {event_name} 没有订阅者")
+            return
+
+        for handler in handlers:
+            try:
+                result = handler(event)
+                if asyncio.iscoroutine(result):
+                    await result
+            except Exception as e:
+                logger.error(f"处理事件 {event_name} 失败: {e}")
+
+    async def close(self) -> None:
+        """关闭事件总线。"""
+        self._handlers.clear()
+        logger.debug("内存事件总线已关闭")
+
+
+__all__ = ["MemoryEventBus"]

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

@@ -0,0 +1,193 @@
+"""RabbitMQ 事件总线后端。
+
+使用 aio-pika 实现 RabbitMQ 事件总线。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+
+from aury.boot.common.logging import logger
+
+from ..base import Event, EventHandler, IEventBus
+
+# 延迟导入 aio-pika（可选依赖）
+try:
+    import aio_pika
+    from aio_pika import ExchangeType
+    from aio_pika import Message as AioPikaMessage
+    from aio_pika.abc import AbstractChannel, AbstractConnection, AbstractExchange
+
+    _AIO_PIKA_AVAILABLE = True
+except ImportError:
+    _AIO_PIKA_AVAILABLE = False
+    aio_pika = None
+    ExchangeType = None
+    AioPikaMessage = None
+    AbstractChannel = None
+    AbstractConnection = None
+    AbstractExchange = None
+
+
+class RabbitMQEventBus(IEventBus):
+    """RabbitMQ 事件总线实现。
+
+    使用 RabbitMQ Exchange (fanout/topic) 实现事件发布/订阅。
+
+    注意：需要安装 aio-pika: pip install aio-pika
+    """
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        exchange_name: str = "events",
+        exchange_type: str = "topic",
+    ) -> None:
+        """初始化 RabbitMQ 事件总线。
+
+        Args:
+            url: RabbitMQ 连接 URL
+            exchange_name: 交换机名称
+            exchange_type: 交换机类型 (topic/fanout)
+        """
+        if not _AIO_PIKA_AVAILABLE:
+            raise ImportError("aio-pika 未安装。请安装: pip install aio-pika")
+
+        self._url = url
+        self._exchange_name = exchange_name
+        self._exchange_type = exchange_type
+        self._connection: AbstractConnection | None = None
+        self._channel: AbstractChannel | None = None
+        self._exchange: AbstractExchange | None = None
+        # event_name -> list of handlers
+        self._handlers: dict[str, list[EventHandler]] = {}
+        self._consumer_tasks: list[asyncio.Task] = []
+        self._running = False
+
+    async def _ensure_connection(self) -> None:
+        """确保连接已建立。"""
+        if self._connection is None or self._connection.is_closed:
+            self._connection = await aio_pika.connect_robust(self._url)
+            self._channel = await self._connection.channel()
+
+            # 声明交换机
+            exchange_type = (
+                ExchangeType.TOPIC
+                if self._exchange_type == "topic"
+                else ExchangeType.FANOUT
+            )
+            self._exchange = await self._channel.declare_exchange(
+                self._exchange_name,
+                exchange_type,
+                durable=True,
+            )
+            logger.info("RabbitMQ 事件总线连接已建立")
+
+    def _get_event_name(self, event_type: type[Event] | str) -> str:
+        """获取事件名称。"""
+        if isinstance(event_type, str):
+            return event_type
+        return event_type.__name__
+
+    def subscribe(
+        self,
+        event_type: type[Event] | str,
+        handler: EventHandler,
+    ) -> None:
+        """订阅事件。"""
+        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__}")
+
+    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__}")
+            except ValueError:
+                pass
+
+    async def publish(self, event: Event) -> None:
+        """发布事件。"""
+        await self._ensure_connection()
+        event_name = event.event_name
+        data = json.dumps(event.to_dict())
+
+        message = AioPikaMessage(
+            body=data.encode(),
+            content_type="application/json",
+        )
+
+        # 使用事件名称作为 routing key
+        await self._exchange.publish(message, routing_key=event_name)
+
+    async def start_listening(self) -> None:
+        """开始监听事件（需要在后台任务中运行）。"""
+        await self._ensure_connection()
+        self._running = True
+
+        # 为每个事件类型创建队列和消费者
+        for event_name in self._handlers:
+            queue = await self._channel.declare_queue(
+                f"events.{event_name}",
+                durable=True,
+            )
+            await queue.bind(self._exchange, routing_key=event_name)
+
+            async def process_message(message, en=event_name):
+                async with message.process():
+                    try:
+                        data = json.loads(message.body.decode())
+                        handlers = self._handlers.get(en, [])
+                        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"处理事件 {en} 失败: {e}")
+                    except Exception as e:
+                        logger.warning(f"解析事件消息失败: {e}")
+
+            task = asyncio.create_task(self._consume_queue(queue, process_message))
+            self._consumer_tasks.append(task)
+
+    async def _consume_queue(self, queue, callback) -> None:
+        """消费队列消息。"""
+        async with queue.iterator() as queue_iter:
+            async for message in queue_iter:
+                if not self._running:
+                    break
+                await callback(message)
+
+    async def close(self) -> None:
+        """关闭事件总线。"""
+        self._running = False
+        for task in self._consumer_tasks:
+            task.cancel()
+        self._consumer_tasks.clear()
+
+        if self._connection:
+            await self._connection.close()
+            self._connection = None
+            self._channel = None
+            self._exchange = None
+
+        self._handlers.clear()
+        logger.debug("RabbitMQ 事件总线已关闭")
+
+
+__all__ = ["RabbitMQEventBus"]

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

@@ -0,0 +1,162 @@
+"""Redis 事件总线后端。
+
+适用于多进程/多实例场景，支持跨进程事件传递。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import TYPE_CHECKING
+
+from aury.boot.common.logging import logger
+
+from ..base import Event, EventHandler, IEventBus
+
+if TYPE_CHECKING:
+    from aury.boot.infrastructure.clients.redis import RedisClient
+
+
+class RedisEventBus(IEventBus):
+    """Redis 事件总线实现。
+
+    使用 Redis Pub/Sub 实现跨进程的事件发布/订阅。
+    """
+
+    def __init__(
+        self,
+        url: str | None = None,
+        *,
+        redis_client: RedisClient | None = None,
+        channel_prefix: str = "events:",
+    ) -> None:
+        """初始化 Redis 事件总线。
+
+        Args:
+            url: Redis 连接 URL（当 redis_client 为 None 时必须提供）
+            redis_client: RedisClient 实例（可选，优先使用）
+            channel_prefix: 频道名称前缀
+        
+        Raises:
+            ValueError: 当 url 和 redis_client 都为 None 时
+        """
+        if redis_client is None and url is None:
+            raise ValueError("Redis 事件总线需要提供 url 或 redis_client 参数")
+        
+        self._url = url
+        self._client = redis_client
+        self._channel_prefix = channel_prefix
+        # event_name -> list of handlers (本地订阅)
+        self._handlers: dict[str, list[EventHandler]] = {}
+        self._pubsub = None
+        self._listener_task: asyncio.Task | None = None
+        self._running = False
+        self._owns_client = False  # 是否自己创建的客户端
+    
+    async def _ensure_client(self) -> None:
+        """确保 Redis 客户端已初始化。"""
+        if self._client is None and self._url:
+            from aury.boot.infrastructure.clients.redis import RedisClient
+            self._client = RedisClient()
+            await self._client.initialize(url=self._url)
+            self._owns_client = True
+
+    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:
+        """获取 Redis 频道名称。"""
+        return f"{self._channel_prefix}{event_name}"
+
+    def subscribe(
+        self,
+        event_type: type[Event] | str,
+        handler: EventHandler,
+    ) -> None:
+        """订阅事件。"""
+        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__}")
+
+    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__}")
+            except ValueError:
+                pass
+
+    async def publish(self, event: Event) -> None:
+        """发布事件。"""
+        await self._ensure_client()
+        event_name = event.event_name
+        channel = self._get_channel(event_name)
+        data = json.dumps(event.to_dict())
+        await self._client.connection.publish(channel, data)
+
+    async def start_listening(self) -> None:
+        """开始监听事件（需要在后台任务中运行）。"""
+        if self._running:
+            return
+        
+        await self._ensure_client()
+        self._pubsub = self._client.connection.pubsub()
+        self._running = True
+
+        # 订阅所有已注册事件的频道
+        channels = [self._get_channel(name) for name in self._handlers]
+        if channels:
+            await self._pubsub.subscribe(*channels)
+
+        # 监听消息
+        async for message in self._pubsub.listen():
+            if not self._running:
+                break
+
+            if message["type"] == "message":
+                try:
+                    data = json.loads(message["data"])
+                    event_name = data.get("event_name")
+                    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}")
+
+    async def close(self) -> None:
+        """关闭事件总线。"""
+        self._running = False
+        if self._pubsub:
+            await self._pubsub.close()
+            self._pubsub = None
+        if self._listener_task:
+            self._listener_task.cancel()
+            self._listener_task = None
+        if self._owns_client and self._client:
+            await self._client.close()
+            self._client = None
+        self._handlers.clear()
+        logger.debug("Redis 事件总线已关闭")
+
+
+__all__ = ["RedisEventBus"]