sycommon-python-lib 0.1.35__tar.gz → 0.1.37__tar.gz

{sycommon_python_lib-0.1.35 → sycommon_python_lib-0.1.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.35
+Version: 0.1.37
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.1.35 → sycommon_python_lib-0.1.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.35"
+version = "0.1.37"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"

{sycommon_python_lib-0.1.35 → sycommon_python_lib-0.1.37}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -1,3 +1,7 @@
+from aio_pika.pool import Pool
+from aio_pika.abc import AbstractRobustConnection
+from aio_pika import connect_robust, Channel
+from typing import Optional, List
 import asyncio
 import json
 from typing import Callable, Coroutine, Optional, Dict, Any, Union, Set
@@ -81,9 +85,8 @@ class RabbitMQClient:
         self._exchange_exists = False  # 由 _connection_lock 保护
         self._queue_exists = False     # 由 _connection_lock 保护
         self._queue_bound = False      # 由 _connection_lock 保护
-        self._is_consuming = False     # 由 _consume_state_lock 保护
         self._closed = False           # 由 _connection_lock 保护
-        # 由 _consume_state_lock 保护
+        # 由 _consume_state_lock 保护：通过 consumer_tag 存在性判断是否在消费
         self._consumer_tag: Optional[ConsumerTag] = None
         self._last_activity_timestamp = asyncio.get_event_loop().time()
         self._last_message_processed = asyncio.get_event_loop().time()
@@ -102,7 +105,7 @@ class RabbitMQClient:
         self._tracking_messages: Dict[str, Dict[str, Any]] = {}
 
         # 细粒度锁（核心设计：按资源类型拆分，避免嵌套）
-        # 保护消费状态（_is_consuming、message_handler、_consumer_tag）
+        # 保护消费状态（message_handler、_consumer_tag）
         self._consume_state_lock = asyncio.Lock()
         self._tracking_lock = asyncio.Lock()       # 保护消息跟踪记录（_tracking_messages）
         # 保护连接/资源状态（channel、exchange、queue、_closed等）
@@ -131,17 +134,19 @@ class RabbitMQClient:
     async def _get_consume_state(self) -> tuple[bool, Optional[Callable], Optional[ConsumerTag]]:
         """安全获取消费相关状态（一次性获取，避免多次加锁）"""
         async with self._consume_state_lock:
-            return self._is_consuming, self.message_handler, self._consumer_tag
+            # 通过 _consumer_tag 是否存在判断是否在消费
+            is_consuming = self._consumer_tag is not None
+            return is_consuming, self.message_handler, self._consumer_tag
 
-    async def _set_consume_state(self, is_consuming: bool, consumer_tag: Optional[ConsumerTag] = None):
-        """安全更新消费状态（原子操作）"""
+    async def _set_consumer_tag(self, consumer_tag: Optional[ConsumerTag] = None):
+        """安全更新消费者标签（替代原 _set_consume_state）"""
         async with self._consume_state_lock:
-            old_is_consuming = self._is_consuming
-            self._is_consuming = is_consuming
-            if consumer_tag is not None:
-                self._consumer_tag = consumer_tag
-            if old_is_consuming != is_consuming:
-                logger.info(f"消费状态变更: {old_is_consuming} → {is_consuming}")
+            old_tag = self._consumer_tag
+            self._consumer_tag = consumer_tag
+            old_is_consuming = old_tag is not None
+            new_is_consuming = consumer_tag is not None
+            if old_is_consuming != new_is_consuming:
+                logger.info(f"消费状态变更: {old_is_consuming} → {new_is_consuming}")
 
     async def set_message_handler(self, handler):
         """设置消息处理器（加锁保护，避免并发修改）"""
@@ -332,7 +337,7 @@ class RabbitMQClient:
         # 重置连接状态和跟踪记录
         await self._reset_connection_state()
         await self._clear_tracking_messages()
-        await self._set_consume_state(is_consuming=False)
+        await self._set_consumer_tag(None)  # 重置消费者标签（停止消费）
 
         retries = 0
         last_exception = None
@@ -401,9 +406,9 @@ class RabbitMQClient:
                 if not await self.is_connected:
                     raise Exception("连接验证失败，状态异常")
 
-                # 重新开始消费（如果已设置处理器）
-                is_consuming, handler, _ = await self._get_consume_state()
-                if handler:
+                # 重新开始消费（如果已设置处理器且之前在消费）
+                _, handler, consumer_tag = await self._get_consume_state()
+                if handler and consumer_tag:  # 有处理器且之前有消费标签，说明需要恢复消费
                     await self.start_consuming()
 
                 # 启动监控和保活任务
@@ -447,9 +452,9 @@ class RabbitMQClient:
                     if cleaned_count > 0:
                         logger.info(f"清理了 {cleaned_count} 条已确认消息记录")
 
-                    # 检查消费停滞（仅当消费状态为True时）
-                    is_consuming, _, _ = await self._get_consume_state()
-                    if is_consuming:
+                    # 检查消费停滞（仅当有消费者标签时）
+                    _, handler, consumer_tag = await self._get_consume_state()
+                    if consumer_tag:  # 有消费标签说明正在消费
                         tracking_count = await self._get_tracking_count()
                         if current_time - self._last_message_processed > self.consumption_stall_threshold:
                             if tracking_count > 0:
@@ -469,7 +474,7 @@ class RabbitMQClient:
                                 except Exception as e:
                                     logger.error(
                                         f"重启消费失败: {str(e)}", exc_info=True)
-                                    await self._set_consume_state(is_consuming=False)
+                                    await self._set_consumer_tag(None)
 
                 except Exception as e:
                     logger.error(f"监控任务出错: {str(e)}", exc_info=True)
@@ -482,7 +487,7 @@ class RabbitMQClient:
     async def _recreate_channel(self) -> None:
         """重建通道并恢复资源（无锁嵌套）"""
         # 先停止消费
-        await self._set_consume_state(is_consuming=False)
+        await self._set_consumer_tag(None)
         logger.info("开始重建通道...")
 
         try:
@@ -505,7 +510,7 @@ class RabbitMQClient:
             # 更新连接资源
             await self._update_connection_resources(channel, exchange, queue)
 
-            # 重新开始消费
+            # 重新开始消费（如果有处理器）
             _, handler, _ = await self._get_consume_state()
             if handler:
                 await self.start_consuming()
@@ -516,7 +521,7 @@ class RabbitMQClient:
             self._update_activity_timestamp()
         except Exception as e:
             logger.error(f"通道重建失败: {str(e)}，触发重连", exc_info=True)
-            await self._set_consume_state(is_consuming=False)
+            await self._set_consumer_tag(None)
             await self.connect(force_reconnect=True)
 
     def _start_keepalive(self) -> None:
@@ -706,11 +711,11 @@ class RabbitMQClient:
             await self.connect()
 
         # 获取消费状态和资源
-        is_consuming, handler, consumer_tag = await self._get_consume_state()
+        _, handler, consumer_tag = await self._get_consume_state()
         channel, exchange, queue = await self._get_connection_resources()
 
-        # 检查是否已在消费
-        if is_consuming and consumer_tag:
+        # 检查是否已在消费（通过 consumer_tag 是否存在判断）
+        if consumer_tag:
             logger.info(f"已经在消费中，返回现有consumer_tag: {consumer_tag}")
             return consumer_tag
 
@@ -732,31 +737,31 @@ class RabbitMQClient:
             if not new_consumer_tag:
                 raise Exception("未能获取到有效的consumer_tag")
 
-            # 更新消费状态
-            await self._set_consume_state(is_consuming=True, consumer_tag=new_consumer_tag)
+            # 更新消费状态（设置消费者标签）
+            await self._set_consumer_tag(new_consumer_tag)
             logger.info(
                 f"消费者已启动，队列: {queue.name}, tag: {new_consumer_tag}")
             return new_consumer_tag
         except Exception as e:
             # 异常时回滚状态
-            await self._set_consume_state(is_consuming=False)
+            await self._set_consumer_tag(None)
             logger.error(f"启动消费失败: {str(e)}", exc_info=True)
             raise
 
     async def stop_consuming(self) -> None:
         """停止消费（无锁嵌套，通过原子方法获取/更新状态）"""
         # 获取消费状态和资源
-        is_consuming, _, consumer_tag = await self._get_consume_state()
+        _, _, consumer_tag = await self._get_consume_state()
         _, _, queue = await self._get_connection_resources()
 
-        if not is_consuming:
+        if not consumer_tag:  # 无消费标签说明未在消费
             logger.info("未处于消费状态，无需停止")
             return
 
         logger.info(f"开始停止消费（consumer_tag: {consumer_tag}）")
 
-        # 先更新消费状态为False
-        await self._set_consume_state(is_consuming=False)
+        # 先清除消费标签
+        await self._set_consumer_tag(None)
 
         # 取消消费者
         if consumer_tag and queue and not await self._is_closed():
@@ -781,10 +786,6 @@ class RabbitMQClient:
                     break
                 await asyncio.sleep(1)
 
-        # 清理消费状态
-        async with self._consume_state_lock:
-            self._consumer_tag = None
-
         logger.info(f"已停止消费队列: {queue.name if queue else '未知'}")
 
     async def _parse_message(self, message: AbstractIncomingMessage) -> Union[Dict[str, Any], str]:
@@ -911,21 +912,21 @@ class RabbitMQClient:
 
         # 重试检查消费状态（处理极端并发场景）
         for attempt in range(max_check_attempts):
-            is_consuming, handler, _ = await self._get_consume_state()
-            if is_consuming and handler:
+            _, handler, consumer_tag = await self._get_consume_state()
+            if consumer_tag and handler:  # 有消费标签且有处理器才继续
                 break
             if attempt < max_check_attempts - 1:
                 logger.debug(
                     f"消息 {message_id} 处理状态检查重试（第{attempt+1}次）: "
                     f"handler={'存在' if handler else '不存在'}, "
-                    f"is_consuming={is_consuming}"
+                    f"consumer_tag={'存在' if consumer_tag else '不存在'}"
                 )
                 await asyncio.sleep(check_interval)
 
         # 最终状态判断：状态异常则拒绝消息
-        is_consuming, handler, _ = await self._get_consume_state()
-        if not is_consuming or not handler:
-            err_msg = f"消息 {message_id} 拒绝处理：handler={'存在' if handler else '不存在'}, is_consuming={is_consuming}"
+        _, handler, consumer_tag = await self._get_consume_state()
+        if not consumer_tag or not handler:
+            err_msg = f"消息 {message_id} 拒绝处理：handler={'存在' if handler else '不存在'}, consumer_tag={'存在' if consumer_tag else '不存在'}"
             logger.warning(err_msg)
             try:
                 await self._handle_business_retry(message, Exception(err_msg), drop=False)

{sycommon_python_lib-0.1.35 → sycommon_python_lib-0.1.37}/src/sycommon/synacos/feign.py

@@ -123,28 +123,56 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
 
 
 async def _handle_feign_response(response):
-    """处理Feign请求的响应，统一返回格式"""
+    """
+    处理Feign请求的响应，统一返回格式
+    调整逻辑：先判断状态码，再处理内容
+    - 200状态：优先识别JSON/文本，其他均按文件流（二进制）处理
+    - 非200状态：统一返回错误字典
+    """
     try:
-        content_type = response.headers.get('Content-Type', '')
-        if 'application/json' in content_type:
-            response_body = await response.json()
+        status_code = response.status
+        content_type = response.headers.get('Content-Type', '').lower()
+        response_body = None
+
+        if status_code == 200:
+            if 'application/json' in content_type:
+                response_body = await response.json()
+            elif 'text/' in content_type:
+                # 文本类型（text/plain、text/html等）：按文本读取
+                try:
+                    response_body = await response.text(encoding='utf-8')
+                except UnicodeDecodeError:
+                    # 兼容中文编码（gbk）
+                    response_body = await response.text(encoding='gbk')
+            else:
+                # 其他类型（PDF、图片、octet-stream等）：按文件流（二进制）读取
+                binary_data = await response.read()
+                SYLogger.info(
+                    f"按文件流处理响应，类型：{content_type}，大小：{len(binary_data)/1024:.2f}KB")
+                return io.BytesIO(binary_data)  # 返回BytesIO，支持read()
+            return response_body
         else:
-            response_body = await response.text()
+            # 非200状态：统一读取响应体（兼容文本/二进制错误信息）
+            try:
+                if 'application/json' in content_type:
+                    response_body = await response.json()
+                else:
+                    response_body = await response.text(encoding='utf-8', errors='ignore')
+            except Exception:
+                binary_data = await response.read()
+                response_body = f"非200状态，响应无法解码：{binary_data[:100].hex()}"
+
+            error_msg = f"请求失败，状态码: {status_code}，响应内容: {str(response_body)[:500]}"
+            SYLogger.error(error_msg)
+            return {
+                "success": False,
+                "code": status_code,
+                "message": error_msg,
+                "data": response_body
+            }
+
     except Exception as e:
-        response_body = f"读取响应体失败: {str(e)}"
-        SYLogger.error(f"nacos:处理响应时出错: {response_body}")
-
-    if response.status == 200:
-        if 'application/octet-stream' in content_type:
-            return io.BytesIO(await response.read())  # 重新读取二进制内容
-        return response_body
-    else:
-        # 失败：返回统一错误字典，包含状态码、响应体
-        error_msg = f"请求失败，状态码: {response.status}，响应内容: {response_body}"
-        SYLogger.error(error_msg)
-        return {
-            "success": False,
-            "code": response.status,
-            "message": error_msg,
-            "data": response_body
-        }
+        import traceback
+        error_detail = f"处理响应异常: {str(e)}\n{traceback.format_exc()}"
+        SYLogger.error(f"nacos:处理响应时出错: {error_detail}")
+        return None

{sycommon_python_lib-0.1.35 → sycommon_python_lib-0.1.37}/src/sycommon/synacos/nacos_service.py

@@ -47,7 +47,7 @@ class NacosService(metaclass=SingletonMeta):
             self.retry_backoff = self.nacos_config.get('retryBackoff', 1.5)
             self.max_retry_delay = self.nacos_config.get('maxRetryDelay', 30)
             self.heartbeat_interval = self.nacos_config.get(
-                'heartbeatInterval', 10)
+                'heartbeatInterval', 15)
             self.register_retry_interval = self.nacos_config.get(
                 'registerRetryInterval', 5)  # 注册重试间隔
 

{sycommon_python_lib-0.1.35 → sycommon_python_lib-0.1.37}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.35
+Version: 0.1.37
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown