sycommon-python-lib 0.1.16__py3-none-any.whl → 0.1.56b1__py3-none-any.whl

sycommon/services.py

@@ -1,10 +1,13 @@
-from typing import Any, Callable, Dict, List, Tuple, Union, Optional, AsyncGenerator
 import asyncio
 import logging
+import yaml
 from contextlib import asynccontextmanager
+from dotenv import load_dotenv
 from fastapi import FastAPI, applications
 from pydantic import BaseModel
+from typing import Any, Callable, Dict, List, Tuple, Union, Optional, AsyncGenerator
 from sycommon.config.Config import SingletonMeta
+from sycommon.logging.logger_levels import setup_logger_levels
 from sycommon.models.mqlistener_config import RabbitMQListenerConfig
 from sycommon.models.mqsend_config import RabbitMQSendConfig
 from sycommon.rabbitmq.rabbitmq_service import RabbitMQService
@@ -16,10 +19,13 @@ class Services(metaclass=SingletonMeta):
     _config: Optional[dict] = None
     _initialized: bool = False
     _registered_senders: List[str] = []
-    _mq_tasks: List[asyncio.Task] = []
     _instance: Optional['Services'] = None
     _app: Optional[FastAPI] = None
     _user_lifespan: Optional[Callable] = None
+    _shutdown_lock: asyncio.Lock = asyncio.Lock()
+
+    # 用于存储待执行的异步数据库初始化任务
+    _pending_async_db_setup: List[Tuple[Callable, str]] = []
 
     def __init__(self, config: dict, app: FastAPI):
         if not Services._config:
@@ -41,26 +47,37 @@ class Services(metaclass=SingletonMeta):
     def plugins(
         cls,
         app: FastAPI,
-        config: dict,
+        config: Optional[dict] = None,
         middleware: Optional[Callable[[FastAPI, dict], None]] = None,
         nacos_service: Optional[Callable[[dict], None]] = None,
         logging_service: Optional[Callable[[dict], None]] = None,
         database_service: Optional[Union[
-            Tuple[Callable[[dict, str], None], str],
-            List[Tuple[Callable[[dict, str], None], str]]
+            Tuple[Callable, str],
+            List[Tuple[Callable, str]]
         ]] = None,
         rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
         rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None
     ) -> FastAPI:
-        # 保存应用实例和配置
+        load_dotenv()
+        setup_logger_levels()
         cls._app = app
         cls._config = config
         cls._user_lifespan = app.router.lifespan_context
-        # 设置文档
+
         applications.get_swagger_ui_html = custom_swagger_ui_html
         applications.get_redoc_html = custom_redoc_html
 
-        # 立即配置非异步服务（在应用启动前）
+        if not cls._config:
+            config = yaml.safe_load(open('app.yaml', 'r', encoding='utf-8'))
+            cls._config = config
+
+        app.state.config = {
+            "host": cls._config.get('Host', '0.0.0.0'),
+            "port": cls._config.get('Port', 8080),
+            "workers": cls._config.get('Workers', 1),
+            "h11_max_incomplete_event_size": cls._config.get('H11MaxIncompleteEventSize', 1024 * 1024 * 10)
+        }
+
         if middleware:
             middleware(app, config)
 
@@ -70,25 +87,62 @@ class Services(metaclass=SingletonMeta):
         if logging_service:
             logging_service(config)
 
+        # ========== 处理数据库服务 ==========
+        # 清空之前的待执行列表（防止热重载时重复）
+        cls._pending_async_db_setup = []
+
         if database_service:
