| |
| |
|
|
| """异步 HTTP Session 管理器，用于管理 aiohttp.ClientSession 的连接池复用""" |
|
|
| import asyncio |
| import ssl |
| from typing import Optional |
|
|
| import aiohttp |
| import certifi |
|
|
| from dashscope.common.logging import logger |
|
|
|
|
| class AioConnectionPoolConfig: |
| """异步连接池配置类""" |
|
|
| def __init__( |
| self, |
| limit: int = 100, |
| limit_per_host: int = 30, |
| ttl_dns_cache: int = 300, |
| keepalive_timeout: int = 30, |
| force_close: bool = False, |
| ): |
| """ |
| 初始化异步连接池配置 |
| |
| Args: |
| limit: 总连接数限制，默认 100 |
| limit_per_host: 每个主机的连接数限制，默认 30 |
| ttl_dns_cache: DNS 缓存 TTL（秒），默认 300 |
| keepalive_timeout: Keep-Alive 超时（秒），默认 30 |
| force_close: 是否强制关闭连接，默认 False |
| |
| Raises: |
| ValueError: 当参数值不合法时 |
| """ |
| if limit <= 0: |
| raise ValueError(f"limit ({limit}) 必须 > 0") |
| if limit_per_host <= 0: |
| raise ValueError(f"limit_per_host ({limit_per_host}) 必须 > 0") |
| if limit_per_host > limit: |
| raise ValueError( |
| f"limit_per_host ({limit_per_host}) 必须 <= " f"limit ({limit})", |
| ) |
| if ttl_dns_cache < 0: |
| raise ValueError(f"ttl_dns_cache ({ttl_dns_cache}) 必须 >= 0") |
| if keepalive_timeout < 0: |
| raise ValueError( |
| f"keepalive_timeout ({keepalive_timeout}) 必须 >= 0", |
| ) |
|
|
| self.limit = limit |
| self.limit_per_host = limit_per_host |
| self.ttl_dns_cache = ttl_dns_cache |
| self.keepalive_timeout = keepalive_timeout |
| self.force_close = force_close |
|
|
| def __repr__(self): |
| return ( |
| f"AioConnectionPoolConfig(limit={self.limit}, " |
| f"limit_per_host={self.limit_per_host}, " |
| f"ttl_dns_cache={self.ttl_dns_cache}, " |
| f"keepalive_timeout={self.keepalive_timeout}, " |
| f"force_close={self.force_close})" |
| ) |
|
|
|
|
| class AioSessionManager: |
| """ |
| 异步 HTTP Session 管理器（单例模式） |
| |
| 用于管理全局的 aiohttp.ClientSession 实例，实现异步 HTTP 连接复用。 |
| |
| 特性： |
| - 单例模式：全局唯一实例 |
| - 异步锁保护：使用 asyncio.Lock 保护并发访问 |
| - 连接池配置：支持自定义 TCPConnector 参数 |
| - 生命周期管理：支持启用、禁用、重置 |
| - 向后兼容：默认禁用，不影响现有代码 |
| |
| Examples: |
| >>> import asyncio |
| >>> from dashscope.common.aio_session_manager import AioSessionManager |
| >>> |
| >>> async def main(): |
| ... manager = await AioSessionManager.get_instance() |
| ... await manager.enable(limit=200, limit_per_host=50) |
| ... session = await manager.get_session() |
| ... # 使用 session 进行请求 |
| ... await manager.disable() |
| >>> |
| >>> asyncio.run(main()) |
| """ |
|
|
| _instance: Optional["AioSessionManager"] = None |
| _lock = asyncio.Lock() |
|
|
| def __init__(self): |
| """初始化 Session 管理器（私有，通过 get_instance 获取）""" |
| self._enabled = False |
| self._session: Optional[aiohttp.ClientSession] = None |
| self._session_lock = asyncio.Lock() |
| self._config = AioConnectionPoolConfig() |
| logger.debug("AioSessionManager initialized") |
|
|
| @classmethod |
| async def get_instance(cls) -> "AioSessionManager": |
| """ |
| 获取单例实例（异步） |
| |
| Returns: |
| AioSessionManager: 单例实例 |
| """ |
| if cls._instance is None: |
| async with cls._lock: |
| if cls._instance is None: |
| cls._instance = cls() |
| logger.debug( |
| "AioSessionManager singleton instance created", |
| ) |
| return cls._instance |
|
|
| @classmethod |
| async def reset_instance(cls): |
| """ |
| 重置单例实例（仅用于测试） |
| |
| 警告：此方法仅应在测试环境中使用 |
| """ |
| async with cls._lock: |
| if cls._instance is not None: |
| await cls._instance.disable() |
| await cls._instance.reset() |
| cls._instance = None |
| logger.debug("AioSessionManager singleton instance reset") |
|
|
| async def enable( |
| self, |
| limit: int = None, |
| limit_per_host: int = None, |
| ttl_dns_cache: int = None, |
| keepalive_timeout: int = None, |
| force_close: bool = None, |
| ): |
| """ |
| 启用异步连接池复用 |
| |
| Args: |
| limit: 总连接数限制，默认 100 |
| limit_per_host: 每个主机的连接数限制，默认 30 |
| ttl_dns_cache: DNS 缓存 TTL（秒），默认 300 |
| keepalive_timeout: Keep-Alive 超时（秒），默认 30 |
| force_close: 是否强制关闭连接，默认 False |
| |
| Examples: |
| >>> manager = await AioSessionManager.get_instance() |
| >>> await manager.enable(limit=200, limit_per_host=50) |
| """ |
| async with self._session_lock: |
| |
| if any( |
| param is not None |
| for param in [ |
| limit, |
| limit_per_host, |
| ttl_dns_cache, |
| keepalive_timeout, |
| force_close, |
| ] |
| ): |
| await self._configure( |
| limit=limit, |
| limit_per_host=limit_per_host, |
| ttl_dns_cache=ttl_dns_cache, |
| keepalive_timeout=keepalive_timeout, |
| force_close=force_close, |
| ) |
|
|
| self._enabled = True |
| await self._ensure_session() |
| logger.info( |
| "Async HTTP connection pool enabled with config: %s", |
| self._config, |
| ) |
|
|
| async def disable(self): |
| """ |
| 禁用异步连接池复用 |
| |
| 关闭当前 Session 并禁用连接池功能 |
| |
| Examples: |
| >>> manager = await AioSessionManager.get_instance() |
| >>> await manager.disable() |
| """ |
| async with self._session_lock: |
| self._enabled = False |
| if self._session and not self._session.closed: |
| await self._session.close() |
| logger.debug("Async ClientSession closed") |
| self._session = None |
| logger.info("Async HTTP connection pool disabled") |
|
|
| async def configure( |
| self, |
| limit: int = None, |
| limit_per_host: int = None, |
| ttl_dns_cache: int = None, |
| keepalive_timeout: int = None, |
| force_close: bool = None, |
| ): |
| """ |
| 配置连接池参数 |
| |
| Args: |
| limit: 总连接数限制 |
| limit_per_host: 每个主机的连接数限制 |
| ttl_dns_cache: DNS 缓存 TTL（秒） |
| keepalive_timeout: Keep-Alive 超时（秒） |
| force_close: 是否强制关闭连接 |
| |
| Examples: |
| >>> manager = await AioSessionManager.get_instance() |
| >>> await manager.configure(limit=200, limit_per_host=50) |
| """ |
| async with self._session_lock: |
| await self._configure( |
| limit=limit, |
| limit_per_host=limit_per_host, |
| ttl_dns_cache=ttl_dns_cache, |
| keepalive_timeout=keepalive_timeout, |
| force_close=force_close, |
| ) |
|
|
| async def _configure( |
| self, |
| limit: int = None, |
| limit_per_host: int = None, |
| ttl_dns_cache: int = None, |
| keepalive_timeout: int = None, |
| force_close: bool = None, |
| ): |
| """内部配置方法（无锁）""" |
| config_params = {} |
| if limit is not None: |
| config_params["limit"] = limit |
| if limit_per_host is not None: |
| config_params["limit_per_host"] = limit_per_host |
| if ttl_dns_cache is not None: |
| config_params["ttl_dns_cache"] = ttl_dns_cache |
| if keepalive_timeout is not None: |
| config_params["keepalive_timeout"] = keepalive_timeout |
| if force_close is not None: |
| config_params["force_close"] = force_close |
|
|
| if config_params: |
| |
| limit = config_params.get("limit", self._config.limit) |
| limit_per_host = config_params.get( |
| "limit_per_host", |
| self._config.limit_per_host, |
| ) |
| ttl_dns_cache = config_params.get( |
| "ttl_dns_cache", |
| self._config.ttl_dns_cache, |
| ) |
| keepalive_timeout = config_params.get( |
| "keepalive_timeout", |
| self._config.keepalive_timeout, |
| ) |
| force_close = config_params.get( |
| "force_close", |
| self._config.force_close, |
| ) |
|
|
| new_config = AioConnectionPoolConfig( |
| limit=limit, |
| limit_per_host=limit_per_host, |
| ttl_dns_cache=ttl_dns_cache, |
| keepalive_timeout=keepalive_timeout, |
| force_close=bool(force_close), |
| ) |
| self._config = new_config |
|
|
| |
| if self._enabled: |
| if self._session and not self._session.closed: |
| await self._session.close() |
| self._session = None |
| await self._ensure_session() |
| logger.info( |
| "Async connection pool reconfigured: %s", |
| self._config, |
| ) |
|
|
| async def _ensure_session(self): |
| """确保 Session 存在且有效（内部方法，无锁）""" |
| if self._session is None or self._session.closed: |
| connector = aiohttp.TCPConnector( |
| limit=self._config.limit, |
| limit_per_host=self._config.limit_per_host, |
| ttl_dns_cache=self._config.ttl_dns_cache, |
| keepalive_timeout=self._config.keepalive_timeout, |
| force_close=self._config.force_close, |
| ssl=ssl.create_default_context(cafile=certifi.where()), |
| ) |
| self._session = aiohttp.ClientSession(connector=connector) |
| logger.debug( |
| "New async ClientSession created with config: %s", |
| self._config, |
| ) |
|
|
| async def get_session(self) -> Optional[aiohttp.ClientSession]: |
| """ |
| 获取 Session（如果启用） |
| |
| Returns: |
| Optional[aiohttp.ClientSession]: 如果启用返回 Session，否则返回 None |
| |
| Examples: |
| >>> manager = await AioSessionManager.get_instance() |
| >>> await manager.enable() |
| >>> session = await manager.get_session() |
| >>> if session: |
| ... # 使用 session 进行请求 |
| ... pass |
| """ |
| async with self._session_lock: |
| if self._enabled: |
| await self._ensure_session() |
| return self._session |
| return None |
|
|
| async def get_session_direct(self) -> Optional[aiohttp.ClientSession]: |
| """ |
| 直接获取 Session（不检查启用状态） |
| |
| Returns: |
| Optional[aiohttp.ClientSession]: 当前 Session 或 None |
| |
| Note: |
| 此方法主要用于测试，一般应使用 get_session() |
| """ |
| async with self._session_lock: |
| return self._session |
|
|
| async def reset(self): |
| """ |
| 重置 Session |
| |
| 关闭当前 Session 并根据启用状态重新创建 |
| |
| Examples: |
| >>> manager = await AioSessionManager.get_instance() |
| >>> await manager.reset() |
| """ |
| async with self._session_lock: |
| if self._session and not self._session.closed: |
| await self._session.close() |
| logger.debug("Async ClientSession closed during reset") |
| self._session = None |
| if self._enabled: |
| await self._ensure_session() |
| logger.info("Async HTTP connection pool reset") |
|
|
| def get_config(self) -> AioConnectionPoolConfig: |
| """ |
| 获取当前连接池配置 |
| |
| Returns: |
| AioConnectionPoolConfig: 当前配置 |
| |
| Examples: |
| >>> manager = await AioSessionManager.get_instance() |
| >>> config = manager.get_config() |
| >>> print(config.limit) |
| """ |
| return self._config |
|
|
| def is_enabled(self) -> bool: |
| """ |
| 检查连接池是否已启用 |
| |
| Returns: |
| bool: 是否已启用 |
| |
| Examples: |
| >>> manager = await AioSessionManager.get_instance() |
| >>> if manager.is_enabled(): |
| ... print("Connection pool is enabled") |
| """ |
| return self._enabled |
|
|
| async def has_active_session(self) -> bool: |
| """ |
| 检查是否有活跃的 Session |
| |
| Returns: |
| bool: 是否有活跃的 Session |
| |
| Examples: |
| >>> manager = await AioSessionManager.get_instance() |
| >>> if await manager.has_active_session(): |
| ... print("Active session exists") |
| """ |
| async with self._session_lock: |
| return self._session is not None and not self._session.closed |
|
|
