fix(HEL-494): 数据中枢独占调度，主网站不再回退旧接口

主网站只向中枢要业务数据；来源选择、切源、补数全部在中枢内部完成，失败不再走东财/腾讯/Tushare 保底。

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: multica-agent <github@multica.ai>

backend/data/datahub/bridge.py

@@ -19,6 +19,7 @@ from backend.data.datahub.redact import redact_text, redact_value
 from backend.data.datahub.route_state import LEDGER
 from backend.data.datahub.settings import DatahubSettings
 from backend.data.providers.tushare_client import TushareClient
+from backend.data.providers.tushare_transport import TushareError
 
 LOGGER = logging.getLogger("xiaobai.datahub")
 ShadowSink = Callable[[dict[str, Any]], None]
@@ -171,6 +172,45 @@ class DatahubBridge:
             self._log_failure("index_quotes", exc)
             return None
 
+    def try_sector_quote(self, code: str, trade_date: str = "") -> dict[str, Any] | None:
+        flags = self.settings.flags("quotes")
+        if not flags.read:
+            return None
+        try:
+            response = self.client.sector_quote(code, trade_date)
+            data = response.data
+            if not isinstance(data, dict) or not data:
+                raise DatahubError("EMPTY", "datahub sector quote empty")
+            row = dict(data)
+            if (response.meta or {}).get("stale"):
+                row["delayed"] = True
+                row["delay_seconds"] = int((response.meta or {}).get("staleness_seconds") or 0)
+                row["delay_notice"] = str((response.meta or {}).get("delay_notice") or "")
+            self._record_route("quotes", "datahub", str((response.meta or {}).get("source") or "datahub"))
+            return row
+        except Exception as exc:
+            self._log_failure("quotes", exc)
+            return None
+
+    def try_limit_pool(self, trade_date: str = "") -> list[dict[str, Any]] | None:
+        flags = self.settings.flags("limit_events")
+        if not flags.read:
+            return None
+        try:
+            response = self.client.limit_pool(trade_date)
+            rows = [dict(item) for item in (response.data or []) if isinstance(item, dict)]
+            if not rows:
+                raise DatahubError("EMPTY", "datahub limit pool empty")
+            self._record_route(
+                "limit_events",
+                "datahub",
+                str((response.meta or {}).get("source") or "datahub"),
+            )
+            return rows
+        except Exception as exc:
+            self._log_failure("limit_events", exc)
+            return None
+
     def try_daily_chart(
         self,
         code: str,
@@ -191,6 +231,11 @@ class DatahubBridge:
                     self.client.index_bars,
                     {"code": code, "from": start, "to": compact_end},
                 )
+            elif dataset == "sector_daily":
+                response = self._paginate(
+                    self.client.sectors,
+                    {"code": code, "from": start, "to": compact_end},
+                )
             else:
                 response = self._paginate(
                     self.client.daily_bars,
@@ -263,53 +308,33 @@ class DatahubBridge:
         fields: str,
         legacy_query: Callable[..., list[dict[str, Any]]],
     ) -> list[dict[str, Any]]:
+        del legacy_query  # 主网站不再直连 Tushare；调度全部由数据中枢完成。
+        if api_name == "rt_sw_k":
+            raise TushareError("rt_sw_k is disabled; use published sw_daily or free Shenwan realtime")
         dataset = API_TO_DATASET.get(api_name)
