cfquant 0.2.55__tar.gz → 0.2.56__tar.gz

{cfquant-0.2.55 → cfquant-0.2.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.55
+Version: 0.2.56
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8
@@ -343,6 +343,8 @@ trader.disconnect()
 
 `XtQuantTrader`、`StockAccount`、常用行情查询和交易方法保持接近 `xtquant` 的调用方式，原有回调类通常可以继续使用。仍有部分 QMT 专有接口、字段和返回结构存在兼容边界，使用前请查看 [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) 和 [QMT 函数封装能力清单](docs/QMT函数封装能力清单.md)。
 
+账号订阅成功后，SDK 会在后台约每两秒重新确认订阅。用户程序保持运行时，QMT、cfquant Web 或通信服务重启后，待桥接策略恢复授权、通道可用，SDK 会自动恢复该账号的新回调；默认 Web 路由和直接 Pipe/LTtx 连接均适用。主动 `unsubscribe(account)` 后不会再恢复该账号，`stop()` / `disconnect()` 会停止后台恢复。此机制只恢复账号订阅，不补发停机期间的回调，也不重试委托或撤单。升级 SDK 后需先重启一次用户程序加载新代码，此后无需随 QMT 重启用户程序。
+
 推荐迁移顺序：**行情查询 → 资金/持仓 → 回调 → 模拟委托 → 模拟撤单 → 正式策略**。每一步都先在 Web 控制台接口测试和日志中确认，再进入下一步。
 
 ## Web 控制台

{cfquant-0.2.55 → cfquant-0.2.56}/README.md

@@ -317,9 +317,11 @@ trader.disconnect()
 
 ### 回调和接口差异
 
-`XtQuantTrader`、`StockAccount`、常用行情查询和交易方法保持接近 `xtquant` 的调用方式，原有回调类通常可以继续使用。仍有部分 QMT 专有接口、字段和返回结构存在兼容边界，使用前请查看 [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) 和 [QMT 函数封装能力清单](docs/QMT函数封装能力清单.md)。
-
-推荐迁移顺序：**行情查询 → 资金/持仓 → 回调 → 模拟委托 → 模拟撤单 → 正式策略**。每一步都先在 Web 控制台接口测试和日志中确认，再进入下一步。
+`XtQuantTrader`、`StockAccount`、常用行情查询和交易方法保持接近 `xtquant` 的调用方式，原有回调类通常可以继续使用。仍有部分 QMT 专有接口、字段和返回结构存在兼容边界，使用前请查看 [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) 和 [QMT 函数封装能力清单](docs/QMT函数封装能力清单.md)。
+
+账号订阅成功后，SDK 会在后台约每两秒重新确认订阅。用户程序保持运行时，QMT、cfquant Web 或通信服务重启后，待桥接策略恢复授权、通道可用，SDK 会自动恢复该账号的新回调；默认 Web 路由和直接 Pipe/LTtx 连接均适用。主动 `unsubscribe(account)` 后不会再恢复该账号，`stop()` / `disconnect()` 会停止后台恢复。此机制只恢复账号订阅，不补发停机期间的回调，也不重试委托或撤单。升级 SDK 后需先重启一次用户程序加载新代码，此后无需随 QMT 重启用户程序。
+
+推荐迁移顺序：**行情查询 → 资金/持仓 → 回调 → 模拟委托 → 模拟撤单 → 正式策略**。每一步都先在 Web 控制台接口测试和日志中确认，再进入下一步。
 
 ## Web 控制台
 

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/batch_orders.py

@@ -197,6 +197,8 @@ def batch_cancel_result_rows(cancels, seqs=None):
 def batch_result(account, batch_id, asynchronous, results, operation="order"):
     counts = {name: sum(row["status"] == name for row in results)
               for name in ("submitted", "failed", "unknown", "skipped")}
+    counts["rejected"] = sum(row.get("dispatched") is False for row in results)
+    counts["retryable"] = sum(row.get("safe_to_retry") is True for row in results)
     return dict(counts, batch_id=batch_id, account=account, asynchronous=asynchronous,
                 operation=operation, execution="qmt", total=len(results), attempted=len(results) - counts["skipped"],
                 ok=counts["submitted"] == len(results), results=results)
@@ -207,6 +209,19 @@ def batch_unknown(rows, error):
         row.update(status="unknown", ok=None, error=str(error) or type(error).__name__)
 
 
+def batch_rejected(rows, error):
+    """Mark a rejection known to happen before QMT dispatch."""
+    details = getattr(error, "error_details", None)
+    details = details if isinstance(details, dict) else {}
+    message = str(error) or type(error).__name__
+    for row in rows:
+        row.update(status="failed", ok=False, error=message, dispatched=False,
+                   safe_to_retry=details.get("safe_to_retry") is True,
+                   retry_when=details.get("retry_when", ""),
+                   error_code=details.get("code", ""),
+                   error_stage=details.get("stage", "before_dispatch"))
+
+
 def validate_batch_response(result, params, asynchronous):
     expected = params["orders"]
     if (not isinstance(result, dict) or result.get("execution") != "qmt"

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/cftrader.py

@@ -1,7 +1,7 @@
 """Order-only extensions sharing an existing XtQuantTrader session and callbacks."""
 
 from .batch_orders import (
-    batch_cancel_result_rows, batch_result, batch_result_rows, batch_unknown,
+    batch_cancel_result_rows, batch_rejected, batch_result, batch_result_rows, batch_unknown,
     prepare_batch_cancels, prepare_batch_orders, validate_batch_cancel_response, validate_batch_response,
 )
 from .protocol import new_id
@@ -86,9 +86,18 @@ class CfQuantTrader:
             result = validate_batch_response(response, params, asynchronous)
         except Exception as error:
             results = batch_result_rows(rows, seqs)
-            batch_unknown(results, "Batch response unavailable; QMT may still execute the batch: %s" % error)
+            if getattr(error, "dispatched", None) is False:
+                batch_rejected(results, error)
+            else:
+                batch_unknown(results, "Batch response unavailable; QMT may still execute the batch: %s" % error)
             result = batch_result(account, batch_id, asynchronous, results)
             result["request_error"] = str(error) or type(error).__name__
+            details = getattr(error, "error_details", None)
+            if isinstance(details, dict):
+                result.update(error_code=details.get("code", ""), error_stage=details.get("stage", ""),
+                              dispatched=details.get("dispatched"), safe_to_retry=details.get("safe_to_retry") is True,
+                              retry_when=details.get("retry_when", ""),
+                              runtime_instance_id=details.get("runtime_instance_id", ""))
         if asynchronous:
             for row in result["results"]:
                 if row["status"] in ("failed", "skipped"):
@@ -113,7 +122,16 @@ class CfQuantTrader:
             return validate_batch_cancel_response(response, params, asynchronous)
         except Exception as error:
             results = batch_cancel_result_rows(rows, seqs)
-            batch_unknown(results, "Batch cancel response unavailable; QMT may still execute the batch: %s" % error)
+            if getattr(error, "dispatched", None) is False:
+                batch_rejected(results, error)
+            else:
+                batch_unknown(results, "Batch cancel response unavailable; QMT may still execute the batch: %s" % error)
             result = batch_result(account, batch_id, asynchronous, results, operation="cancel")
             result["request_error"] = str(error) or type(error).__name__
+            details = getattr(error, "error_details", None)
+            if isinstance(details, dict):
+                result.update(error_code=details.get("code", ""), error_stage=details.get("stage", ""),
+                              dispatched=details.get("dispatched"), safe_to_retry=details.get("safe_to_retry") is True,
+                              retry_when=details.get("retry_when", ""),
+                              runtime_instance_id=details.get("runtime_instance_id", ""))
             return result

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/client.py

@@ -12,8 +12,17 @@ from .protocol import decode_value, dumps_message, loads_message, new_id, pack_r
 from .rpc_timing import RpcTiming
 
 
-class CfquantError(RuntimeError):
-    pass
+class CfquantError(RuntimeError):
+    """RPC failure retaining the server's structured rejection details."""
+
+    def __init__(self, message="", details=None):
+        super(CfquantError, self).__init__(message)
+        self.error_details = dict(details) if isinstance(details, dict) else {}
+        self.code = self.error_details.get("code", "")
+        self.stage = self.error_details.get("stage", "")
+        self.dispatched = self.error_details.get("dispatched")
+        self.safe_to_retry = self.error_details.get("safe_to_retry", False) is True
+        self.retry_when = self.error_details.get("retry_when", "")
 
 
 class CfquantTimeout(TimeoutError):
@@ -209,6 +218,7 @@ class LTtxRpcClient(object):
                 with self._pending_lock:
                     self._pending[request_id] = q
                 self._push("request", raw, request_channel or self.request_channel)
+                timing.sent()
             try:
                 msg = _wait_response(q, effective_timeout)
             except queue.Empty:
@@ -216,7 +226,7 @@ class LTtxRpcClient(object):
             timing.received(msg)
             if not msg.get("ok"):
                 err = msg.get("error") or {}
-                raise CfquantError(err.get("message") or str(err))
+                raise CfquantError(err.get("message") or str(err), details=err)
             return timing.decode(msg.get("result"), decode_value)
         except (KeyboardInterrupt, SystemExit):
             self.close()

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/normal_bridge.py

@@ -837,6 +837,7 @@ class NormalQmtBridge(TxTradeBridge):
             if not active:
                 return
             msg = active[0][0]
+            dispatch_started = time.perf_counter()
             result = self._dispatch(msg.get("action"), msg.get("params") or {}, msg)
             with self.coalesce_lock:
                 entry = self.coalesced_requests.pop(coalesce_key, None)
@@ -847,6 +848,15 @@ class NormalQmtBridge(TxTradeBridge):
             encoded_result = encode_response_result(result)
             while response_waiters:
                 waiter_msg, _ = response_waiters[0]
+                if msg.get("_response_meta") and str(msg.get("action", "")).startswith("xttrader.query_stock_"):
+                    # Coalesced readers share execution, but each keeps its own ID
+                    # and queue delay (including readers arriving during execution).
+                    timing = dict(msg["_response_meta"]["timing"]["qmt"])
+                    received = waiter_msg.get("_received_monotonic")
+                    if received is not None:
+                        timing["queue_ms"] = round(max(0.0, dispatch_started - received) * 1000, 3)
+                    timing["coalesced_request_id"] = msg.get("id")
+                    waiter_msg["_response_meta"] = {"timing": {"qmt": timing}}
                 self._send_response(waiter_msg, result, encoded_result=encoded_result)
                 response_waiters.pop(0)
             self._log(
@@ -864,6 +874,13 @@ class NormalQmtBridge(TxTradeBridge):
                 % (source, msg.get("action"), msg.get("id"), len(waiters), e)
             )
             for waiter_msg, _ in waiters:
+                if msg.get("_response_meta") and str(msg.get("action", "")).startswith("xttrader.query_stock_"):
+                    timing = dict(msg["_response_meta"]["timing"]["qmt"])
+                    received = waiter_msg.get("_received_monotonic")
+                    if received is not None:
+                        timing["queue_ms"] = round(max(0.0, dispatch_started - received) * 1000, 3)
+                    timing["coalesced_request_id"] = msg.get("id")
+                    waiter_msg["_response_meta"] = {"timing": {"qmt": timing}}
                 self._send_error(waiter_msg, e)
 
     def _on_whole_quote(self, data):
@@ -908,6 +925,13 @@ class NormalQmtBridge(TxTradeBridge):
         client_id = msg.get("client_id") or msg.get("reply_channel")
         if not client_id:
             return
+        if (not msg.get("_response_meta") and str(msg.get("action", "")).startswith("xttrader.query_stock_")
+                and str(error) == "read-only request expired before QMT execution"):
+            received = msg.get("_received_monotonic")
+            msg["_response_meta"] = {"timing": {"qmt": {
+                "available": True, "executed": False, "native_ms": 0.0, "execute_ms": 0.0,
+                "queue_ms": round((time.perf_counter() - received) * 1000, 3) if received is not None else None,
+            }}}
         self._log(
             "normal bridge send_error action=%s id=%s client_id=%s error=%s"
             % (msg.get("action"), msg.get("id"), client_id, error)

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/pipe_client.py

@@ -48,18 +48,24 @@ class PipeRpcClient(object):
             if self._started:
                 self._started = False
                 self._close_conns_locked()
-            self._rx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
-            self._rx_conn.write_frame(dumps_pipe_message({
-                "type": "hello",
-                "role": "api_rx",
-                "client_id": self.client_id,
-            }))
-            self._tx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
-            self._tx_conn.write_frame(dumps_pipe_message({
-                "type": "hello",
-                "role": "api_tx",
-                "client_id": self.client_id,
-            }))
+            try:
+                self._rx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
+                self._rx_conn.write_frame(dumps_pipe_message({
+                    "type": "hello",
+                    "role": "api_rx",
+                    "client_id": self.client_id,
+                }))
+                self._tx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
+                self._tx_conn.write_frame(dumps_pipe_message({
+                    "type": "hello",
+                    "role": "api_tx",
+                    "client_id": self.client_id,
+                }))
+            except BaseException:
+                # A retry must not orphan the receive pipe when opening or
+                # registering the send pipe failed halfway through startup.
+                self.close()
+                raise
             self._started = True
             self._closed = False
             generation = self._event_dispatcher.start()
@@ -95,6 +101,7 @@ class PipeRpcClient(object):
                     self._pending[request_id] = q
                 try:
                     self._send_request(raw, request_channel or self.request_channel)
+                    timing.sent()
                 except Exception:
                     self.close()
                     raise
@@ -111,7 +118,7 @@ class PipeRpcClient(object):
                 err = msg.get("error") or {}
                 from .client import CfquantError
 
-                raise CfquantError(err.get("message") or str(err))
+                raise CfquantError(err.get("message") or str(err), details=err)
             return timing.decode(msg.get("result"), decode_value)
         except (KeyboardInterrupt, SystemExit):
             self.close()

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/protocol.py

@@ -215,10 +215,11 @@ def encode_error(error):
         return None
     if isinstance(error, dict):
         return error
-    return {
-        "type": type(error).__name__,
-        "message": str(error),
-    }
+    details = getattr(error, "error_details", None)
+    result = dict(details) if isinstance(details, dict) else {}
+    result.setdefault("type", type(error).__name__)
+    result["message"] = str(error)
+    return result
 
 
 def encode_value(value):

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/qmt_dependencies.py

@@ -13,7 +13,7 @@ LOGIN_MODULES = ("frida", "win32api", "win32crypt", "win32event", "win32gui", "w
 _LOCK = threading.Lock()
 _CACHE = {}
 _PROBE_CODE = r'''
-import importlib, importlib.metadata, json, pathlib, sys
+import importlib, importlib.metadata, json, os, pathlib, sys
 checks = []
 for name in MODULES:
     try:
@@ -28,10 +28,14 @@ for name in ('pywin32', 'frida'):
     except importlib.metadata.PackageNotFoundError:
         packages[name] = ''
 prefix = pathlib.Path(sys.prefix)
+base_prefix = pathlib.Path(getattr(sys, 'base_prefix', sys.prefix))
 conda = (prefix / 'conda-meta').is_dir()
+venv = not conda and prefix != base_prefix
+environment = 'conda' if conda else 'venv' if venv else 'python'
 print(json.dumps(dict(python_executable=sys.executable, python_version=sys.version.split()[0],
-    prefix=str(prefix), environment='conda' if conda else 'venv' if sys.prefix != sys.base_prefix else 'python',
+    prefix=str(prefix), base_prefix=str(base_prefix), environment=environment,
     global_python=sys.prefix == sys.base_prefix,
+    conda_executable=os.environ.get('CONDA_EXE', '') if conda else '',
     conda_pywin32=conda and bool(list((prefix / 'conda-meta').glob('pywin32-*.json'))),
     supported=sys.platform == 'win32', checks=checks, packages=packages), ensure_ascii=True))
 '''
@@ -55,23 +59,40 @@ def _finish_report(report):
         report["message"] = "QMT 自动登录组件不可用（%s）。可取消自动启动，保存配置后手动启动并登录 QMT。" % names
     commands = []
     python = "& " + _ps_quote(report["python_executable"])
+    environment = str(report.get("environment") or "").lower()
+    if environment not in {"conda", "venv", "python"}:
+        environment = "python" if report.get("global_python") else "venv"
     if report.get("supported") and failed:
         if any(item["name"].startswith("win32") for item in failed):
-            if report.get("conda_pywin32"):
-                commands.append("conda install --prefix %s --force-reinstall 'pywin32>=306'" % _ps_quote(report["prefix"]))
+            if environment == "conda" and report.get("conda_pywin32"):
+                conda = report.get("conda_executable") or "conda"
+                commands.append("& %s install --prefix %s --force-reinstall 'pywin32>=306'" % (
+                    _ps_quote(conda), _ps_quote(report["prefix"])))
             else:
-                commands.append(python + " -m pip install --no-cache-dir --force-reinstall 'pywin32>=306'")
-                if report.get("global_python"):
+                commands.append(python + " -m pip install --no-cache-dir --upgrade --force-reinstall 'pywin32>=306'")
+                if environment == "python":
                     commands.append(python + " -m pywin32_postinstall -install")
         if any(item["name"] == "frida" for item in failed):
-            commands.append(python + " -m pip install --no-cache-dir --force-reinstall 'frida>=17.0,<18'")
+            commands.append(python + " -m pip install --no-cache-dir --upgrade --force-reinstall 'frida>=17.0,<18'")
         commands.append(python + " -c " + _ps_quote("import " + ", ".join(LOGIN_MODULES) + "; print('QMT login components OK')"))
     report["repair_commands"] = commands
-    report["repair_note"] = (
-        "先停止 CFQuant，再在此电脑的 PowerShell 中执行；Conda 命令请使用 Anaconda PowerShell Prompt。"
-        "验证通过后重启 CFQuant，再重新检测。若仍报 DLL 错误，需要检查旧 DLL 残留；"
-        "虚拟环境中不要运行 pywin32_postinstall。"
-    )
+    if environment == "conda":
+        report["repair_note"] = (
+            "已检测到 Conda 环境。先停止 CFQuant，在已激活该环境的 Anaconda Prompt 或 PowerShell 中执行；"
+            "命令会绑定当前环境的前缀。验证通过后重启 CFQuant，再重新检测。"
+        )
+    elif environment == "venv":
+        report["repair_note"] = (
+            "已检测到 venv 虚拟环境。先停止 CFQuant，在普通 PowerShell 中执行下面的命令；"
+            "命令已绑定当前 venv 的 Python，不要切换到系统 Python，也不要运行 pywin32_postinstall。"
+            "验证通过后重启 CFQuant，再重新检测。"
+        )
+    else:
+        report["repair_note"] = (
+            "已检测到独立 Python 环境。先停止 CFQuant，在 PowerShell 中执行下面的命令；"
+            "命令已绑定当前 Python，安装完成后会执行 pywin32_postinstall。"
+            "验证通过后重启 CFQuant，再重新检测。"
+        )
     return report
 
 

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/qmt_pipe_runtime.py

@@ -5,11 +5,23 @@ import os as _cq_os
 import sys as _cq_sys
 import threading as _cq_threading
 import time as _cq_time
+import uuid as _cq_uuid
+
+
+class ManagedStrategyError(RuntimeError):
+    """A rejection made before entering any QMT business dispatcher."""
+
+    def __init__(self, message, code, runtime_instance_id, retry_when=""):
+        super(ManagedStrategyError, self).__init__(message)
+        self.error_details = dict(code=code, stage="before_dispatch", dispatched=False,
+                                  safe_to_retry=bool(retry_when), retry_when=retry_when,
+                                  runtime_instance_id=runtime_instance_id)
 
 
 class ManagedPipeRuntime(object):
     def __init__(self, descriptor=None):
         self.descriptor = dict(descriptor or {})
+        self.runtime_instance_id = _cq_uuid.uuid4().hex
         self.active = False
         self.approved = False
         self.revoked = False
@@ -49,7 +61,8 @@ class ManagedPipeRuntime(object):
         state = "error" if self.failure else ("stopped" if not self.active or self.revoked
                                               else ("running" if ready and self.approved else "loaded"))
         return dict(self.descriptor, state=state, error=self.failure,
-                    pid=_cq_os.getpid(), updated_at=_cq_time.time())
+                    pid=_cq_os.getpid(), updated_at=_cq_time.time(),
+                    runtime_instance_id=self.runtime_instance_id)
 
     def control(self, desired):
         if desired.get("runtime_key") != self.descriptor.get("runtime_key"):
@@ -78,9 +91,18 @@ class ManagedPipeRuntime(object):
                 return self.control(params or {})
             if action == "cfquant.status":
                 return function(action, params, msg)
-            if not self.approved:
-                raise RuntimeError("Managed strategy is awaiting account mode confirmation from cfquant Web.")
-            return dispatch_request(action, params, msg)
+            with self.mutex:
+                if not self.active or self.revoked:
+                    raise ManagedStrategyError("The account's cfquant strategy mode has changed.",
+                                               "STRATEGY_MODE_CHANGED", self.runtime_instance_id)
+                if not self.approved:
+                    raise ManagedStrategyError(
+                        "Managed strategy is awaiting account mode confirmation from cfquant Web.",
+                        "ACCOUNT_MODE_UNCONFIRMED", self.runtime_instance_id, "account_ready")
+            result = dispatch_request(action, params, msg)
+            if action == "cfquant.ping" and isinstance(result, dict):
+                result = dict(result, managed_runtime=self.status())
+            return result
         return guarded
 
     def wrap(self, function, reject=False):
@@ -89,7 +111,8 @@ class ManagedPipeRuntime(object):
             with self.mutex:
                 if not self.active or self.revoked:
                     if reject:
-                        raise RuntimeError("The account's cfquant strategy mode has changed.")
+                        raise ManagedStrategyError("The account's cfquant strategy mode has changed.",
+                                                   "STRATEGY_MODE_CHANGED", self.runtime_instance_id)
                     return None
                 self.calls += 1
             try:

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/qmt_strategy_deploy.py

@@ -5,7 +5,8 @@ import copy
 import hashlib
 import io
 import json
-import os
+import logging
+import os
 from pathlib import Path
 import re
 import threading
@@ -15,9 +16,12 @@ import traceback
 import uuid
 from xml.dom import minidom
 
-from .qmt_strategy_package import build_package
-
-
+from .qmt_strategy_package import build_package
+
+
+logger = logging.getLogger(__name__)
+
+
 SCRIPTS = {"ctypes": "CFQUANT_CTYPE_ALL_LOWLAT.py", "lite": "CFQUANT_LITE.py",
            "lttx": "CFQUANT.py"}
 MODE_ALIASES = {
@@ -577,9 +581,12 @@ class QmtStrategyManager:
         with self.lock:
             jobs = [job for job in self.jobs.values() if job["account_key"] == account_key]
             fields = ("root", "state", "message", "error", "mode", "updated_at", "backup")
-            result = {"enabled": any(job.get("enabled") for job in jobs),
-                    "targets": [dict({k: job.get(k, "") for k in fields},
-                                     strategies=[r["name"] for r in job.get("roles", [])]) for job in jobs]}
+            result = {"enabled": any(job.get("enabled") for job in jobs),
+                    "targets": [dict({k: job.get(k, "") for k in fields},
+                                     strategies=[r["name"] for r in job.get("roles", [])],
+                                     control_sync=[dict(r.get("control_sync") or {}, role=r["role"],
+                                                        strategy=r["name"])
+                                                   for r in job.get("roles", [])]) for job in jobs]}
             if account_key in self.errors:
                 detail = str(self.errors[account_key] or "策略部署失败")
                 result.update(error=detail, message="账号已保存，策略部署失败: " + detail)
@@ -737,6 +744,8 @@ class QmtStrategyManager:
     def _sync_pipe_runtime(self, job):
         if self.runtime_request is None:
             return
+        from .channels import channels_for_bridge
+
         desired = self._desired(job)
         for role in job.get("retired_roles", []):
             try:
@@ -744,16 +753,34 @@ class QmtStrategyManager:
             except Exception:
                 pass
         for role in job["roles"]:
+            identity = role["identity"]
+            sync = role.setdefault("control_sync", {})
+            previous_error = sync.get("last_error", "")
+            sync.update(last_attempt_at=time.time(), pipe_name=identity.get("pipe_name"),
+                        request_channel=((identity.get("channels") or {}).get("normal")
+                                         or identity.get("normal_channel")
+                                         or channels_for_bridge(identity.get("bridge_id"))["normal"]))
             try:
-                report = self.runtime_request(role["identity"], desired)
-                if (isinstance(report, dict) and report.get("runtime_key") == desired["runtime_key"]
-                        and report.get("role") == role["role"]):
-                    # Only the external manager writes status files.
-                    _write_json(role["runtime_status_path"], report)
-            except Exception:
+                report = self.runtime_request(identity, desired)
+                if (not isinstance(report, dict) or report.get("runtime_key") != desired["runtime_key"]
+                        or report.get("role") != role["role"]):
+                    raise ValueError("Managed strategy control response scope mismatch")
+                # Success records an acknowledged control, not necessarily a
+                # ready bridge: QMT may still be binding its trading context.
+                sync.update(last_success_at=time.time(), state=report.get("state"),
+                            pid=report.get("pid"), generation=report.get("generation"), last_error="")
+                # Only the external manager writes status files.
+                _write_json(role["runtime_status_path"], report)
+            except Exception as error:
                 # A stopped/not-yet-imported strategy has no Pipe endpoint.
-                # Existing reports expire normally in _observe_runtime.
-                pass
+                # Retry next cycle, but retain diagnostics instead of hiding
+                # why a restarted strategy is still awaiting confirmation.
+                detail = "%s: %s" % (type(error).__name__, str(error))
+                sync["last_error"] = detail
+                if detail != previous_error:
+                    logger.warning("QMT strategy control sync failed account=%s role=%s pipe=%s channel=%s: %s",
+                                   job["account_key"], role["role"], sync["pipe_name"],
+                                   sync["request_channel"], detail)
 
     @staticmethod
     def _role_endpoint(role):
@@ -790,23 +817,18 @@ class QmtStrategyManager:
         with self.lock:
             changed = False
             for job in self.jobs.values():
-                before = copy.deepcopy(job)
-                if job.get("state") == "disabled":
-                    continue
-                if job.get("enabled") and self._prepare_generation_transition(job):
-                    # A strategy can report an older generation after this
-                    # process starts. Publish the transition before QMT
-                    # launches the old container again.
-                    self._control(job)
-                if job.get("state") == "error":
-                    if not job.get("control_generation") and not _generation_values(
-                            job.get("accepted_generations")):
-                        continue
-                    retry_count = int(job.get("deploy_retry_count") or 0)
-                    if retry_count >= 5 or time.time() < float(job.get("deploy_retry_after") or 0):
-                        continue
-                try:
-                    self._advance(job)
+                before = copy.deepcopy(job)
+                if job.get("state") == "disabled":
+                    continue
+                try:
+                    transition = job.get("enabled") and self._prepare_generation_transition(job)
+                    # A QMT restart loses its in-memory approval. Keep sending
+                    # the selected mode even if offline deployment failed,
+                    # its retries are exhausted, or its files are unavailable.
+                    self._sync_pipe_runtime(job)
+                    if transition:
+                        self._control(job)
+                    self._advance(job)
                 except Exception as error:
                     retry_count = int(job.get("deploy_retry_count") or 0) + 1
                     job["deploy_retry_count"] = retry_count
@@ -826,12 +848,21 @@ class QmtStrategyManager:
             if changed:
                 self._save()
 
-    def _advance(self, job):
-        root = qmt_root(job["root"], validate=True)
+    def _advance(self, job):
+        root = qmt_root(job["root"])
         if self.process_checker(root):
-            self._sync_pipe_runtime(job)
             self._observe_runtime(job)
             return
+        # Retry limits apply to offline deployment, never to mode confirmation
+        # or observing a strategy that has come back online.
+        if job.get("state") == "error":
+            retry_count = int(job.get("deploy_retry_count") or 0)
+            if (not retry_count and not job.get("control_generation")
+                    and not _generation_values(job.get("accepted_generations"))):
+                return
+            if retry_count >= 5 or time.time() < float(job.get("deploy_retry_after") or 0):
+                return
+        root = qmt_root(root, validate=True)
         job["retired_roles"] = []
         if (job.get("state") in ("configured", "running", "waiting_start", "waiting_manual_start")
                 and all(role.get("imported") for role in job["roles"])):

{cfquant-0.2.55 → cfquant-0.2.56}/cfquant/rpc_timing.py

@@ -7,23 +7,36 @@ class RpcTiming(object):
         self.output = output
         self.started = time.perf_counter()
         self.received_at = None
+        self.sent_at = None
         if output is not None:
             output.update({
                 "request_id": request_id,
+                "started_at": time.time(),
                 "qmt": {"available": False, "reason": "no_response"},
                 "rpc": {"response_received": False},
             })
 
+    def sent(self):
+        self.sent_at = time.perf_counter()
+        if self.output is not None:
+            self.output["rpc"].update({
+                "sent_at": time.time(),
+                "connect_send_ms": round((self.sent_at - self.started) * 1000, 3),
+            })
+
     def received(self, message):
         self.received_at = time.perf_counter()
         if self.output is None:
             return
         self.output["rpc"].update({
+            "received_at": time.time(),
             "response_received": True,
             "response_ok": bool(message.get("ok")),
             "wait_ms": round((self.received_at - self.started) * 1000, 3),
             "json_decode_ms": message.get("_client_parse_ms"),
         })
+        if self.sent_at is not None:
+            self.output["rpc"]["response_wait_ms"] = round((self.received_at - self.sent_at) * 1000, 3)
         meta = message.get("meta") or {}
         qmt = (meta.get("timing") or {}).get("qmt")
         self.output["qmt"] = dict(qmt) if isinstance(qmt, dict) else {
@@ -44,3 +57,5 @@ class RpcTiming(object):
             self.output["rpc"]["total_ms"] = elapsed
             if self.received_at is None:
                 self.output["rpc"]["wait_ms"] = elapsed
+                if self.sent_at is not None:
+                    self.output["rpc"]["response_wait_ms"] = round((time.perf_counter() - self.sent_at) * 1000, 3)