aury-boot 0.0.4__py3-none-any.whl → 0.0.7__py3-none-any.whl

aury/boot/application/app/startup.py

@@ -0,0 +1,249 @@
+"""启动日志工具。
+
+提供应用启动时的组件状态打印功能，包括 URL 脱敏。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import re
+from typing import Any
+
+from aury.boot.common.logging import logger
+
+
+@dataclass
+class ComponentStatus:
+    """组件状态。"""
+
+    name: str
+    status: str  # "ok", "error", "disabled"
+    backend: str | None = None
+    url: str | None = None
+    details: dict[str, Any] = field(default_factory=dict)
+
+
+def mask_url(url: str | None) -> str:
+    """URL 脱敏（隐藏密码和敏感信息）。
+
+    Args:
+        url: 原始 URL
+
+    Returns:
+        脱敏后的 URL
+    """
+    if not url:
+        return "N/A"
+
+    # 匹配常见 URL 格式中的密码部分
+    # redis://:password@host:port/db
+    # amqp://user:password@host:port/vhost
+    # postgresql://user:password@host:port/db
+    patterns = [
+        # user:password@ 格式
+        (r"(://[^:]+:)([^@]+)(@)", r"\1***\3"),
+        # :password@ 格式 (无用户名)
+        (r"(://:)([^@]+)(@)", r"\1***\3"),
+    ]
+
+    masked = url
+    for pattern, replacement in patterns:
+        masked = re.sub(pattern, replacement, masked)
+
+    return masked
+
+
+def print_startup_banner(
+    app_name: str = "Aury Boot",
+    version: str = "",
+    components: list[ComponentStatus] | None = None,
+) -> None:
+    """打印启动横幅和组件状态。
+
+    Args:
+        app_name: 应用名称
+        version: 版本号
+        components: 组件状态列表
+    """
+    # 打印横幅
+    banner = f"""
+╔══════════════════════════════════════════════════════════════╗
+║  {app_name:^58}  ║
+║  {f'v{version}' if version else '':^58}  ║
+╚══════════════════════════════════════════════════════════════╝
+"""
+    logger.info(banner)
+
+    # 打印组件状态
+    if components:
+        logger.info("组件状态:")
+        logger.info("-" * 60)
+
+        for comp in components:
+            status_icon = "✓" if comp.status == "ok" else "✗" if comp.status == "error" else "○"
+            status_text = f"[{status_icon}] {comp.name}"
+
+            if comp.backend:
+                status_text += f" ({comp.backend})"
+
+            if comp.url:
+                status_text += f" -> {mask_url(comp.url)}"
+
+            if comp.status == "error" and comp.details.get("error"):
+                status_text += f" | Error: {comp.details['error']}"
+
+            logger.info(f"  {status_text}")
+
+        logger.info("-" * 60)
+
+
+def collect_component_status() -> list[ComponentStatus]:
+    """收集所有组件状态。
+
+    Returns:
+        组件状态列表
+    """
+    from aury.boot.infrastructure.cache import CacheManager
+    from aury.boot.infrastructure.database import DatabaseManager
+    from aury.boot.infrastructure.scheduler import SchedulerManager
+    from aury.boot.infrastructure.storage import StorageManager
+
+    # 延迟导入新模块（可能不存在）
+    try:
+        from aury.boot.infrastructure.clients.redis import RedisClient
+    except ImportError:
+        RedisClient = None
+
+    try:
+        from aury.boot.infrastructure.channel import ChannelManager
+    except ImportError:
+        ChannelManager = None
+
+    try:
+        from aury.boot.infrastructure.mq import MQManager
+    except ImportError:
+        MQManager = None
+
+    try:
+        from aury.boot.infrastructure.events import EventBusManager
+    except ImportError:
+        EventBusManager = None
+
+    statuses = []
+
+    # Database - 收集所有实例
+    for name, instance in DatabaseManager._instances.items():
+        if instance.is_initialized:
+            url = str(instance._engine.url) if instance._engine else None
+            statuses.append(
+                ComponentStatus(
+                    name="Database" if name == "default" else f"Database [{name}]",
+                    status="ok",
+                    backend="SQLAlchemy",
+                    url=url,
+                )
+            )
+
+    # Cache - 收集所有实例
+    for name, instance in CacheManager._instances.items():
+        if instance._backend:
+            statuses.append(
+                ComponentStatus(
+                    name="Cache" if name == "default" else f"Cache [{name}]",
+                    status="ok",
+                    backend=instance.backend_type,
+                    url=instance._config.get("CACHE_URL") if instance._config else None,
+                )
+            )
+
+    # Storage - 收集所有实例
+    for name, instance in StorageManager._instances.items():
+        if instance._backend:
+            backend_type = instance._config.backend.value if instance._config else "unknown"
+            url = None
+            if instance._config:
+                if backend_type == "local":
+                    url = instance._config.base_path
+                elif instance._config.endpoint:
+                    url = instance._config.endpoint
+            statuses.append(
+                ComponentStatus(
+                    name="Storage" if name == "default" else f"Storage [{name}]",
+                    status="ok",
+                    backend=backend_type,
+                    url=url,
+                )
+            )
+
+    # Scheduler
+    scheduler = SchedulerManager.get_instance()
+    if scheduler._initialized:
+        statuses.append(
+            ComponentStatus(
+                name="Scheduler",
+                status="ok",
+                backend="APScheduler",
+            )
+        )
+
+    # Redis Clients
+    if RedisClient:
+        for name, instance in RedisClient._instances.items():
+            if instance.is_initialized:
+                statuses.append(
+                    ComponentStatus(
+                        name="Redis" if name == "default" else f"Redis [{name}]",
+                        status="ok",
+                        backend="redis",
+                        url=instance._config.url if instance._config else None,
+                    )
+                )
+
+    # Channel
+    if ChannelManager:
+        for name, instance in ChannelManager._instances.items():
+            if instance.is_initialized:
+                statuses.append(
+                    ComponentStatus(
+                        name="Channel" if name == "default" else f"Channel [{name}]",
+                        status="ok",
+                        backend=instance.backend_type,
+                        url=getattr(instance._backend, "_url", None) if instance._backend else None,
+                    )
+                )
+
+    # MQ
+    if MQManager:
+        for name, instance in MQManager._instances.items():
+            if instance.is_initialized:
+                statuses.append(
+                    ComponentStatus(
+                        name="MQ" if name == "default" else f"MQ [{name}]",
+                        status="ok",
+                        backend=instance.backend_type,
+                        url=getattr(instance._backend, "_url", None) if instance._backend else None,
+                    )
+                )
+
+    # Events
+    if EventBusManager:
+        for name, instance in EventBusManager._instances.items():
+            if instance.is_initialized:
+                statuses.append(
+                    ComponentStatus(
+                        name="Events" if name == "default" else f"Events [{name}]",
+                        status="ok",
+                        backend=instance.backend_type,
+                        url=getattr(instance._backend, "_url", None) if instance._backend else None,
+                    )
+                )
+
+    return statuses
+
+
+__all__ = [
+    "ComponentStatus",
+    "collect_component_status",
+    "mask_url",
+    "print_startup_banner",
+]

aury/boot/application/config/__init__.py

@@ -6,39 +6,74 @@
 设计原则：
 - Application 层配置完全独立，不依赖 Infrastructure 层
 - 配置是纯粹的数据模型定义
+
+多实例配置:
+框架支持多种组件的多实例配置，使用统一的环境变量格式:
+    {PREFIX}_{INSTANCE}_{FIELD}=value
+
+示例:
+    DATABASE_DEFAULT_URL=postgresql://main...
+    DATABASE_ANALYTICS_URL=postgresql://analytics...
+    CACHE_DEFAULT_URL=redis://localhost:6379/1
+    MQ_DEFAULT_URL=redis://localhost:6379/2
 """
 