-        # 问天按实际数据依赖接入：已映射到 hub 的 API 跟随开关；未映射的继续旧链路。
-        if not dataset:
-            return legacy_query(api_name, params, fields)
-        flags = self.settings.flags(dataset)
-        if not flags.read and not flags.shadow:
-            return legacy_query(api_name, params, fields)
-
-        hub_rows: list[dict[str, Any]] | None = None
-        hub_meta: dict[str, Any] = {}
-        hub_error: str | None = None
-        hub_canonical: list[dict[str, Any]] = []
-        try:
-            response = self._fetch_dataset(dataset, params or {}, api_name=api_name)
-            hub_canonical = self._extract_rows(dataset, response, params or {})
-            hub_rows = to_native_rows(dataset, hub_canonical)
-            hub_meta = dict(response.meta)
-            self._validate_usable(dataset, hub_rows, response)
-        except Exception as exc:
-            hub_error = self._error_text(exc)
-            self._log_failure(dataset, exc)
-
-        if flags.shadow:
-            try:
-                legacy_rows = legacy_query(api_name, params, fields)
-            except Exception as exc:
-                if flags.read and hub_rows is not None and hub_error is None:
-                    self._emit_shadow(
-                        compare_rows(dataset, [], hub_canonical, hub_meta, self._error_text(exc), fields)
-                    )
-                    return project_fields(hub_rows, fields)
-                raise
-            self._emit_shadow(compare_rows(dataset, legacy_rows, hub_canonical, hub_meta, hub_error, fields))
-            if flags.read and hub_rows is not None and hub_error is None:
-                self._record_route(dataset, "datahub", str(hub_meta.get("source") or "datahub"))
-                return project_fields(hub_rows, fields)
+        if dataset:
+            flags = self.settings.flags(dataset)
             if flags.read:
-                self._record_route(dataset, "legacy", "tushare", hub_error or "")
-            return legacy_rows
-
-        if flags.read and hub_rows is not None and hub_error is None:
-            self._record_route(dataset, "datahub", str(hub_meta.get("source") or "datahub"))
-            return project_fields(hub_rows, fields)
-        result = legacy_query(api_name, params, fields)
-        if flags.read:
-            self._record_route(dataset, "legacy", "tushare", hub_error or "")
-        return result
+                try:
+                    response = self._fetch_dataset(dataset, params or {}, api_name=api_name)
+                    hub_canonical = self._extract_rows(dataset, response, params or {})
+                    hub_rows = to_native_rows(dataset, hub_canonical)
+                    self._validate_usable(dataset, hub_rows, response)
+                    self._record_route(dataset, "datahub", str(response.meta.get("source") or "datahub"))
+                    return project_fields(hub_rows, fields)
+                except Exception as exc:
+                    self._log_failure(dataset, exc)
+        try:
+            response = self.client.query_api(api_name, params or {}, fields)
+            rows = [dict(item) for item in (response.data or []) if isinstance(item, dict)]
+            if dataset:
+                self._record_route(dataset, "datahub", str((response.meta or {}).get("source") or "datahub"))
+            else:
+                self._record_route(api_name, "datahub", str((response.meta or {}).get("source") or "datahub"))
+            return rows if not fields else project_fields(rows, fields)
+        except Exception as exc:
+            self._log_failure(dataset or api_name, exc)
+            raise TushareError(self._error_text(exc)) from exc
 
     def _fetch_dataset(self, dataset: str, params: dict[str, Any], api_name: str = "") -> DatahubResponse:
         date = yyyymmdd(params.get("trade_date") or params.get("date"))
@@ -429,8 +454,8 @@ class DatahubBridge:
 
     def _log_failure(self, dataset: str, exc: Exception) -> None:
         error = redact_text(self._error_text(exc), self.settings.secrets())
-        LOGGER.warning("datahub fallback dataset=%s error=%s", dataset, error)
-        self._record_route(dataset, "legacy", "pending-legacy", error)
+        LOGGER.warning("datahub unavailable dataset=%s error=%s", dataset, error)
+        self._record_route(dataset, "datahub", "unavailable", error)
 
     def _record_route(self, dataset: str, route: str, source: str = "", error: str = "") -> None:
         LEDGER.record(dataset, route, source, redact_text(error, self.settings.secrets()))
@@ -529,6 +554,8 @@ class DatahubAwareTushareClient:
         legacy.try_market_quotes = self.try_market_quotes
         legacy.try_quotes = self.try_quotes
         legacy.try_index_quotes = self.try_index_quotes
