sycommon-python-lib 0.1.21__py3-none-any.whl → 0.1.46__py3-none-any.whl

sycommon/services.py

@@ -22,6 +22,7 @@ class Services(metaclass=SingletonMeta):
     _instance: Optional['Services'] = None
     _app: Optional[FastAPI] = None
     _user_lifespan: Optional[Callable] = None
+    _shutdown_lock: asyncio.Lock = asyncio.Lock()
 
     def __init__(self, config: dict, app: FastAPI):
         if not Services._config:
@@ -66,8 +67,13 @@ class Services(metaclass=SingletonMeta):
         if not cls._config:
             config = yaml.safe_load(open('app.yaml', 'r', encoding='utf-8'))
             cls._config = config
-        app.host = cls._config.get('Host')
-        app.post = cls._config.get('Port')
+        # 使用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 * 1024)
+        }
 
         # 立即配置非异步服务（在应用启动前）
         if middleware:
@@ -139,12 +145,26 @@ class Services(metaclass=SingletonMeta):
         has_listeners: bool = False,
         has_senders: bool = False,
     ):
-        """异步设置MQ相关服务"""
+        """异步设置MQ相关服务（适配新的RabbitMQService）"""
         # 初始化RabbitMQ服务，传递状态
         RabbitMQService.init(self._config, has_listeners, has_senders)
 
+        # 等待RabbitMQ连接池初始化完成（最多等待30秒）
+        start_time = asyncio.get_event_loop().time()
+        while not RabbitMQService._connection_pool and not RabbitMQService._is_shutdown:
+            if asyncio.get_event_loop().time() - start_time > 30:
+                raise TimeoutError("RabbitMQ连接池初始化超时")
+            logging.info("等待RabbitMQ连接池初始化...")
+            await asyncio.sleep(1)
+
         # 设置发送器，传递是否有监听器的标志
         if rabbitmq_senders:
+            # 判断是否有监听器，如果有遍历监听器列表，队列名一样将prefetch_count属性设置到发送器对象中
+            if 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)
 
         # 设置监听器，传递是否有发送器的标志
@@ -153,20 +173,25 @@ class Services(metaclass=SingletonMeta):
 
         # 验证初始化结果
         if has_listeners:
+            # 异步获取客户端数量（适配新的RabbitMQService）
             listener_count = len(RabbitMQService._clients)
             logging.info(f"监听器初始化完成，共启动 {listener_count} 个消费者")
             if listener_count == 0:
                 logging.warning("未成功初始化任何监听器，请检查配置")
 
     async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
+        """设置发送器（适配新的RabbitMQService异步方法）"""
         Services._registered_senders = [
             sender.queue_name for sender in rabbitmq_senders]
 
-        # 将是否有监听器的信息传递给RabbitMQService
+        # 将是否有监听器的信息传递给RabbitMQService（异步调用）
         await RabbitMQService.setup_senders(rabbitmq_senders, has_listeners)
+        # 更新已注册的发送器（从RabbitMQService获取实际注册的名称）
+        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):
+        """设置监听器（适配新的RabbitMQService异步方法）"""
         await RabbitMQService.setup_listeners(rabbitmq_listeners, has_senders)
 
     @classmethod
@@ -177,23 +202,30 @@ class Services(metaclass=SingletonMeta):
         max_retries: int = 3,
         retry_delay: float = 1.0, **kwargs
     ) -> None:
-        """发送消息，添加重试机制"""
+        """发送消息，添加重试机制（适配新的RabbitMQService异步API）"""
         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:
                     cls._registered_senders = RabbitMQService._sender_client_names
                     if queue_name not in cls._registered_senders:
                         raise ValueError(f"发送器 {queue_name} 未注册")
 
-                sender = RabbitMQService.get_sender(queue_name)
+                # 获取发送器（适配新的异步get_sender方法）
+                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)
+                # 发送消息（调用RabbitMQService的异步send_message）
+                await RabbitMQService.send_message(data, queue_name, **kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
                 return
 
@@ -209,17 +241,28 @@ class Services(metaclass=SingletonMeta):
                 )
                 await asyncio.sleep(retry_delay)
 
-    @staticmethod
-    async def shutdown():
-        """关闭所有服务"""
-        # 取消所有MQ任务
-        for task in Services._mq_tasks:
-            if not task.done():
-                task.cancel()
-                try:
-                    await task
-                except asyncio.CancelledError:
-                    pass
-
-        # 关闭RabbitMQ服务
-        await RabbitMQService.shutdown()
+    @classmethod
+    async def shutdown(cls):
+        """关闭所有服务（线程安全，适配新的RabbitMQService关闭逻辑）"""
+        async with cls._shutdown_lock:
+            if RabbitMQService._is_shutdown:
+                logging.info("RabbitMQService已关闭，无需重复操作")
+                return
+
+            # 取消所有MQ任务
+            for task in Services._mq_tasks:
+                if not task.done():
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        logging.info(f"MQ任务 {task.get_name()} 已取消")
+
+            # 关闭RabbitMQ服务（异步调用）
+            await RabbitMQService.shutdown()
+
+            # 清理全局状态
+            cls._initialized = False
+            cls._registered_senders.clear()
+            cls._mq_tasks.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]}")