sycommon-python-lib 0.2.6a14__tar.gz → 0.2.7a0__tar.gz

{sycommon_python_lib-0.2.6a14 → sycommon_python_lib-0.2.7a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.6a14
+Version: 0.2.7a0
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.6a14 → sycommon_python_lib-0.2.7a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.6a14"
+version = "0.2.7a0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.6a14 → sycommon_python_lib-0.2.7a0}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -92,14 +92,51 @@ class RabbitMQClient:
         except Exception:
             return False
 
+    async def _probe_queue_state(self) -> Optional[tuple]:
+        """被动声明检查队列状态，返回 (消息数, 消费者数)。队列不存在返回 None。"""
+        channel, _ = await self.connection_pool.acquire_channel()
+        try:
+            queue = await channel.declare_queue(name=self.queue_name, passive=True)
+            if queue.declaration_result:
+                return (
+                    queue.declaration_result.message_count,
+                    queue.declaration_result.consumer_count,
+                )
+            return (0, 0)
+        finally:
+            await channel.close()
+
+    async def _refresh_channel(self) -> None:
+        """PRECONDITION_FAILED 会关闭 self._channel，需重建通道并重新声明交换机。
+
+        重建后 self._channel / self._channel_conn / self._exchange 保持一致，
+        self._queue 被置空，由调用方重新声明。
+        """
+        if self._channel and not self._channel.is_closed:
+            try:
+                await self._channel.close()
+            except Exception:
+                pass
+        self._channel = None
+        self._exchange = None
+        self._queue = None
+        self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
+        self._exchange = await self._channel.declare_exchange(
+            name=self.exchange_name,
+            type=self.exchange_type,
+            durable=self.durable,
+            auto_delete=self.auto_delete,
+        )
+
     async def _try_migrate_queue(self, original_error: Exception) -> bool:
         """尝试迁移队列以支持 x-max-priority。
 
-        当队列已存在但参数不匹配（PRECONDITION_FAILED）时，检查队列是否为空，
-        为空则删除重建，否则跳过迁移。
+        仅当队列为空且无消费者时，删除并重建为带优先级队列（破坏性，但安全）。
+        非空或有消费者时跳过迁移，由调用方走降级复用路径（见 _fallback_passive_declare）。
 
         Returns:
-            True 迁移成功，False 未迁移（需由调用方处理）
+            True 迁移成功（self._queue 已就绪）；
+            False 未迁移（队列非空/有消费者/非参数冲突），交由降级逻辑处理
         """
         from aiormq.exceptions import ChannelPreconditionFailed
 
@@ -110,32 +147,24 @@ class RabbitMQClient:
             return False
 
         try:
-            # PRECONDITION_FAILED 会关闭当前 channel，需要用新 channel 检查队列状态
-            channel, _ = await self.connection_pool.acquire_channel()
-            try:
-                queue = await channel.declare_queue(
-                    name=self.queue_name, passive=True
-                )
-                if queue.declaration_result:
-                    message_count = queue.declaration_result.message_count
-                    consumer_count = queue.declaration_result.consumer_count
-                else:
-                    message_count = 0
-                    consumer_count = 0
-            finally:
-                await channel.close()
+            # PRECONDITION_FAILED 会关闭当前 channel，用独立 channel 检查队列状态
+            state = await self._probe_queue_state()
+            if state is None:
+                # 队列不存在，不是参数冲突，交由上层处理
+                return False
+            message_count, consumer_count = state
 
-            if message_count > 0:
+            if message_count > 0 or consumer_count > 0:
                 logger.warning(
                     f"队列 '{self.queue_name}' 迁移跳过: "
-                    f"存在 {message_count} 条消息"
+                    f"存在 {message_count} 条消息 / {consumer_count} 个消费者"
                 )
                 return False
 
             logger.info(
                 f"开始迁移队列 '{self.queue_name}'，添加 x-max-priority={self.max_priority}")
 
-            # 删除旧队列
+            # 删除旧队列（空且无消费者，安全）
             channel, _ = await self.connection_pool.acquire_channel()
             try:
                 await channel.queue_delete(
@@ -146,26 +175,8 @@ class RabbitMQClient:
             finally:
                 await channel.close()
 
-            # 清理旧 channel（被 PRECONDITION_FAILED 关闭后残留）
-            if self._channel and not self._channel.is_closed:
-                try:
-                    await self._channel.close()
-                except Exception:
-                    pass
-            self._channel = None
-            self._exchange = None
-            self._queue = None
-
-            # 重建 self._channel（旧 channel 已被 PRECONDITION_FAILED 关闭）
-            self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
-
-            # 重新声明交换机
-            self._exchange = await self._channel.declare_exchange(
-                name=self.exchange_name,
-                type=self.exchange_type,
-                durable=self.durable,
-                auto_delete=self.auto_delete,
-            )
+            # 重建通道并重新声明交换机（旧通道已被 PRECONDITION_FAILED 关闭）
+            await self._refresh_channel()
 
             # 重新声明带 priority 的队列
             self._queue = await self._channel.declare_queue(
@@ -183,6 +194,72 @@ class RabbitMQClient:
             logger.error(f"队列 '{self.queue_name}' 迁移失败: {migrate_error}")
             return False
 
+    async def _fallback_passive_declare(self, original_error: Exception) -> Optional[AbstractQueue]:
+        """降级：参数不匹配且无法安全迁移时，被动声明复用现有队列。
+
+        保证消费可正常启动、不丢消息，代价是该队列不应用 x-max-priority。
+        适用于：队列已存在但参数（如 x-max-priority）与期望不一致，且队列非空或正被消费。
+        """
+        from aiormq.exceptions import ChannelPreconditionFailed
+
+        if not isinstance(original_error, ChannelPreconditionFailed):
+            # 非 PRECONDITION_FAILED（真实错误），向上抛出
+            raise original_error
+
+        logger.warning(
+            f"⚠️ 队列 '{self.queue_name}' 参数不匹配（x-max-priority 等）且无法安全迁移，"
+            f"降级为被动复用现有队列（x-max-priority={self.max_priority} 未生效，消费不受影响）"
+        )
+        # 旧通道已被 PRECONDITION_FAILED 关闭，重建后被动声明
+        await self._refresh_channel()
+        queue = await self._channel.declare_queue(name=self.queue_name, passive=True)
+        await queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+        logger.info(f"已被动复用现有队列 '{self.queue_name}'，消费可正常启动")
+        return queue
+
+    async def _ensure_consumer_queue(self) -> Optional[AbstractQueue]:
+        """声明并绑定消费者队列，自动处理 x-max-priority 等参数不匹配。
+
+        仅当 queue_name 符合消费者命名规范（以 app_name 结尾）时初始化队列。
+        非破坏性策略（绝不丢消息）：
+          1. 用期望参数声明（含 x-max-priority）。
+          2. PRECONDITION_FAILED 参数不匹配时：
+             - 队列空且无消费者 → 删除重建（升级为优先级队列）。
+             - 否则 → 被动声明复用现有队列（降级，不丢消息，保证消费可启动）。
+        """
+        # 【核心保留逻辑】只有当 queue_name 存在且符合消费者命名规范时，才初始化队列
+        if not (self.queue_name and self.queue_name.endswith(f".{self.app_name}")):
+            return None
+
+        queue_args = {}
+        if self.max_priority is not None:
+            queue_args["x-max-priority"] = self.max_priority
+
+        try:
+            queue = await self._channel.declare_queue(
+                name=self.queue_name,
+                durable=self.durable,
+                auto_delete=self.auto_delete,
+                passive=not self.create_if_not_exists,
+                arguments=queue_args or None,
+            )
+            await queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+            logger.debug(f"队列就绪: {self.queue_name}")
+            return queue
+        except Exception as e:
+            if not self.create_if_not_exists:
+                self._queue = None
+                logger.warning(
+                    f"⚠️ 队列 '{self.queue_name}' 不存在或无权访问 (Passive模式)，跳过绑定。")
+                return None
+
+            # 参数不匹配：尝试迁移（空队列）或降级复用（非破坏性，绝不丢消息）
+            migrated = await self._try_migrate_queue(e)
+            if migrated:
+                return self._queue
+
+            return await self._fallback_passive_declare(e)
+
     async def _rebuild_resources(self) -> None:
         if not self._channel or self._channel.is_closed:
             raise RuntimeError("无有效通道，无法重建资源")
@@ -202,37 +279,8 @@ class RabbitMQClient:
             raise
 
         # 2. 声明队列 (仅消费者需要)
-        # 【核心保留逻辑】只有当 queue_name 存在且符合消费者命名规范时，才初始化队列
-        if self.queue_name and self.queue_name.endswith(f".{self.app_name}"):
-            queue_args = {}
-            if self.max_priority is not None:
-                queue_args["x-max-priority"] = self.max_priority
-
-            try:
-                self._queue = await self._channel.declare_queue(
-                    name=self.queue_name,
-                    durable=self.durable,
-                    auto_delete=self.auto_delete,
-                    passive=not self.create_if_not_exists,
-                    arguments=queue_args or None,
-                )
-                await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
-                logger.debug(f"队列就绪: {self.queue_name}")
-            except Exception as e:
-                if not self.create_if_not_exists:
-                    self._queue = None
-                    logger.warning(
-                        f"⚠️ 队列 '{self.queue_name}' 不存在或无权访问 (Passive模式)，跳过绑定。")
-                    return
-
-                # 尝试自动迁移：参数不匹配时删除重建
-                migrated = await self._try_migrate_queue(e)
-                if not migrated:
-                    # 迁移失败（非参数不匹配 / 队列非空 / 有消费者），抛出原始异常
-                    raise
-        else:
-            # 不符合命名规范或无队列名，清空队列引用
-            self._queue = None
+        # 委托给 _ensure_consumer_queue 统一处理参数不匹配（含 x-max-priority）
+        self._queue = await self._ensure_consumer_queue()
 
     async def _cleanup_running_tasks(self) -> None:
         """仅清理后台 handler 任务（不做任何破坏性清理，不调 queue.cancel、不关通道）"""
@@ -370,21 +418,9 @@ class RabbitMQClient:
         if not self._queue and self.queue_name and self.queue_name.endswith(f".{self.app_name}"):
             logger.warning(f"队列对象在消费前为空，尝试强制初始化: {self.queue_name}")
             try:
-                queue_args = {}
-                if self.max_priority is not None:
-                    queue_args["x-max-priority"] = self.max_priority
-                self._queue = await self._channel.declare_queue(
-                    name=self.queue_name,
-                    durable=self.durable,
-                    auto_delete=self.auto_delete,
-                    passive=False,
-                    arguments=queue_args or None,
-                )
-                await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+                self._queue = await self._ensure_consumer_queue()
             except Exception as e:
-                migrated = await self._try_migrate_queue(e)
-                if not migrated:
-                    raise RuntimeError(f"无法初始化队列 {self.queue_name}")
+                raise RuntimeError(f"无法初始化队列 {self.queue_name}: {e}")
 
         if not self._queue:
             raise RuntimeError("未配置队列名或队列初始化失败")

sycommon_python_lib-0.2.7a0/src/sycommon/tests/test_queue_priority_fallback.py

@@ -0,0 +1,259 @@
+"""
+验证 _ensure_consumer_queue 在 x-max-priority 参数不匹配时的非破坏性决策。
+
+覆盖日志报告的场景：
+  PRECONDITION_FAILED - inequivalent arg 'x-max-priority' ... received the value '10' but current is none
+
+之前实现：参数不匹配时仅当队列为空才迁移，否则直接 raise → 消费者无法启动、连接失败。
+本次修复：参数不匹配时
+  - 队列空且无消费者 → 删除重建为优先级队列（升级）
+  - 队列非空或有消费者 → 被动声明复用现有队列（降级，绝不丢消息）
+
+运行: cd sycommon-python-lib && python -m pytest src/sycommon/tests/test_queue_priority_fallback.py -v
+"""
+import asyncio
+import sys
+import os
+from unittest.mock import AsyncMock, MagicMock
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".."))
+
+from aiormq.exceptions import (
+    ChannelPreconditionFailed,
+    ChannelNotFoundEntity,
+    ChannelAccessRefused,
+)
+
+from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient
+
+
+class FakeDeclResult:
+    def __init__(self, message_count=0, consumer_count=0):
+        self.message_count = message_count
+        self.consumer_count = consumer_count
+
+
+class FakeQueue:
+    """模拟声明成功后返回的 aio_pika Queue"""
+
+    def __init__(self, declaration_result=None):
+        self.declaration_result = declaration_result
+        self.bind = AsyncMock()
+        self.consume = AsyncMock(return_value="ctag-fake")
+        self.cancel = AsyncMock()
+        self.name = "fake"
+        self._consumers = {}
+
+    async def declare(self, timeout=None):
+        return self.declaration_result
+
+
+class FakeChannel:
+    """模拟 aio_pika Channel。
+
+    declare_queue 语义：
+      passive=True → 返回 _passive_queue，或抛 ChannelNotFoundEntity
+      否则 → 若 _declare_exc 非空则抛它（模拟 RPC 层声明失败），成功则返回 _declared_queue
+    queue_delete / declare_exchange 为 AsyncMock。
+    """
+
+    def __init__(self, *, declared_queue=None, passive_queue=None, declare_exc=None):
+        self.is_closed = False
+        self.close = AsyncMock()
+        self.declare_exchange = AsyncMock(return_value=MagicMock())
+        self.queue_delete = AsyncMock()
+        self._declared_queue = declared_queue
+        self._passive_queue = passive_queue
+        self._declare_exc = declare_exc  # 单次：声明成功后置 None
+
+    async def declare_queue(self, name=None, *, durable=False, auto_delete=False,
+                            passive=False, arguments=None, **kw):
+        if passive:
+            if self._passive_queue is not None:
+                return self._passive_queue
+            raise ChannelNotFoundEntity(404, "NOT_FOUND - no queue")
+        # 非被动声明：可能抛出声明异常
+        if self._declare_exc is not None:
+            exc = self._declare_exc
+            self._declare_exc = None  # 单次触发，后续重建声明成功
+            raise exc
+        return self._declared_queue or FakeQueue()
+
+
+def _make_client(*, max_priority=10, create_if_not_exists=True):
+    pool = MagicMock()
+    pool.acquire_channel = AsyncMock(return_value=(FakeChannel(), MagicMock()))
+    client = RabbitMQClient.__new__(RabbitMQClient)
+    client.connection_pool = pool
+    client.exchange_name = "system.topic.exchange"
+    client.exchange_type = "topic"
+    client.app_name = "shengye-platform-invoice-assist"
+    client.queue_name = (
+        "jms.queue.zhongdeng.search_complate_notify_AC.shengye-platform-invoice-assist"
+    )
+    client.routing_key = "jms.queue.#"
+    client.durable = True
+    client.auto_delete = False
+    client.max_priority = max_priority
+    client.create_if_not_exists = create_if_not_exists
+    client._channel = None
+    client._channel_conn = None
+    client._exchange = MagicMock()
+    client._queue = None
+    return client
+
+
+CPF = lambda: ChannelPreconditionFailed(
+    406, "PRECONDITION_FAILED - inequivalent arg 'x-max-priority'")
+
+
+def _run(coro_fn):
+    loop = asyncio.new_event_loop()
+    try:
+        return loop.run_until_complete(coro_fn())
+    finally:
+        loop.close()
+
+
+def test_migrate_when_queue_empty_and_no_consumers():
+    """队列存在(无 priority) + 要 x-max-priority=10 + 队列空且无消费者
+    → 删除重建为优先级队列（迁移成功），返回非 None 且触发了删除"""
+    client = _make_client(max_priority=10)
+
+    probe_channel = FakeChannel(passive_queue=FakeQueue(
+        declaration_result=FakeDeclResult(message_count=0, consumer_count=0)))
+    delete_channel = FakeChannel()
+    rebuilt_queue = FakeQueue(declaration_result=FakeDeclResult())
+    rebuilt_channel = FakeChannel(declared_queue=rebuilt_queue)
+
+    client.connection_pool.acquire_channel = AsyncMock(side_effect=[
+        (probe_channel, MagicMock()),
+        (delete_channel, MagicMock()),
+        (rebuilt_channel, MagicMock()),
+    ])
+
+    main_channel = FakeChannel(declare_exc=CPF())
+    client._channel = main_channel
+
+    result = _run(client._ensure_consumer_queue)
+
+    assert result is not None, "迁移成功应返回非 None 队列"
+    assert client._queue is rebuilt_queue
+    assert delete_channel.queue_delete.assert_awaited_once() is None, "应删除旧空队列"
+    assert rebuilt_channel is client._channel, "应切换到重建通道"
+
+
+def test_fallback_when_queue_has_messages():
+    """队列有 5 条消息 → 不删除，被动声明复用现有队列（降级，绝不丢消息）"""
+    client = _make_client(max_priority=10)
+
+    probe_channel = FakeChannel(passive_queue=FakeQueue(
+        declaration_result=FakeDeclResult(message_count=5, consumer_count=0)))
+    fallback_queue = FakeQueue(declaration_result=FakeDeclResult())
+    fallback_channel = FakeChannel(passive_queue=fallback_queue)
+
+    client.connection_pool.acquire_channel = AsyncMock(side_effect=[
+        (probe_channel, MagicMock()),
+        (fallback_channel, MagicMock()),
+    ])
+
+    client._channel = FakeChannel(declare_exc=CPF())
+
+    result = _run(client._ensure_consumer_queue)
+
+    assert result is fallback_queue, "应被动复用现有队列"
+    # 关键：从未删除有数据的队列（queue_delete 是 AsyncMock，断言未调用）
+    probe_channel.queue_delete.assert_not_awaited()
+
+
+def test_fallback_when_queue_has_consumer():
+    """队列有消费者（consumer_count=1）→ 不删除（保护在线消费者），被动复用"""
+    client = _make_client(max_priority=10)
+
+    probe_channel = FakeChannel(passive_queue=FakeQueue(
+        declaration_result=FakeDeclResult(message_count=0, consumer_count=1)))
+    fallback_queue = FakeQueue(declaration_result=FakeDeclResult())
+    fallback_channel = FakeChannel(passive_queue=fallback_queue)
+
+    client.connection_pool.acquire_channel = AsyncMock(side_effect=[
+        (probe_channel, MagicMock()),
+        (fallback_channel, MagicMock()),
+    ])
+
+    client._channel = FakeChannel(declare_exc=CPF())
+
+    result = _run(client._ensure_consumer_queue)
+
+    assert result is fallback_queue
+    probe_channel.queue_delete.assert_not_awaited()
+
+
+def test_non_precondition_error_propagates():
+    """非 PRECONDITION_FAILED 的真实错误（如 ACCESS_REFUSED）→ 不降级，向上抛出"""
+    client = _make_client(max_priority=10)
+    client._channel = FakeChannel(
+        declare_exc=ChannelAccessRefused(403, "ACCESS_REFUSED"))
+
+    raised = False
+    loop = asyncio.new_event_loop()
+    try:
+        loop.run_until_complete(client._ensure_consumer_queue())
+    except ChannelAccessRefused:
+        raised = True
+    finally:
+        loop.close()
+    assert raised, "非 PRECONDITION_FAILED 的错误必须向上抛出，不能被吞掉或降级"
+
+
+def test_max_priority_none_skips_migration_but_fallback_handles_cpf():
+    """max_priority=None：_try_migrate_queue 直接返回 False，但 CPF 仍由 _fallback_passive_declare 处理"""
+    client = _make_client(max_priority=None)
+
+    fallback_queue = FakeQueue(declaration_result=FakeDeclResult())
+    fallback_channel = FakeChannel(passive_queue=fallback_queue)
+    client.connection_pool.acquire_channel = AsyncMock(side_effect=[
+        (fallback_channel, MagicMock()),
+    ])
+    client._channel = FakeChannel(declare_exc=CPF())
+
+    result = _run(client._ensure_consumer_queue)
+    assert result is fallback_queue, "max_priority=None 时 CPF 仍应降级复用，保证可启动"
+
+
+def test_non_consumer_queue_name_returns_none():
+    """queue_name 不以 app_name 结尾（非消费者命名）→ 返回 None，不声明"""
+    client = _make_client()
+    client.queue_name = "some.producer.queue"
+
+    result = _run(client._ensure_consumer_queue)
+    assert result is None
+
+
+def test_normal_declare_success():
+    """参数匹配/队列不存在（create_if_not_exists）→ 正常声明，不进入迁移/降级"""
+    client = _make_client(max_priority=10)
+    ok_queue = FakeQueue(declaration_result=FakeDeclResult())
+    client._channel = FakeChannel(declared_queue=ok_queue)
+
+    result = _run(client._ensure_consumer_queue)
+    assert result is ok_queue
+    ok_queue.bind.assert_awaited_once()
+
+
+if __name__ == "__main__":
+    for fn in [
+        test_migrate_when_queue_empty_and_no_consumers,
+        test_fallback_when_queue_has_messages,
+        test_fallback_when_queue_has_consumer,
+        test_non_precondition_error_propagates,
+        test_max_priority_none_skips_migration_but_fallback_handles_cpf,
+        test_non_consumer_queue_name_returns_none,
+        test_normal_declare_success,
+    ]:
+        try:
+            fn()
+            print(f"✅ {fn.__name__}")
+        except AssertionError as e:
+            print(f"❌ {fn.__name__}: {e}")
+        except Exception as e:
+            print(f"💥 {fn.__name__}: {type(e).__name__}: {e}")

{sycommon_python_lib-0.2.6a14 → sycommon_python_lib-0.2.7a0}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.6a14
+Version: 0.2.7a0
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.6a14 → sycommon_python_lib-0.2.7a0}/src/sycommon_python_lib.egg-info/SOURCES.txt

@@ -280,6 +280,7 @@ src/sycommon/tests/test_mcp_server.py
 src/sycommon/tests/test_minimax_reasoning.py
 src/sycommon/tests/test_mq.py
 src/sycommon/tests/test_oa_login.py
+src/sycommon/tests/test_queue_priority_fallback.py
 src/sycommon/tests/test_real_summarization.py
 src/sycommon/tests/test_summarization_config.py
 src/sycommon/tests/test_summarization_real.py