+from .multi_instance import (
+    MultiInstanceConfigLoader,
+    MultiInstanceSettings,
+    parse_multi_instance_env,
+)
 from .settings import (
     BaseConfig,
+    CacheInstanceConfig,
     CacheSettings,
+    ChannelInstanceConfig,
     CORSSettings,
+    DatabaseInstanceConfig,
     DatabaseSettings,
+    EventInstanceConfig,
     EventSettings,
     HealthCheckSettings,
     LogSettings,
+    MessageQueueSettings,
     MigrationSettings,
+    MQInstanceConfig,
     RPCClientSettings,
     RPCServiceSettings,
     SchedulerSettings,
     ServerSettings,
     ServiceSettings,
+    StorageInstanceConfig,
     TaskSettings,
 )
 
 __all__ = [
+    # 配置类
     "BaseConfig",
-    "CacheSettings",
     "CORSSettings",
+    # 多实例配置类
+    "CacheInstanceConfig",
+    "CacheSettings",
+    "ChannelInstanceConfig",
+    "DatabaseInstanceConfig",
     "DatabaseSettings",
+    "EventInstanceConfig",
     "EventSettings",
     "HealthCheckSettings",
     "LogSettings",
+    "MQInstanceConfig",
+    "MessageQueueSettings",
     "MigrationSettings",
+    # 多实例配置工具
+    "MultiInstanceConfigLoader",
+    "MultiInstanceSettings",
     "RPCClientSettings",
     "RPCServiceSettings",
     "SchedulerSettings",
     "ServerSettings",
     "ServiceSettings",
+    "StorageInstanceConfig",
     "TaskSettings",
+    "parse_multi_instance_env",
 ]
 

