Initial commit

This commit is contained in:
Alex committed 2026-11-02 22:54:14 +08:00
commit 57fc3525eb
7311 files changed
+1291398

No files matched your search

+748
View File
@@ -0,0 +1,748 @@
# app/core/browser/connection.py
import json
import os
import socket
import threading
import time
import contextlib
from typing import Optional, List, Dict, Any, TYPE_CHECKING
from app.core.driver.drission_internals import connect_existing_browser
from app.core.config import logger, BrowserConstants, BrowserConnectionError, SSEFormatter
from app.core import cdp_hygiene
from app.core.driver import browser_driver
# P0-2 / P0-4:运行期 CDP 卫生补丁(释放 run_js 对象结果、Network.enable 缓冲上限)
cdp_hygiene.install()
if TYPE_CHECKING:
from .main import BrowserCore
from app.core.tab_pool import TabPoolManager, TabSession
def _looks_like_transient_local_debug_error(error: Any) -> bool:
text = str(error or "").strip().lower()
if not text:
return False
if "winerror 10048" in text:
return True
if "max retries exceeded" in text and "127.0.0.1" in text and "/json" in text:
return True
if "failed to establish a new connection" in text and "127.0.0.1" in text:
return True
return False
def _inspect_headless_or_windowless_browser(port: int, timeout: float = 0.5) -> Optional[Dict[str, str]]:
"""
探测指定端口的 Chromium 浏览器是否处于无头(Headless)或无窗口/缺少页面标签页状态。
返回 None 表示不是无头(或者端口未开放/非 Chromium)。
"""
import urllib.request
import json
port_int = int(port)
# 显式使用空 ProxyHandler,避免系统或环境变量代理(如 HTTP_PROXY)拦截 loopback 探测
opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
# 1. 检查进程启动参数 (若 psutil 可用,优先确认是否明确声明了 --headless 或 --no-startup-window)
cmd_has_headless = False
cmd_has_no_startup_window = False
try:
import psutil
target_arg = f"--remote-debugging-port={port_int}"
for proc in psutil.process_iter(["pid", "cmdline"]):
try:
cmdline_list = proc.info.get("cmdline") or []
# 过滤 Chromium 子进程(renderer/gpu/utility 等子进程必然包含 --type=,主进程不包含)
if any(str(arg).startswith("--type=") for arg in cmdline_list):
continue
cmdline = " ".join(cmdline_list)
if target_arg in cmdline:
cmd_lower = cmdline.lower()
if "--headless" in cmd_lower:
cmd_has_headless = True
if "--no-startup-window" in cmd_lower:
cmd_has_no_startup_window = True
if cmd_has_headless and cmd_has_no_startup_window:
break
except Exception:
continue
except Exception:
pass
if cmd_has_headless:
return {"reason": "headless_arg", "detail": "浏览器启动参数显式包含 --headless"}
# 2. 检查 /json/version
version_url = f"http://127.0.0.1:{port_int}/json/version"
try:
req = urllib.request.Request(version_url, headers={"User-Agent": "UWAPI-Diagnostics"})
with opener.open(req, timeout=timeout) as resp:
data = json.loads(resp.read().decode("utf-8", errors="ignore"))
except Exception:
return None
browser_desc = str(data.get("Browser", "") or "")
user_agent = str(data.get("User-Agent", "") or "")
if "headless" in browser_desc.lower() or "headless" in user_agent.lower():
return {
"reason": "headless",
"detail": f"检测到无头浏览器 ({browser_desc or user_agent})",
}
# 3. 检查 /json 目标列表 (targets)
targets_url = f"http://127.0.0.1:{port_int}/json"
try:
req = urllib.request.Request(targets_url, headers={"User-Agent": "UWAPI-Diagnostics"})
with opener.open(req, timeout=timeout) as resp:
targets = json.loads(resp.read().decode("utf-8", errors="ignore"))
if isinstance(targets, list):
pages = [
t for t in targets
if isinstance(t, dict) and str(t.get("type", "")).lower() == "page"
]
if not pages:
if cmd_has_no_startup_window:
return {
"reason": "no_startup_window",
"detail": "浏览器带有 --no-startup-window 参数且当前无前台可视页面",
}
other_types = sorted(list({
str(t.get("type", "unknown"))
for t in targets if isinstance(t, dict) and t.get("type")
}))
detail_types = ", ".join(other_types) if other_types else "无任何活动目标"
return {
"reason": "no_pages",
"detail": f"无可视标签页(当前后台目标: {detail_types})",
}
except Exception:
pass
return None
def _load_model_name_overrides_config() -> Optional[Dict[str, Any]]:
config_path = "config/model_name_overrides.local.json"
if not os.path.exists(config_path):
return None
try:
with open(config_path, "r", encoding="utf-8-sig") as f:
payload = json.load(f)
return payload if isinstance(payload, dict) else None
except Exception as e:
logger.debug(f"加载模型显示名称本地配置失败: {e}")
return None
def _load_preset_overrides_config() -> Optional[Dict[str, Any]]:
config_path = "config/preset_overrides.local.json"
if not os.path.exists(config_path):
return None
try:
with open(config_path, "r", encoding="utf-8-sig") as f:
payload = json.load(f)
return payload if isinstance(payload, dict) else None
except Exception as e:
logger.debug(f"加载预设本地配置失败: {e}")
return None
def _load_tab_pool_config() -> Dict:
"""从配置文件和环境变量加载标签页池配置"""
config = {
"max_tabs": 5,
"min_tabs": 1,
"idle_timeout": 300,
"acquire_timeout": 60,
"stuck_timeout": 180,
"allocation_mode": "first_idle",
"excluded_urls": [],
"preserve_error_tabs": False,
"auto_remember_url_presets": False,
"model_name_overrides": {"sites": {}, "urls": {}},
"preset_overrides": {"urls": {}},
"route_groups": [],
}
# 从 browser_config.json 加载
try:
config_path = "config/browser_config.json"
if os.path.exists(config_path):
with open(config_path, 'r', encoding='utf-8') as f:
file_config = json.load(f)
pool_config = file_config.get("tab_pool", {})
config.update(pool_config)
except Exception as e:
logger.debug(f"加载 tab_pool 配置失败: {e}")
local_model_name_overrides = _load_model_name_overrides_config()
if local_model_name_overrides is not None:
config["model_name_overrides"] = local_model_name_overrides
local_preset_overrides = _load_preset_overrides_config()
if local_preset_overrides is not None:
config["preset_overrides"] = local_preset_overrides
# 环境变量覆盖
if os.getenv("MAX_TABS"):
config["max_tabs"] = int(os.getenv("MAX_TABS"))
if os.getenv("MIN_TABS"):
config["min_tabs"] = int(os.getenv("MIN_TABS"))
allowed_keys = {
"max_tabs",
"min_tabs",
"idle_timeout",
"acquire_timeout",
"stuck_timeout",
"allocation_mode",
"excluded_urls",
"preserve_error_tabs",
"auto_remember_url_presets",
"model_name_overrides",
"preset_overrides",
"route_groups",
}
return {key: value for key, value in config.items() if key in allowed_keys}
class BrowserConnectionMixin:
"""浏览器连接管理、生命周期、Watchdog 及 Tab 巡检混入类"""
@staticmethod
def _to_bool_env(name: str, default: bool = False) -> bool:
value = os.getenv(name)
if value is None:
return default
return str(value).strip().lower() in {"1", "true", "yes", "y", "on"}
def _shutdown_tab_pool_for_reconnect(self, reason: str = "reconnect") -> None:
pool = getattr(self, "_tab_pool", None)
if pool is None:
return
self._tab_pool = None
try:
pool.shutdown()
logger.info(f"[BrowserCore] 已重置旧 TabPool ({reason})")
except Exception as e:
logger.warning(f"[BrowserCore] 重置旧 TabPool 失败 ({reason}): {e}")
def _dispose_previous_browser_handle(self, browser_handle: Any, reason: str = "reconnect") -> None:
if browser_handle is None:
return
if self._to_bool_env("BROWSER_RECONNECT_QUIT_OLD_HANDLE", False):
try:
browser_handle.quit(timeout=1, force=False, del_data=False)
logger.info(f"[BrowserCore] 已关闭旧浏览器句柄 ({reason})")
return
except Exception as e:
logger.debug(f"[BrowserCore] 关闭旧浏览器句柄失败 ({reason}): {e}")
stopped = 0
for driver in [getattr(browser_handle, "_driver", None)]:
stop = getattr(driver, "stop", None)
if callable(stop):
try:
stop()
stopped += 1
except Exception:
pass
try:
all_drivers = getattr(browser_handle, "_all_drivers", {}) or {}
for driver_group in list(all_drivers.values()):
for driver in list(driver_group or []):
stop = getattr(driver, "stop", None)
if callable(stop):
try:
stop()
stopped += 1
except Exception:
pass
except Exception:
pass
if stopped:
logger.debug(f"[BrowserCore] 已释放旧 CDP driver 引用 ({reason}, count={stopped})")
def _connect(self) -> bool:
now = time.time()
# 处于无头模式冷却期时快速返回,避免频繁阻塞 30 秒超时
if now < getattr(self, "_connect_retry_after", 0.0):
return False
previous_handle = getattr(self, "browser_handle", None)
self._shutdown_tab_pool_for_reconnect("connect")
# 端口未开启时直接快速失败,避免调用 DrissionPage 陷入 30 秒内部超时阻塞
if not self._is_debug_port_open():
logger.debug(f"[BrowserCore] 调试端口 {self.port} 未开放,跳过连接")
self.browser_handle = None
self.page = None
self._connected = False
return False
# 快速预检:检查是否为无头或无窗口/缺少页面标签页
headless_info = None
for attempt in range(3):
headless_info = _inspect_headless_or_windowless_browser(self.port)
if not headless_info:
break
# 明确的无头参数无需等待重试
if headless_info.get("reason") in {"headless", "headless_arg", "no_startup_window"}:
break
# 若仅是暂时无 page,等待 0.3s 重试(给正在启动的浏览器事件循环留出时间)
if attempt < 2:
time.sleep(0.3)
if headless_info:
detail = headless_info["detail"]
reason = headless_info.get("reason")
# 明确的无头/无窗口冷却 15 秒;仅缺少页面的瞬时状态设置温和冷却 3 秒
cooldown = 15.0 if reason in {"headless", "headless_arg", "no_startup_window"} else 3.0
self._connect_retry_after = now + cooldown
last_diag = getattr(self, "_last_headless_diagnosis", None)
last_log = getattr(self, "_last_headless_log_at", 0.0)
if detail != last_diag or (now - last_log) >= 60.0:
self._last_headless_diagnosis = detail
self._last_headless_log_at = now
logger.error(
f"检测到受控浏览器(端口 {self.port})处于无头或无窗口模式: {detail}。受控模式需要有界面的正常浏览器,请关闭该后台进程后用启动器重新拉起"
)
else:
logger.debug(
f"[BrowserCore] 仍处于无头/无窗口模式 ({detail}),已抑制重复报错"
)
self.browser_handle = None
self.page = None
self._connected = False
return False
try:
logger.debug(f"连接浏览器 127.0.0.1:{self.port}")
self.browser_handle = connect_existing_browser(f"127.0.0.1:{self.port}")
if previous_handle is not None and previous_handle is not self.browser_handle:
self._dispose_previous_browser_handle(previous_handle, "connect")
try:
self.page = self.browser_handle.latest_tab
except Exception:
self.page = None
self._connected = True
self._last_headless_diagnosis = None
self._start_connection_watchdog()
logger.info("浏览器连接成功")
return True
except Exception as e:
# 连接失败时,进行无头/无窗口诊断
headless_info = _inspect_headless_or_windowless_browser(self.port)
if headless_info:
detail = headless_info["detail"]
self._connect_retry_after = now + 15.0
last_diag = getattr(self, "_last_headless_diagnosis", None)
last_log = getattr(self, "_last_headless_log_at", 0.0)
if detail != last_diag or (now - last_log) >= 60.0:
self._last_headless_diagnosis = detail
self._last_headless_log_at = now
logger.error(
f"检测到受控浏览器(端口 {self.port})处于无头或无窗口模式: {detail}。受控模式需要有界面的正常浏览器,请关闭该后台进程后用启动器重新拉起"
)
else:
logger.debug(
f"[BrowserCore] 仍处于无头/无窗口模式 ({detail}),已抑制重复报错"
)
else:
logger.error(f"浏览器连接失败: {e}")
self.browser_handle = None
self.page = None
self._connected = False
return False
def _is_debug_port_open(self, timeout: float = 0.4) -> bool:
try:
with socket.create_connection(("127.0.0.1", int(self.port)), timeout=float(timeout)):
self._last_debug_port_error = ""
return True
except Exception as e:
self._last_debug_port_error = str(e)
return False
def _probe_browser_connection_via_cdp(self) -> bool:
"""Prefer the long-lived CDP session over spawning /json short connections."""
browser = self.get_browser_handle()
if not browser or not hasattr(browser, "_run_cdp"):
return False
try:
result = browser_driver(browser).run_cdp("Target.getTargets") or {}
target_infos = result.get("targetInfos")
return isinstance(target_infos, list)
except Exception:
return False
def _list_tabs_via_cdp(self) -> List[Any]:
browser = self.get_browser_handle()
if not browser or not hasattr(browser, "_run_cdp"):
return []
try:
result = browser_driver(browser).run_cdp("Target.getTargets") or {}
target_infos = result.get("targetInfos") or []
except Exception:
return []
tabs: List[Any] = []
for info in target_infos:
if not isinstance(info, dict):
continue
if str(info.get("type") or "").strip().lower() != "page":
continue
target_id = str(info.get("targetId") or "").strip()
if not target_id:
continue
try:
resolved = browser.get_tab(target_id)
except Exception:
resolved = None
tabs.append(resolved or target_id)
return tabs
def _log_get_tabs_fallback(self, message: str, error: Any = None) -> None:
now = time.time()
if now - self._last_get_tabs_fallback_log_at < 10.0:
return
self._last_get_tabs_fallback_log_at = now
if _looks_like_transient_local_debug_error(error):
logger.debug(message)
else:
logger.warning(message)
def _probe_browser_connection(self) -> bool:
"""Lightweight liveness probe for the underlying browser session."""
return self._probe_browser_connection_via_cdp()
def get_browser_handle(self):
if self.browser_handle is not None:
return self.browser_handle
browser = getattr(self.page, "browser", None)
if browser is not None:
self.browser_handle = browser
return browser
return self.page
def get_tabs(self):
browser = self.get_browser_handle()
if browser is None:
raise BrowserConnectionError("无法连接到浏览器")
cdp_tabs = self._list_tabs_via_cdp()
if cdp_tabs:
self._get_tabs_retry_after = 0.0
return cdp_tabs
now = time.time()
if now < self._get_tabs_retry_after:
return []
try:
tabs = browser.get_tabs()
self._get_tabs_retry_after = 0.0
return tabs
except Exception as e:
self._get_tabs_retry_after = max(self._get_tabs_retry_after, time.time() + 5.0)
fallback_tabs = self._list_tabs_via_cdp()
if fallback_tabs:
self._log_get_tabs_fallback(
f"[BrowserCore] browser.get_tabs() 失败,回退到 Target.getTargets: {e}",
error=e,
)
return fallback_tabs
raise
def get_tab_ids(self) -> List[str]:
browser = self.get_browser_handle()
if browser is None:
raise BrowserConnectionError("无法连接到浏览器")
return list(getattr(browser, "tab_ids", []) or [])
def get_tab(self, id_or_num=None):
browser = self.get_browser_handle()
if browser is None:
raise BrowserConnectionError("无法连接到浏览器")
return browser.get_tab(id_or_num)
def get_latest_tab(self):
browser = self.get_browser_handle()
if browser is None:
raise BrowserConnectionError("无法连接到浏览器")
return browser.latest_tab
def _get_watchdog_tab_snapshot(self) -> str:
try:
if not self._tab_pool:
return "tab_pool=uninitialized"
if hasattr(self._tab_pool, "get_watchdog_summary"):
status = self._tab_pool.get_watchdog_summary(limit=4)
else:
status = self._tab_pool.get_status()
total = int(status.get("total", 0) or 0)
idle = int(status.get("idle", 0) or 0)
busy = int(status.get("busy", 0) or 0)
tabs = status.get("tabs") or []
labels = []
for item in tabs[:4]:
if not isinstance(item, dict):
continue
labels.append(
f"{item.get('id', '?')}:{item.get('status', '?')}:{'iso' if item.get('is_isolated_context') else 'shared'}"
)
extra = f", tabs=[{', '.join(labels)}]" if labels else ""
return f"tab_pool(total={total}, idle={idle}, busy={busy}{extra})"
except Exception as e:
return f"tab_pool=error({e})"
@staticmethod
def _get_watchdog_float_env(name: str, default: float, minimum: float = 0.5) -> float:
try:
value = float(os.getenv(name, str(default)))
except Exception:
return default
return max(float(minimum), value)
def _has_recent_watchdog_activity(self) -> bool:
now = time.time()
recent_window = self._get_watchdog_float_env(
"BROWSER_WATCHDOG_RECENT_ACTIVITY_WINDOW",
60.0,
minimum=1.0,
)
try:
from app.services.request_manager import request_manager
status = request_manager.get_status()
if int(status.get("running_count", 0) or 0) > 0:
self._last_watchdog_activity_at = now
return True
except Exception:
return True
try:
pool = self._tab_pool
sessions = pool.get_sessions_snapshot() if pool is not None else []
for session in sessions:
status_value = getattr(getattr(session, "status", None), "value", "")
if status_value == "busy":
self._last_watchdog_activity_at = now
return True
except Exception:
return True
last_activity = float(getattr(self, "_last_watchdog_activity_at", 0.0) or 0.0)
return bool(last_activity and now - last_activity < recent_window)
def _get_connection_watchdog_interval(self) -> float:
active_interval = self._get_watchdog_float_env(
"BROWSER_WATCHDOG_ACTIVE_INTERVAL",
3.0,
minimum=0.5,
)
idle_interval = self._get_watchdog_float_env(
"BROWSER_WATCHDOG_IDLE_INTERVAL",
5.0,
minimum=active_interval,
)
return active_interval if self._has_recent_watchdog_activity() else idle_interval
def _connection_watchdog_loop(self) -> None:
while not self._watchdog_stop.wait(self._get_connection_watchdog_interval()):
try:
pool = self._tab_pool
if pool is not None:
pool.run_watchdog_tick()
except Exception as e:
logger.debug(f"[BrowserWatchdog] 标签页巡检异常(忽略): {e}")
port_open = self._is_debug_port_open()
session_alive = self._probe_browser_connection()
health = "alive" if session_alive else ("port_only" if port_open else "dead")
if health == self._last_watchdog_health:
continue
snapshot = self._get_watchdog_tab_snapshot()
if health == "alive":
if port_open:
logger.info(
f"[BrowserWatchdog] 受控浏览器连接正常 (port={self.port}, session=alive, {snapshot})"
)
elif _looks_like_transient_local_debug_error(self._last_debug_port_error):
logger.debug(
f"[BrowserWatchdog] 长连接正常,已忽略瞬时调试端口探测失败 "
f"(port={self.port}, session=alive, {snapshot})"
)
else:
logger.info(
f"[BrowserWatchdog] 受控浏览器连接正常 "
f"(port={self.port}, session=alive, port_probe=failed, {snapshot})"
)
elif health == "port_only":
logger.warning(
f"[BrowserWatchdog] 调试端口可达,但当前页面会话已失效 "
f"(port={self.port}, session=dead, connected={self._connected}, {snapshot})"
)
else:
detail = ""
if self._last_debug_port_error and not _looks_like_transient_local_debug_error(self._last_debug_port_error):
detail = f", probe_error={self._last_debug_port_error}"
logger.error(
f"[BrowserWatchdog] 受控浏览器调试端口不可达 "
f"(port={self.port}, connected={self._connected}, {snapshot}{detail})"
)
self._last_watchdog_port_open = port_open
self._last_watchdog_session_alive = session_alive
self._last_watchdog_health = health
def _start_connection_watchdog(self) -> None:
if self._watchdog_thread and self._watchdog_thread.is_alive():
return
self._watchdog_stop.clear()
self._last_watchdog_port_open = None
self._last_watchdog_session_alive = None
self._last_watchdog_health = None
self._watchdog_thread = threading.Thread(
target=self._connection_watchdog_loop,
daemon=True,
name="browser-connection-watchdog",
)
self._watchdog_thread.start()
def health_check(self) -> Dict[str, Any]:
result = {
"status": "unhealthy",
"connected": False,
"port": self.port,
"tab_pool": None,
"error": None
}
try:
if not self.get_browser_handle():
if not self._connect():
result["error"] = "无法连接到浏览器"
return result
elif not self._probe_browser_connection():
previous_handle = self.browser_handle
self._connected = False
self.browser_handle = None
self.page = None
self._dispose_previous_browser_handle(previous_handle, "health_check")
if not self._connect():
result["error"] = "无法连接到浏览器"
return result
result["status"] = "healthy"
result["connected"] = True
if self._tab_pool:
result["tab_pool"] = self._tab_pool.get_status()
except Exception as e:
result["error"] = str(e)
self._connected = False
return result
def ensure_connection(self) -> bool:
if self._connected:
if self._probe_browser_connection():
return True
previous_handle = self.browser_handle
self._connected = False
self.browser_handle = None
self.page = None
self._dispose_previous_browser_handle(previous_handle, "ensure_connection")
return self._connect()
def get_active_tab(self):
"""
获取一个可用的标签页(兼容旧接口)
注意:新代码应使用 execute_workflow_with_session
"""
# 生成临时任务 ID
task_id = f"legacy_{int(time.time() * 1000)}"
session = self.tab_pool.acquire(task_id, timeout=30)
if session is None:
raise BrowserConnectionError("无法获取可用标签页")
return session.tab
@contextlib.contextmanager
def get_temporary_tab(self, timeout: int = 30):
"""
获取临时标签页的上下文管理器(推荐使用)
使用方式:
with browser.get_temporary_tab() as tab:
elements = tab.eles(selector)
# 退出 with 块后自动释放
Args:
timeout: 获取标签页的超时时间(秒)
Yields:
tab: 浏览器标签页对象
Raises:
BrowserConnectionError: 无法获取可用标签页时抛出
"""
task_id = f"temp_{time.time_ns()}"
session = None
try:
session = self.tab_pool.acquire(task_id, timeout=timeout)
if session is None:
raise BrowserConnectionError("无法获取可用标签页,服务繁忙请稍后重试")
logger.debug(f"[{session.id}] 临时标签页已分配")
yield session.tab
finally:
if session is not None:
self.tab_pool.release(session.id, expected_task_id=task_id)
logger.debug(f"[{session.id}] 临时标签页已释放")
def get_pool_status(self) -> Dict:
"""获取标签页池状态"""
if self._tab_pool:
return self._tab_pool.get_status()
return {"initialized": False}
def _check_page_status(self, tab) -> Dict[str, Any]:
"""检查页面状态"""
result = {"ready": True, "reason": None}
try:
url = tab.url or ""
if not url or url in ("about:blank", "chrome://newtab/"):
result["ready"] = False
result["reason"] = "请先打开目标AI网站"
return result
error_indicators = ["chrome-error://", "about:neterror"]
for indicator in error_indicators:
if indicator in url:
result["ready"] = False
result["reason"] = "页面加载错误"
return result
except Exception as e:
logger.debug(f"页面状态检查异常: {e}")
return result