-            cls._setup_database_static(database_service, config)
+            # 解析配置并区分同步/异步
+            items = [database_service] if isinstance(
+                database_service, tuple) else database_service
+            for item in items:
+                db_setup_func, db_name = item
+                if asyncio.iscoroutinefunction(db_setup_func):
+                    # 如果是异步函数，加入待执行列表
+                    logging.info(f"检测到异步数据库服务: {db_name}，将在应用启动时初始化")
+                    cls._pending_async_db_setup.append(item)
+                else:
+                    # 如果是同步函数，立即执行
+                    logging.info(f"执行同步数据库服务: {db_name}")
+                    try:
+                        db_setup_func(config, db_name)
+                    except Exception as e:
+                        logging.error(
+                            f"同步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                        raise
 
         # 创建组合生命周期管理器
         @asynccontextmanager
         async def combined_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
             # 1. 执行Services自身的初始化
             instance = cls(config, app)
-            has_listeners = bool(
+
+            # ========== 执行挂起的异步数据库初始化 ==========
+            if cls._pending_async_db_setup:
+                logging.info("开始执行异步数据库初始化...")
+                for db_setup_func, db_name in cls._pending_async_db_setup:
+                    try:
+                        await db_setup_func(config, db_name)
+                        logging.info(f"异步数据库服务 {db_name} 初始化成功")
+                    except Exception as e:
+                        logging.error(
+                            f"异步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                        raise
+
+            # ========== 初始化 MQ ==========
+            has_valid_listeners = bool(
                 rabbitmq_listeners and len(rabbitmq_listeners) > 0)
-            has_senders = bool(rabbitmq_senders and len(rabbitmq_senders) > 0)
+            has_valid_senders = bool(
+                rabbitmq_senders and len(rabbitmq_senders) > 0)
 
             try:
-                await instance._setup_mq_async(
-                    rabbitmq_listeners=rabbitmq_listeners,
-                    rabbitmq_senders=rabbitmq_senders,
-                    has_listeners=has_listeners,
-                    has_senders=has_senders
-                )
+                if has_valid_listeners or has_valid_senders:
+                    await instance._setup_mq_async(
+                        rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
+                        rabbitmq_senders=rabbitmq_senders if has_valid_senders else None,
+                        has_listeners=has_valid_listeners,
+                        has_senders=has_valid_senders
+                    )
                 cls._initialized = True
                 logging.info("Services初始化完成")
             except Exception as e:
@@ -100,28 +154,18 @@ class Services(metaclass=SingletonMeta):
             # 2. 执行用户定义的生命周期
             if cls._user_lifespan:
                 async with cls._user_lifespan(app):
-                    yield  # 应用运行阶段
+                    yield
             else:
-                yield  # 没有用户生命周期时直接 yield
+                yield
 
             # 3. 执行Services的关闭逻辑
             await cls.shutdown()
             logging.info("Services已关闭")
 
-        # 设置组合生命周期
         app.router.lifespan_context = combined_lifespan
-
         return app
 
-    @staticmethod
-    def _setup_database_static(database_service, config):
-        """静态方法：设置数据库服务"""
-        if isinstance(database_service, tuple):
-            db_setup, db_name = database_service
-            db_setup(config, db_name)
-        elif isinstance(database_service, list):
-            for db_setup, db_name in database_service:
-                db_setup(config, db_name)
+    # 移除了 _setup_database_static，因为逻辑已内联到 plugins 中
 
     async def _setup_mq_async(
         self,
@@ -131,33 +175,46 @@ class Services(metaclass=SingletonMeta):
         has_senders: bool = False,
     ):
         """异步设置MQ相关服务"""
-        # 初始化RabbitMQ服务，传递状态
+        if not (has_listeners or has_senders):
+            logging.info("无RabbitMQ监听器/发送器配置，跳过RabbitMQService初始化")
+            return
+
         RabbitMQService.init(self._config, has_listeners, has_senders)
 
-        # 设置发送器，传递是否有监听器的标志
-        if rabbitmq_senders:
+        start_time = asyncio.get_event_loop().time()
+        while not (RabbitMQService._connection_pool and RabbitMQService._connection_pool._initialized) and not RabbitMQService._is_shutdown:
+            if asyncio.get_event_loop().time() - start_time > 30:
+                raise TimeoutError("RabbitMQ连接池初始化超时（30秒）")
+            logging.info("等待RabbitMQ连接池初始化...")
+            await asyncio.sleep(0.5)
+
+        if has_senders and rabbitmq_senders:
+            if has_listeners and rabbitmq_listeners:
+                for sender in rabbitmq_senders:
+                    for listener in rabbitmq_listeners:
+                        if sender.queue_name == listener.queue_name:
+                            sender.prefetch_count = listener.prefetch_count
             await self._setup_senders_async(rabbitmq_senders, has_listeners)
 
-        # 设置监听器，传递是否有发送器的标志
-        if rabbitmq_listeners:
+        if has_listeners and rabbitmq_listeners:
             await self._setup_listeners_async(rabbitmq_listeners, has_senders)
 
-        # 验证初始化结果
         if has_listeners:
-            listener_count = len(RabbitMQService._clients)
+            listener_count = len(RabbitMQService._consumer_tasks)
             logging.info(f"监听器初始化完成，共启动 {listener_count} 个消费者")
             if listener_count == 0:
-                logging.warning("未成功初始化任何监听器，请检查配置")
+                logging.warning("未成功初始化任何监听器，请检查配置或MQ服务状态")
 
     async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
+        """设置发送器"""
         Services._registered_senders = [
             sender.queue_name for sender in rabbitmq_senders]
-
-        # 将是否有监听器的信息传递给RabbitMQService
         await RabbitMQService.setup_senders(rabbitmq_senders, has_listeners)
+        Services._registered_senders = RabbitMQService._sender_client_names
         logging.info(f"已注册的RabbitMQ发送器: {Services._registered_senders}")
 
     async def _setup_listeners_async(self, rabbitmq_listeners, has_senders: bool):
+        """设置监听器"""
         await RabbitMQService.setup_listeners(rabbitmq_listeners, has_senders)
 
     @classmethod
@@ -168,11 +225,15 @@ class Services(metaclass=SingletonMeta):
         max_retries: int = 3,
         retry_delay: float = 1.0, **kwargs
     ) -> None:
-        """发送消息，添加重试机制"""
+        """发送消息"""
         if not cls._initialized or not cls._loop:
             logging.error("Services not properly initialized!")
             raise ValueError("服务未正确初始化")
 
+        if RabbitMQService._is_shutdown:
+            logging.error("RabbitMQService已关闭，无法发送消息")
+            raise RuntimeError("RabbitMQ服务已关闭")
+
         for attempt in range(max_retries):
             try:
                 if queue_name not in cls._registered_senders:
@@ -180,11 +241,11 @@ class Services(metaclass=SingletonMeta):
                     if queue_name not in cls._registered_senders:
                         raise ValueError(f"发送器 {queue_name} 未注册")
 
-                sender = RabbitMQService.get_sender(queue_name)
+                sender = await RabbitMQService.get_sender(queue_name)
                 if not sender:
-                    raise ValueError(f"发送器 '{queue_name}' 不存在")
+                    raise ValueError(f"发送器 '{queue_name}' 不存在或连接无效")
 
-                await RabbitMQService.send_message(data, queue_name, ** kwargs)
+                await RabbitMQService.send_message(data, queue_name, **kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
                 return
 
@@ -193,24 +254,18 @@ class Services(metaclass=SingletonMeta):
                     logging.error(
                         f"消息发送失败（已尝试 {max_retries} 次）: {str(e)}", exc_info=True)
                     raise
-
                 logging.warning(
-                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，"
-                    f"{retry_delay}秒后重试..."
-                )
+                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，{retry_delay}秒后重试...")
                 await asyncio.sleep(retry_delay)
 
-    @staticmethod
-    async def shutdown():
+    @classmethod
+    async def shutdown(cls):
         """关闭所有服务"""
-        # 取消所有MQ任务
-        for task in Services._mq_tasks:
-            if not task.done():
-                task.cancel()
-                try:
-                    await task
-                except asyncio.CancelledError:
-                    pass
-
-        # 关闭RabbitMQ服务
-        await RabbitMQService.shutdown()
+        async with cls._shutdown_lock:
+            if RabbitMQService._is_shutdown:
+                logging.info("RabbitMQService已关闭，无需重复操作")
+                return
+            await RabbitMQService.shutdown()
+            cls._initialized = False
+            cls._registered_senders.clear()
+            logging.info("所有服务已关闭")

sycommon/synacos/example.py

@@ -0,0 +1,153 @@
+from typing import Dict, Any, Optional, List, Union
+
+from sycommon.synacos.param import Body, Cookie, File, Form, Header, Path, Query
+from sycommon.synacos.feign_client import feign_client, feign_request, feign_upload
+
+
+@feign_client(
+    service_name="product-service",
+    path_prefix="/api/v1",
+    default_headers={
+        "User-Agent": "Feign-Client/1.0",
+        "Accept": "application/json"
+    }
+)
+class ProductServiceClient:
+    """商品服务Feign客户端（优化版）"""
+
+    # ------------------------------
+    # 场景1: 基础参数 + 动态Header + Cookie
+    # ------------------------------
+    @feign_request(
+        "GET",
+        "/products/{product_id}/reviews",
+        headers={"X-Request-Source": "mobile"},  # 固定头
+        timeout=10  # 接口级超时（10秒）
+    )
+    async def get_product_reviews(
+        self,
+        product_id: int = Path(..., description="商品ID"),
+        status: Optional[str] = Query(None, description="评价状态"),
+        page: int = Query(1, description="页码"),
+        size: int = Query(10, description="每页条数"),
+        x_auth_token: str = Header(..., description="动态令牌头"),  # 动态头
+        session_id: str = Cookie(..., description="会话Cookie")  # Cookie
+    ) -> Dict[str, Any]:
+        """获取商品评价列表"""
+        pass
+
+    # ------------------------------
+    # 场景2: 仅Query参数（默认不超时）
+    # ------------------------------
+    @feign_request("GET", "/products")  # 未指定timeout，使用客户端默认（不超时）
+    async def search_products(
+        self,
+        category: str = Query(..., description="商品分类"),
+        min_price: Optional[float] = Query(None, description="最低价格"),
+        max_price: Optional[float] = Query(None, description="最高价格"),
+        sort: str = Query("created_desc", description="排序方式")
+    ) -> Dict[str, Any]:
+        """搜索商品"""
+        pass
+
+    # ------------------------------
+    # 场景3: JSON请求体 + 动态签名头
+    # （通过Header参数传递动态生成的签名）
+    # ------------------------------
+    @feign_request(
+        "POST",
+        "/products",
+        headers={"s-y-version": "2.1"},
+        timeout=15  # 15秒超时
+    )
+    async def create_product(
+        self,
+        product_data: Dict[str, Any] = Body(..., description="商品信息"),
+        x_signature: str = Header(..., description="动态生成的签名头")  # 签名头
+    ) -> Dict[str, Any]:
+        """创建商品（动态签名通过Header参数传递）"""
+        pass
+
+    # ------------------------------
+    # 场景4: 文件上传 + 分片上传头
+    # ------------------------------
+    @feign_upload(field_name="image_file")
+    @feign_request(
+        "POST",
+        "/products/{product_id}/images",
+        headers={"X-Upload-Type": "product-image"},
+        timeout=60  # 上传超时60秒
+    )
+    async def upload_product_image(
+        self,
+        product_id: int = Path(..., description="商品ID"),
+        file_paths: Union[str, List[str]] = File(..., description="文件路径"),
+        image_type: str = Form(..., description="图片类型"),
+        is_primary: bool = Form(False, description="是否主图"),
+        x_chunked: bool = Header(False, description="是否分片上传")  # 分片上传头
+    ) -> Dict[str, Any]:
+        """上传商品图片（支持分片上传标记）"""
+        pass
+
+    # ------------------------------
+    # 场景5: 表单提交 + 操作时间头
+    # ------------------------------
+    @feign_request(
+        "POST",
+        "/products/batch-status",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        timeout=5
+    )
+    async def batch_update_status(
+        self,
+        product_ids: str = Form(..., description="商品ID列表"),
+        status: str = Form(..., description="目标状态"),
+        operator: str = Form(..., description="操作人"),
+        x_operate_time: str = Header(..., description="操作时间戳头")  # 动态时间头
+    ) -> Dict[str, Any]:
+        """批量更新商品状态"""
+        pass
+
+
+# ------------------------------
+# 2. 完整调用示例（含Session和Header用法）
+# ------------------------------
+async def feign_advanced_demo():
+    client = ProductServiceClient()
+
+    # 场景1: 动态Header和Cookie
+    reviews = await client.get_product_reviews(
+        product_id=10086,
+        status="APPROVED",
+        x_auth_token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",  # 动态令牌
+        session_id="sid_123456"  # Cookie
+    )
+    print(f"场景1 - 评价数: {reviews.get('total', 0)}")
+
+    # 场景3: 动态生成签名头（直接通过Header参数传递）
+    import hashlib
+    product_data = {
+        "name": "无线蓝牙耳机",
+        "price": 299.99,
+        "stock": 500
+    }
+    # 生成签名（业务逻辑）
+    sign_str = f"{product_data['name']}_{product_data['price']}_secret"
+    signature = hashlib.md5(sign_str.encode()).hexdigest()
+    # 传递签名头
+    new_product = await client.create_product(
+        product_data=product_data,
+        x_signature=signature  # 动态签名通过Header参数传入
+    )
+    print(f"场景3 - 商品ID: {new_product.get('id')}")
+
+    # 场景4: 分片上传（通过x_chunked头控制）
+    product_id = new_product.get('id')
+    if product_id:
+        upload_result = await client.upload_product_image(
+            product_id=product_id,
+            file_paths=["/tmp/main.jpg", "/tmp/detail.jpg"],
+            image_type="detail",
+            x_chunked=True  # 启用分片上传
+        )
+        print(f"场景4 - 上传图片数: {len(upload_result.get('image_urls', []))}")

sycommon/synacos/example2.py

@@ -0,0 +1,129 @@
+from pydantic import BaseModel, Field
+from typing import Any, Optional, List, Dict
+
+from sycommon.synacos.feign_client import feign_client, feign_request
+from sycommon.synacos.param import Body, Form, Query
+
+
+# ------------------------------
+# 请求模型（req）
+# ------------------------------
+class ProductCreateReq(BaseModel):
+    """创建商品的请求模型"""
+    name: str = Field(..., description="商品名称")
+    category: str = Field(..., description="商品分类")
+    price: float = Field(..., gt=0, description="商品价格（必须>0）")
+    stock: int = Field(..., ge=0, description="库存（必须>=0）")
+    attributes: Optional[Dict[str, str]] = Field(None, description="商品属性")
+
+
+class BatchUpdateStatusReq(BaseModel):
+    """批量更新状态的请求模型（表单提交）"""
+    product_ids: str = Field(..., description="商品ID列表（逗号分隔）")
+    status: str = Field(..., description="目标状态（如ON_SALE/OFF_SALE）")
+    operator: str = Field(..., description="操作人")
+
+
+# ------------------------------
+# 响应模型（resp）
+# ------------------------------
+class ProductResp(BaseModel):
+    """商品详情响应模型"""
+    id: int = Field(..., description="商品ID")
+    name: str = Field(..., description="商品名称")
+    category: str = Field(..., description="分类")
+    price: float = Field(..., description="价格")
+    stock: int = Field(..., description="库存")
+    created_at: str = Field(..., description="创建时间")
+
+
+class PageResp(BaseModel):
+    """分页响应模型"""
+    total: int = Field(..., description="总条数")
+    items: List[ProductResp] = Field(..., description="商品列表")
+    page: int = Field(..., description="当前页码")
+    size: int = Field(..., description="每页条数")
+
+
+@feign_client(
+    service_name="product-service",
+    path_prefix="/api/v2",
+    default_headers={"Accept": "application/json"}
+)
+class ProductServiceClient:
+    # ------------------------------
+    # 场景1: Pydantic 作为请求体（Body）
+    # ------------------------------
+    @feign_request("POST", "/products", timeout=15)
+    async def create_product(
+        self,
+        # 使用 Pydantic 模型作为请求体
+        product: ProductCreateReq = Body(..., description="商品信息")
+    ) -> ProductResp:  # 响应自动解析为 ProductResp 模型
+        """创建商品（Pydantic请求体 + Pydantic响应）"""
+        pass
+
+    # ------------------------------
+    # 场景2: Pydantic 作为表单参数（Form）
+    # ------------------------------
+    @feign_request(
+        "POST",
+        "/products/batch-status",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        timeout=5
+    )
+    async def batch_update_status(
+        self,
+        # 使用 Pydantic 模型作为表单参数
+        update_data: BatchUpdateStatusReq = Form(..., description="批量更新信息")
+    ) -> Dict[str, Any]:  # 普通字典响应
+        """批量更新商品状态（Pydantic表单）"""
+        pass
+
+    # ------------------------------
+    # 场景3: 响应为分页模型（嵌套Pydantic）
+    # ------------------------------
+    @feign_request("GET", "/products", timeout=10)
+    async def search_products(
+        self,
+        category: str = Query(..., description="商品分类"),
+        page: int = Query(1, description="页码"),
+        size: int = Query(10, description="每页条数")
+    ) -> PageResp:  # 响应自动解析为 PageResp（嵌套 ProductResp）
+        """搜索商品（Pydantic分页响应）"""
+        pass
+
+
+async def pydantic_feign_demo():
+    client = ProductServiceClient()
+
+    # 场景1: 创建商品（Pydantic请求体 + 响应）
+    create_req = ProductCreateReq(
+        name="无线蓝牙耳机",
+        category="electronics",
+        price=299.99,
+        stock=500,
+        attributes={"brand": "Feign", "battery_life": "24h"}
+    )
+    product = await client.create_product(product=create_req)
+    # 直接使用 Pydantic 模型的属性
+    print(f"创建商品: ID={product.id}, 名称={product.name}, 价格={product.price}")
+
+    # 场景2: 批量更新（Pydantic表单）
+    batch_req = BatchUpdateStatusReq(
+        product_ids=f"{product.id},1002,1003",
+        status="ON_SALE",
+        operator="system"
+    )
+    batch_result = await client.batch_update_status(update_data=batch_req)
+    print(f"批量更新成功: {batch_result.get('success_count')}个")
+
+    # 场景3: 搜索商品（Pydantic分页响应）
+    page_resp = await client.search_products(
+        category="electronics",
+        page=1,
+        size=10
+    )
+    # 分页模型的属性和嵌套列表
+    print(
+        f"搜索结果: 共{page_resp.total}条，第1页商品: {[p.name for p in page_resp.items]}")