aury/boot/application/config/multi_instance.py

@@ -0,0 +1,216 @@
+"""多实例配置解析工具。
+
+支持从环境变量解析 {PREFIX}__{INSTANCE}__{FIELD} 格式的多实例配置。
+使用双下划线 (__) 作为层级分隔符，符合行业标准。
+
+示例:
+    DATABASE__DEFAULT__URL=postgresql://main...
+    DATABASE__DEFAULT__POOL_SIZE=10
+    DATABASE__ANALYTICS__URL=postgresql://analytics...
+    
+    解析后:
+    {
+        "default": {"url": "postgresql://main...", "pool_size": 10},
+        "analytics": {"url": "postgresql://analytics..."}
+    }
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import Any
+
+from pydantic import BaseModel
+
+
+def parse_multi_instance_env(
+    prefix: str,
+    fields: list[str] | None = None,
+    *,
+    type_hints: dict[str, type] | None = None,
+) -> dict[str, dict[str, Any]]:
+    """从环境变量解析多实例配置。
+    
+    使用双下划线 (__) 作为层级分隔符：
+    - {PREFIX}__{INSTANCE}__{FIELD}=value
+    
+    Args:
+        prefix: 环境变量前缀，如 "DATABASE"
+        fields: 支持的字段列表（可选，用于过滤）
+        type_hints: 字段类型提示，用于类型转换
+        
+    Returns:
+        dict[str, dict[str, Any]]: 实例名 -> 配置字典
+        
+    示例:
+        >>> parse_multi_instance_env("DATABASE")
+        {
+            "default": {"url": "postgresql://...", "pool_size": 10},
+            "analytics": {"url": "postgresql://..."}
+        }
+    """
+    instances: dict[str, dict[str, Any]] = {}
+    type_hints = type_hints or {}
+    prefix_with_sep = f"{prefix}__"
+    
+    # 将 fields 转为大写集合用于过滤
+    valid_fields: set[str] | None = None
+    if fields:
+        valid_fields = {f.upper() for f in fields}
+    
+    for key, value in os.environ.items():
+        # 检查前缀
+        if not key.upper().startswith(prefix_with_sep):
+            continue
+        
+        # 移除前缀后分割
+        remainder = key[len(prefix_with_sep):]
+        parts = remainder.split("__", 1)  # 只分割一次：INSTANCE__FIELD
+        
+        if len(parts) != 2:
+            continue
+        
+        instance_name = parts[0].lower()
+        field_name = parts[1].lower()
+        field_name_upper = parts[1].upper()
+        
+        # 如果指定了字段列表，进行过滤
+        if valid_fields and field_name_upper not in valid_fields:
+            continue
+        
+        # 类型转换
+        converted_value = _convert_value(value, type_hints.get(field_name))
+        
+        if instance_name not in instances:
+            instances[instance_name] = {}
+        instances[instance_name][field_name] = converted_value
+    
+    return instances
+
+
+def _convert_value(value: str, target_type: type | None) -> Any:
+    """转换环境变量值到目标类型。"""
+    if target_type is None:
+        return value
+    
+    if target_type is bool:
+        return value.lower() in ("true", "1", "yes", "on")
+    elif target_type is int:
+        return int(value)
+    elif target_type is float:
+        return float(value)
+    elif target_type is list:
+        # 简单的逗号分隔
+        return [v.strip() for v in value.split(",") if v.strip()]
+    else:
+        return value
+
+
+class MultiInstanceSettings(BaseModel):
+    """多实例配置基类。
+    
+    子类需要定义各实例共享的配置字段。
+    """
+    
+    @classmethod
+    def get_field_names(cls) -> list[str]:
+        """获取所有字段名。"""
+        return list(cls.model_fields.keys())
+    
+    @classmethod
+    def get_type_hints(cls) -> dict[str, type]:
+        """获取字段类型提示。"""
+        hints = {}
+        for name, field_info in cls.model_fields.items():
+            annotation = field_info.annotation
+            # 处理 Optional 类型
+            if hasattr(annotation, "__origin__"):
+                # 如 str | None -> str
+                args = getattr(annotation, "__args__", ())
+                for arg in args:
+                    if arg is not type(None):
+                        hints[name] = arg
+                        break
+            else:
+                hints[name] = annotation
+        return hints
+
+
+class MultiInstanceConfigLoader:
+    """多实例配置加载器。
+    
+    使用示例:
+        loader = MultiInstanceConfigLoader("DATABASE", DatabaseInstanceConfig)
+        instances = loader.load()
+        # {"default": DatabaseInstanceConfig(...), "analytics": DatabaseInstanceConfig(...)}
+    """
+    
+    def __init__(
+        self,
+        prefix: str,
+        config_class: type[MultiInstanceSettings],
+    ):
+        """初始化加载器。
+        
+        Args:
+            prefix: 环境变量前缀
+            config_class: 配置类（继承自 MultiInstanceSettings）
+        """
+        self.prefix = prefix.upper()
+        self.config_class = config_class
+    
+    def load(self) -> dict[str, MultiInstanceSettings]:
+        """加载所有实例配置。
+        
+        Returns:
+            dict[str, config_class]: 实例名 -> 配置对象
+        """
+        fields = self.config_class.get_field_names()
+        type_hints = self.config_class.get_type_hints()
+        
+        raw_instances = parse_multi_instance_env(
+            self.prefix,
+            fields,
+            type_hints=type_hints,
+        )
+        
+        # 转换为配置对象
+        instances = {}
+        for name, config_dict in raw_instances.items():
+            try:
+                instances[name] = self.config_class(**config_dict)
+            except Exception as e:
+                # 配置不完整时跳过，让 Pydantic 验证报错
+                raise ValueError(
+                    f"配置实例 [{self.prefix}_{name.upper()}] 无效: {e}"
+                ) from e
+        
+        return instances
+    
+    def load_or_default(
+        self,
+        default_instance: str = "default",
+    ) -> dict[str, MultiInstanceSettings]:
+        """加载配置，如果没有任何实例则返回包含默认实例的字典。
+        
+        Args:
+            default_instance: 默认实例名
+            
+        Returns:
+            dict[str, config_class]: 实例名 -> 配置对象
+        """
+        instances = self.load()
+        
+        if not instances:
+            # 没有配置任何实例，创建一个默认的
+            instances[default_instance] = self.config_class()
+        
+        return instances
+
+
+__all__ = [
+    "MultiInstanceConfigLoader",
+    "MultiInstanceSettings",
+    "parse_multi_instance_env",
+]