+        legacy.try_sector_quote = self.try_sector_quote
+        legacy.try_limit_pool = self.try_limit_pool
         legacy.record_datahub_legacy = self.record_datahub_legacy
 
     def query(
@@ -548,6 +575,12 @@ class DatahubAwareTushareClient:
     def try_index_quotes(self) -> list[dict[str, Any]] | None:
         return self._bridge.try_index_quotes()
 
+    def try_sector_quote(self, code: str, trade_date: str = "") -> dict[str, Any] | None:
+        return self._bridge.try_sector_quote(code, trade_date)
+
+    def try_limit_pool(self, trade_date: str = "") -> list[dict[str, Any]] | None:
+        return self._bridge.try_limit_pool(trade_date)
+
     def record_datahub_legacy(self, dataset: str, source: str = "", error: str = "") -> None:
         self._bridge.record_legacy(dataset, source, error)
 

backend/data/datahub/client.py

@@ -90,6 +90,24 @@ class DatahubClient:
             params["dataset"] = dataset
         return self.get("/v1/batches", params)
 
+    def query_api(self, api_name: str, params: dict[str, Any] | None = None, fields: str = "") -> DatahubResponse:
+        return self.post(
+            "/v1/query",
+            {"api_name": api_name, "params": params or {}, "fields": fields},
+        )
+
+    def sector_quote(self, code: str, date: str = "") -> DatahubResponse:
+        payload: dict[str, Any] = {"code": code}
+        if date:
+            payload["date"] = date
+        return self.get("/v1/sectors/quote", payload)
+
+    def limit_pool(self, trade_date: str = "") -> DatahubResponse:
+        params: dict[str, Any] = {}
+        if trade_date:
+            params["date"] = trade_date
+        return self.get("/v1/limit-pool", params)
+
     def get(self, path: str, params: dict[str, Any] | None = None) -> DatahubResponse:
         if not self.settings.token:
             raise DatahubError("NOT_CONFIGURED", "DATAHUB_TOKEN is not configured")
@@ -118,15 +136,41 @@ class DatahubClient:
                 )
         raise last_error or DatahubError("INTERNAL", "datahub request failed")
 
-    def _request(self, url: str) -> DatahubResponse:
+    def post(self, path: str, body: dict[str, Any] | None = None) -> DatahubResponse:
+        if not self.settings.token:
+            raise DatahubError("NOT_CONFIGURED", "DATAHUB_TOKEN is not configured")
+        url = self.settings.base_url + path
+        attempts = 1 + max(0, self.settings.retries)
+        last_error: DatahubError | None = None
+        payload = json.dumps(body or {}, ensure_ascii=False).encode("utf-8")
+        for attempt in range(attempts):
+            try:
+                return self._request(url, method="POST", data=payload)
+            except DatahubError as exc:
+                last_error = exc
+                if exc.code not in {"TIMEOUT", "UNAVAILABLE"} or attempt + 1 >= attempts:
+                    raise
+                LOGGER.warning(
+                    "datahub retry %s/%s %s",
+                    attempt + 1,
+                    attempts,
+                    redact_text(str(exc), self.settings.secrets()),
+                )
+        raise last_error or DatahubError("INTERNAL", "datahub request failed")
+
+    def _request(self, url: str, method: str = "GET", data: bytes | None = None) -> DatahubResponse:
+        headers = {
+            "Accept": "application/json",
+            "X-Datahub-Token": self.settings.token,
+            "User-Agent": "XiaobaiReviewDatahub/1.0",
+        }
+        if data is not None:
+            headers["Content-Type"] = "application/json"
         request = urllib.request.Request(
             url,
-            headers={
-                "Accept": "application/json",
-                "X-Datahub-Token": self.settings.token,
-                "User-Agent": "XiaobaiReviewDatahub/1.0",
-            },
-            method="GET",
+            data=data,
+            headers=headers,
+            method=method,
         )
         try:
             with self._urlopen(request, timeout=self.settings.timeout_seconds) as response: