xtquant-share 1.3.0__tar.gz → 1.3.1__tar.gz

{xtquant_share-1.3.0/xtquant_share.egg-info → xtquant_share-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xtquant-share
-Version: 1.3.0
+Version: 1.3.1
 Summary: Xtreme Quant Share - eXtreme transparent sharing proxy for XtQuant on macOS/Linux
 Author-email: Jason Hu <63170682@qq.com>
 License-Expression: GPL-3.0-only

{xtquant_share-1.3.0 → xtquant_share-1.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xtquant-share"
-version = "1.3.0"
+version = "1.3.1"
 description = "Xtreme Quant Share - eXtreme transparent sharing proxy for XtQuant on macOS/Linux"
 readme = "README.md"
 license = "GPL-3.0-only"

{xtquant_share-1.3.0 → xtquant_share-1.3.1}/tests/test_quote_events.py

@@ -30,7 +30,7 @@ sys.modules['xtquant.xttype'] = mock_xttype
 from xqshare.server import _init_logging
 _init_logging("WARNING")
 
-from xqshare.server import LoggingProxy, _QuoteEventCallback
+from xqshare.server import LoggingProxy, XtQuantService, _QuoteEventCallback
 from xqshare.client import RemoteQuoteCallback
 from xqshare.auth import AccountLevel
 
@@ -118,6 +118,83 @@ class TestQuoteEventCallback:
         finally:
             qec.stop()
 
+    def test_register_idempotent_per_client(self):
+        """同一 client_info 重复 register（断线重连后新 netref）应覆盖旧 entry 而非累积"""
+        qec = _QuoteEventCallback()
+        try:
+            old_cb = MagicMock()
+            new_cb = MagicMock()
+            qec.register(old_cb, client_info="c1@127.0.0.1:1")
+            qec.register(new_cb, client_info="c1@127.0.0.1:1")
+
+            assert len(qec._subscribers) == 1, "重连后旧 netref 应被覆盖，不累积"
+            entry = next(iter(qec._subscribers.values()))
+            assert entry['callback'] is new_cb
+        finally:
+            qec.stop()
+
+    def test_register_without_client_info_no_dedup(self):
+        """client_info 为 None 时不做幂等去重（保持原语义，按 id 累积）"""
+        qec = _QuoteEventCallback()
+        try:
+            qec.register(MagicMock())
+            qec.register(MagicMock())
+            assert len(qec._subscribers) == 2
+        finally:
+            qec.stop()
+
+    def test_clear_client_callbacks(self):
+        """clear_client_callbacks 只清理指定 client 的回调，不影响其他 client"""
+        qec = _QuoteEventCallback()
+        try:
+            cb1, cb2, cb3 = MagicMock(), MagicMock(), MagicMock()
+            qec.register(cb1, client_info="c1@127.0.0.1:1")
+            qec.register(cb2, client_info="c1@127.0.0.1:1")
+            qec.register(cb3, client_info="c2@127.0.0.1:2")
+
+            qec.clear_client_callbacks("c1@127.0.0.1:1")
+
+            remaining = [e['callback'] for e in qec._subscribers.values()]
+            assert remaining == [cb3], "只应保留其他 client 的回调"
+        finally:
+            qec.stop()
+
+    def test_on_disconnect_clears_quote_subscribers(self):
+        """on_disconnect 应清理该连接注册的 quote 回调，避免 netref 累积泄漏"""
+        qec = _QuoteEventCallback()
+        original = XtQuantService._quote_event_callback
+        XtQuantService._quote_event_callback = qec
+        try:
+            service = XtQuantService()
+            service._client_info = "c1@127.0.0.1:1"
+            service._traders = []
+            qec.register(MagicMock(), client_info="c1@127.0.0.1:1")
+            qec.register(MagicMock(), client_info="c2@127.0.0.1:2")
+
+            service.on_disconnect(MagicMock())
+
+            remaining = [e['client_info'] for e in qec._subscribers.values()]
+            assert remaining == ["c2@127.0.0.1:2"], "断开连接的客户端回调应被清理"
+        finally:
+            qec.stop()
+            XtQuantService._quote_event_callback = original
+
+    def test_on_disconnect_without_quote_callback(self):
+        """quote 单例未初始化时 on_disconnect 不应报错，也不应创建单例"""
+        original = XtQuantService._quote_event_callback
+        XtQuantService._quote_event_callback = None
+        try:
+            service = XtQuantService()
+            service._client_info = "c1@127.0.0.1:1"
+            service._traders = []
+
+            service.on_disconnect(MagicMock())
+
+            assert XtQuantService._quote_event_callback is None, \
+                "不应在断开时懒创建 quote 单例"
+        finally:
+            XtQuantService._quote_event_callback = original
+
 
 class TestLoggingProxyQuoteIntercept:
     """LoggingProxy 拦截 xtdata 订阅并接管 callback"""
@@ -143,8 +220,10 @@ class TestLoggingProxyQuoteIntercept:
 
             kwargs = mock.subscribe_whole_quote.call_args.kwargs
             assert kwargs["callback"] is qec, "原生 callback 应由服务端路由器接管"
-            assert len(qec._subscribers) == 1 and next(iter(qec._subscribers.values())) is client_cb, \
-                "客户端回调应注册到路由器"
+            assert len(qec._subscribers) == 1, "客户端回调应注册到路由器"
+            entry = next(iter(qec._subscribers.values()))
+            assert entry['callback'] is client_cb
+            assert entry['client_info'] == "test-client", "应记录 client_info 供断线清理"
         finally:
             qec.stop()
 

{xtquant_share-1.3.0 → xtquant_share-1.3.1}/tests/test_server.py

@@ -195,6 +195,49 @@ class TestXtQuantService:
         assert "test_token" not in service._tokens
 
 
+class TestTraderCallbackCleanup:
+    """测试 trader 事件路由器线程的清理（防泄漏）"""
+
+    def test_on_disconnect_stops_trader_event_callback(self):
+        """on_disconnect 应停止该连接创建的事件路由器 dispatch 线程"""
+        from xqshare.server import _TraderEventCallback
+        service = XtQuantService()
+        service._conn = Mock()
+        service._conn.peer = "127.0.0.1:12345"
+        service._client_info = "test_client@127.0.0.1:12345"
+        trader = Mock()
+        cb = _TraderEventCallback()
+        service._traders = [(trader, cb)]
+        try:
+            service.on_disconnect(service._conn)
+
+            assert cb._running is False, "on_disconnect 应停止事件路由器线程"
+            trader.stop.assert_called_once()
+        finally:
+            cb.stop()
+
+    def test_trader_event_callback_stop_terminates_thread(self):
+        """_TraderEventCallback.stop() 应让 dispatch daemon 线程退出"""
+        from xqshare.server import _TraderEventCallback
+        cb = _TraderEventCallback()
+        thread = cb._event_thread
+        assert thread.is_alive(), "dispatch 线程应在创建后运行"
+
+        cb.stop()
+        thread.join(timeout=3.0)
+        assert not thread.is_alive(), "stop() 后 dispatch 线程应退出"
+
+    def test_trader_event_callback_stop_idempotent(self):
+        """stop() 多次调用应无副作用"""
+        from xqshare.server import _TraderEventCallback
+        cb = _TraderEventCallback()
+        thread = cb._event_thread
+        cb.stop()
+        cb.stop()
+        thread.join(timeout=3.0)
+        assert not thread.is_alive()
+
+
 class TestSSLContext:
     """测试 SSL 上下文创建"""
     

{xtquant_share-1.3.0 → xtquant_share-1.3.1}/xqshare/__init__.py

@@ -4,7 +4,7 @@ XtQuant Share (xqshare) - Transparent remote proxy for xtquant library
 Allows using xtquant on macOS/Linux by proxying calls to a Windows server.
 """
 
-__version__ = "1.3.0"
+__version__ = "1.3.1"
 __author__ = "Jason Hu"
 
 from .client import (

{xtquant_share-1.3.0 → xtquant_share-1.3.1}/xqshare/server.py

@@ -563,12 +563,16 @@ class _QuoteEventCallback:
         # key 用 id(netref)（本地内存地址）而非 netref 本身：
         # set 的 add/discard 会对 netref 求 hash（触发 RPC），客户端断开后
         # 该 RPC 会抛 EOFError，导致 dispatch 线程崩溃。id() 是纯本地操作。
-        self._subscribers = {}  # id(client_callback_netref) -> client_callback_netref
+        # value 记录 client_info，供 on_disconnect 按连接清理（修复 netref 累积泄漏）。
+        self._subscribers = {}  # id(client_callback_netref) -> {callback, client_info}
         self._running = True
         self._queue = []
         self._queue_lock = threading.Lock()
         self._event_thread = threading.Thread(target=self._dispatch_loop, daemon=True)
         self._event_thread.start()
+        # 订阅者数量告警水位：超过阈值打 warning，用于观察是否仍存在泄漏
+        self._max_subscribers_warning = _get_max_quote_subscribers()
+        self._warned = False
 
     def __call__(self, data):
         """使路由器可被 xtquant 作为函数式 callback 调用。
@@ -604,7 +608,7 @@ class _QuoteEventCallback:
                 continue
             for payload in batch:
                 with self._lock:
-                    callbacks = list(self._subscribers.values())
+                    callbacks = [entry['callback'] for entry in self._subscribers.values()]
                 for cb in callbacks:
                     try:
                         cb.exposed_on_quote_event(payload)
@@ -613,15 +617,58 @@ class _QuoteEventCallback:
                         logger.warning(f"[QuoteEvent] 推送到客户端失败，自动移除: {e}")
                         self.unregister(cb)
 
-    def register(self, client_callback):
+    def register(self, client_callback, client_info: Optional[str] = None):
         with self._lock:
-            self._subscribers[id(client_callback)] = client_callback
+            if client_info is not None:
+                # 幂等化：同一 client_info 重复 register（客户端断线重连后新 netref
+                # 的 id 不同）时，先移除该 client 的旧 entry，避免按 id(netref) 累积。
+                stale = [
+                    cid for cid, entry in self._subscribers.items()
+                    if entry['client_info'] == client_info
+                ]
+                for cid in stale:
+                    self._subscribers.pop(cid, None)
+            self._subscribers[id(client_callback)] = {
+                'callback': client_callback,
+                'client_info': client_info,
+            }
+        self._maybe_warn_subscriber_count()
         logger.info(f"[QuoteEvent] 注册订阅者 total={len(self._subscribers)}")
 
     def unregister(self, client_callback):
         with self._lock:
             self._subscribers.pop(id(client_callback), None)
 
+    def clear_client_callbacks(self, client_info: Optional[str]):
+        """按连接清理该客户端注册的所有 quote 回调（on_disconnect 调用）。"""
+        if client_info is None:
+            return
+        with self._lock:
+            stale = [
+                cid for cid, entry in self._subscribers.items()
+                if entry['client_info'] == client_info
+            ]
+            for cid in stale:
+                self._subscribers.pop(cid, None)
+        if stale:
+            logger.info(
+                f"[QuoteEvent] 清理断开客户端的订阅者: client={client_info} "
+                f"removed={len(stale)} total={len(self._subscribers)}"
+            )
+
+    def _maybe_warn_subscriber_count(self):
+        """订阅者数量超过水位时打 warning（回落时复位，便于反复告警）。"""
+        n = len(self._subscribers)
+        if n > self._max_subscribers_warning:
+            if not self._warned:
+                self._warned = True
+                logger.warning(
+                    f"[QuoteEvent] 订阅者数量异常: total={n} "
+                    f"(阈值 {self._max_subscribers_warning})，可能存在回调泄漏"
+                )
+        elif self._warned:
+            self._warned = False
+
     def stop(self):
         self._running = False
 
@@ -655,6 +702,15 @@ def _get_download_timeout() -> int:
 DOWNLOAD_TIMEOUT_SECONDS = _get_download_timeout()
 
 
+def _get_max_quote_subscribers() -> int:
+    """读取 quote 订阅者告警水位，默认 500，可用 env XQSHARE_MAX_QUOTE_SUBSCRIBERS 覆盖。"""
+    raw = os.environ.get("XQSHARE_MAX_QUOTE_SUBSCRIBERS", "500")
+    try:
+        return int(raw)
+    except (TypeError, ValueError):
+        return 500
+
+
 def _call_download_with_timeout(fn, *args, timeout=None, name=None, **kwargs):
     """在独立 daemon 线程执行下载，主线程带超时等待。
 
@@ -790,13 +846,13 @@ class LoggingProxy:
                         pos = _QUOTE_SUBSCRIBE_CALLBACK_POS[name]
                         client_callback = kwargs.pop('callback', None)
                         if client_callback is not None:
-                            # 客户端传了接收器（netref），注册到路由器
-                            quote_event_callback.register(client_callback)
+                            # 客户端传了接收器（netref），注册到路由器（带 client_info 供断线清理）
+                            quote_event_callback.register(client_callback, get_client_info())
                             kwargs['callback'] = quote_event_callback
                         elif len(args) > pos:
                             args = list(args)
                             if args[pos] is not None:
-                                quote_event_callback.register(args[pos])
+                                quote_event_callback.register(args[pos], get_client_info())
                             args[pos] = quote_event_callback
                             args = tuple(args)
                         else:
@@ -915,9 +971,15 @@ class XtQuantService(rpyc.Service):
     def on_disconnect(self, conn):
         client_info = getattr(self, '_client_info', 'unknown')
         logger.info(f"[断开] 客户端离开: {client_info}")
-        # 自动清理本次连接创建的所有 trader 实例，防止 session 资源泄漏
+        # 清理本连接注册的 quote 行情回调（根因：netref 随重连累积，只进不出）
+        qec = XtQuantService._quote_event_callback
+        if qec is not None:
+            qec.clear_client_callbacks(client_info)
+        # 自动清理本次连接创建的所有 trader 实例及其事件路由器，
+        # 含停止 _TraderEventCallback 的 dispatch daemon 线程（否则线程持
+        # 有回调对象与 netref，随断线累积泄漏）
         traders = getattr(self, '_traders', [])
-        for trader in traders:
+        for trader, event_callback in traders:
             # disconnect() 在部分 xtquant 版本中不存在，仅作可选清理
             if hasattr(trader, 'disconnect'):
                 try:
@@ -930,6 +992,12 @@ class XtQuantService(rpyc.Service):
                 logger.info(f"[清理Trader] 已自动 stop trader | client={client_info}")
             except Exception as e:
                 logger.warning(f"[清理Trader] stop trader 失败: {e} | client={client_info}")
+            if event_callback is not None and hasattr(event_callback, 'stop'):
+                try:
+                    event_callback.stop()
+                    logger.info(f"[清理Trader] 已停止事件路由器线程 | client={client_info}")
+                except Exception as e:
+                    logger.warning(f"[清理Trader] 停止事件路由器线程失败: {e} | client={client_info}")
 
     def _delayed_disconnect(self, delay: float = 0.5):
         """延迟断开连接，确保异常能传输到客户端"""
@@ -1098,13 +1166,13 @@ class XtQuantService(rpyc.Service):
 
         logger.info(f"[创建Trader] userdata_path={userdata_path} | session_id={session_id}")
 
-        # 记录 trader 实例，供 on_disconnect 时自动清理
-        self._traders.append(trader)
-
         # 每个 trader 独立一个事件路由器，用于把 on_stock_* 推送给远端客户端
         event_callback = _TraderEventCallback()
         trader.register_callback(event_callback)
 
+        # 记录 trader + 事件路由器，供 on_disconnect 时自动清理（含停止线程）
+        self._traders.append((trader, event_callback))
+
         # 用 LoggingProxy 包装 trader，支持日志记录、序列化和事件回调透传
         return LoggingProxy(
             trader, 'xttrader',
@@ -1143,8 +1211,8 @@ class XtQuantService(rpyc.Service):
         )
         trader.register_callback(adapter)
 
-        # 记录 trader 实例，供 on_disconnect 时自动清理
-        self._traders.append(trader)
+        # 记录 trader + 事件路由器，供 on_disconnect 时自动清理（含停止线程）
+        self._traders.append((trader, event_callback))
 
         return LoggingProxy(
             trader, 'xttrader',
@@ -1176,18 +1244,23 @@ class XtQuantService(rpyc.Service):
 
         logger.info(f"[创建并连接大QMT Trader] account_id={account_id} | session_id={session_id}")
 
-        start_result = trader.start()
-        logger.info(f"[大QMT Trader] start() 返回: {start_result}")
-        if start_result not in (0, None):
-            raise RuntimeError(f"启动大QMT 交易线程失败，错误码: {start_result}")
-
-        # bigqmt connect() 同步：内部 RPC ping + 合成 on_account_status；失败抛异常
-        connect_result = trader.connect()
-        logger.info(f"[大QMT Trader] connect() 返回: {connect_result}")
-        if connect_result not in (0, None):
-            raise ConnectionError(f"大QMT 连接失败: 错误码 {connect_result}")
+        try:
+            start_result = trader.start()
+            logger.info(f"[大QMT Trader] start() 返回: {start_result}")
+            if start_result not in (0, None):
+                raise RuntimeError(f"启动大QMT 交易线程失败，错误码: {start_result}")
+
+            # bigqmt connect() 同步：内部 RPC ping + 合成 on_account_status；失败抛异常
+            connect_result = trader.connect()
+            logger.info(f"[大QMT Trader] connect() 返回: {connect_result}")
+            if connect_result not in (0, None):
+                raise ConnectionError(f"大QMT 连接失败: 错误码 {connect_result}")
+        except Exception:
+            # 失败路径也要停止事件路由器线程，避免泄漏
+            event_callback.stop()
+            raise
 
-        self._traders.append(trader)
+        self._traders.append((trader, event_callback))
 
         return LoggingProxy(
             trader, 'xttrader',
@@ -1247,48 +1320,56 @@ class XtQuantService(rpyc.Service):
 
         logger.info(f"[创建并连接Trader] userdata_path={userdata_path} | session_id={session_id}")
 
-        start_result = trader.start()
-        logger.info(f"[Trader] start() 返回: {start_result}")
-        if start_result not in (0, None):
-            raise RuntimeError(f"启动交易线程失败，错误码: {start_result}")
-
-        connect_result = trader.connect()
-        logger.info(f"[Trader] connect() 返回: {connect_result}")
-        if connect_result not in (0, None):
-            error_codes = {
-                -1: "交易服务器未连接",
-                -2: "账号未登录",
-                -3: "请求超时",
-                -4: "资金账号不存在",
-            }
-            raise ConnectionError(f"连接失败: {error_codes.get(connect_result, f'错误码 {connect_result}')}")
-
-        # 等待真实的交易连接建立
-        connected = callback.wait_for_connected(connect_timeout)
-        logger.info(f"[Trader] on_connected 回调状态: {connected}")
-        if not connected:
-            # 某些版本的 xtquant 可能不会触发 on_connected 回调，
-            # 尝试用 query_stock_asset 验证连接是否真正可用
-            logger.info("[Trader] on_connected 未触发，尝试 query_stock_asset 验证连接...")
-            try:
-                from xtquant.xttype import StockAccount
-                account_id = os.environ.get("QMT_ACCOUNT_ID")
-                if account_id:
-                    test_account = StockAccount(account_id)
-                    asset = trader.query_stock_asset(test_account)
-                    logger.info(f"[Trader] query_stock_asset 验证成功: {asset}")
-                    connected = True
-            except Exception as e:
-                logger.warning(f"[Trader] query_stock_asset 验证失败: {e}")
+        try:
+            start_result = trader.start()
+            logger.info(f"[Trader] start() 返回: {start_result}")
+            if start_result not in (0, None):
+                raise RuntimeError(f"启动交易线程失败，错误码: {start_result}")
+
+            connect_result = trader.connect()
+            logger.info(f"[Trader] connect() 返回: {connect_result}")
+            if connect_result not in (0, None):
+                error_codes = {
+                    -1: "交易服务器未连接",
+                    -2: "账号未登录",
+                    -3: "请求超时",
+                    -4: "资金账号不存在",
+                }
+                raise ConnectionError(f"连接失败: {error_codes.get(connect_result, f'错误码 {connect_result}')}")
+
+            # 等待真实的交易连接建立
+            connected = callback.wait_for_connected(connect_timeout)
+            logger.info(f"[Trader] on_connected 回调状态: {connected}")
+            if not connected:
+                # 某些版本的 xtquant 可能不会触发 on_connected 回调，
+                # 尝试用 query_stock_asset 验证连接是否真正可用
+                logger.info("[Trader] on_connected 未触发，尝试 query_stock_asset 验证连接...")
+                try:
+                    from xtquant.xttype import StockAccount
+                    account_id = os.environ.get("QMT_ACCOUNT_ID")
+                    if account_id:
+                        test_account = StockAccount(account_id)
+                        asset = trader.query_stock_asset(test_account)
+                        logger.info(f"[Trader] query_stock_asset 验证成功: {asset}")
+                        connected = True
+                except Exception as e:
+                    logger.warning(f"[Trader] query_stock_asset 验证失败: {e}")
 
-        if not connected:
-            trader.stop()
-            raise TimeoutError(
-                f"等待交易连接建立超时（{connect_timeout}秒），"
-                "请检查 MiniQMT 是否已登录交易账号，或设置更长的 --connect-timeout"
-            )
+            if not connected:
+                raise TimeoutError(
+                    f"等待交易连接建立超时（{connect_timeout}秒），"
+                    "请检查 MiniQMT 是否已登录交易账号，或设置更长的 --connect-timeout"
+                )
+        except Exception:
+            # 失败路径：停止 trader 与事件路由器线程，避免泄漏
+            try:
+                trader.stop()
+            except Exception:
+                pass
+            callback.stop()
+            raise
 
-        self._traders.append(trader)
+        self._traders.append((trader, callback))
 
         return LoggingProxy(
             trader, 'xttrader',

{xtquant_share-1.3.0 → xtquant_share-1.3.1/xtquant_share.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xtquant-share
-Version: 1.3.0
+Version: 1.3.1
 Summary: Xtreme Quant Share - eXtreme transparent sharing proxy for XtQuant on macOS/Linux
 Author-email: Jason Hu <63170682@qq.com>
 License-Expression: GPL-3.0-only