Upload 10 files

browser/instance.py

@@ -7,8 +7,9 @@ from utils.cookie_manager import CookieManager
 from browser.navigation import handle_successful_navigation, KeepAliveError
 from browser.cookie_validator import CookieValidator
 from camoufox.sync_api import Camoufox
+from camoufox.exceptions import InvalidIP, InvalidProxy
 from utils.paths import logs_dir
-from utils.common import parse_headless_mode, ensure_dir
+from utils.common import parse_headless_mode, ensure_dir, parse_proxy_config
 from utils.url_helper import extract_url_path, mask_url_for_logging, mask_path_for_logging
 
 
@@ -64,8 +65,13 @@ def run_browser_instance(config, shutdown_event=None):
     # launch_options["block_images"] = True  # 禁用图片加载
     
     if proxy:
-        logger.info(f"使用代理: {proxy} 访问")
-        launch_options["proxy"] = {"server": proxy, "bypass": "localhost, 127.0.0.1"}
+        proxy_config = parse_proxy_config(proxy)
+        if not proxy_config:
+            logger.error("错误: 代理配置无效，无法启动浏览器实例")
+            return
+        logger.info(f"使用代理: {proxy_config.get('server', proxy)} 访问")
+        launch_options["proxy"] = proxy_config
+        launch_options["geoip"] = True
     
     screenshot_dir = logs_dir()
     ensure_dir(screenshot_dir)
@@ -152,6 +158,10 @@ def run_browser_instance(config, shutdown_event=None):
                         logger.info(f"已截取网络错误时的屏幕快照: {screenshot_path}")
                     except Exception as diag_e:
                         logger.error(f"在尝试进行网络错误诊断（截图）时发生额外错误: {diag_e}")
+
+                    error_message_lower = error_message.lower()
+                    if "proxy" in error_message_lower or "ns_error_proxy" in error_message_lower or "err_proxy" in error_message_lower:
+                        raise KeepAliveError(f"代理连接错误: {error_message}")
                     return # 网络错误，终止
 
                 # --- 如果导航没有抛出异常，继续执行后续逻辑 ---
@@ -236,7 +246,12 @@ def run_browser_instance(config, shutdown_event=None):
                 retry_count = 0
                 return
 
-        except KeepAliveError as e:
+        except (InvalidProxy, InvalidIP, KeepAliveError) as e:
+            if isinstance(e, (InvalidProxy, InvalidIP)):
+                retry_reason = f"代理/GeoIP 处理失败: {e}"
+                logger.error(retry_reason)
+            else:
+                retry_reason = str(e)
             retry_count += 1
             if retry_count > max_retries:
                 logger.error(f"重试次数已达上限 ({max_retries})，实例不再重启，退出")
@@ -244,7 +259,7 @@ def run_browser_instance(config, shutdown_event=None):
             
             # 指数退避：3秒、6秒、12秒、24秒...最长60秒
             delay = min(base_delay * (2 ** (retry_count - 1)), 60)
-            logger.error(f"浏览器实例出现错误 (重试 {retry_count}/{max_retries})，将在 {delay} 秒后重启浏览器实例: {e}")
+            logger.error(f"浏览器实例出现错误 (重试 {retry_count}/{max_retries})，将在 {delay} 秒后重启浏览器实例: {retry_reason}")
             time.sleep(delay)
             continue
         except KeyboardInterrupt:

browser/navigation.py

@@ -1,9 +1,10 @@
 import time
 import os
+import random
 from playwright.sync_api import Page, expect
 from utils.paths import logs_dir
 from utils.common import ensure_dir
-from browser.ws_helper import reconnect_ws, get_ws_status, dismiss_interaction_modal, click_in_iframe
+from browser.ws_helper import reconnect_ws, get_ws_status, dismiss_interaction_modal, click_in_iframe, PageLocators
 
 class KeepAliveError(Exception):
     pass
@@ -75,13 +76,16 @@ def handle_successful_navigation(page: Page, logger, cookie_file_config, shutdow
     if cookie_validator:
         logger.info("Cookie验证器已创建，将定期验证Cookie有效性")
 
-    logger.info("实例将保持运行状态。每10秒点击一次页面以保持活动")
+    logger.info("实例将保持运行状态。每8-15秒随机点击一次页面以保持活动")
 
     # 等待页面加载和渲染
     time.sleep(15)
 
+    # 创建 PageLocators 缓存对象，复用 locator 避免内存泄漏
+    locators = PageLocators(page)
+
     # 记录初始WS状态
-    last_ws_status = get_ws_status(page, logger)
+    last_ws_status = get_ws_status(page, logger, locators)
     logger.info(f"初始WS状态: {last_ws_status}")
 
     # 添加Cookie验证计数器
@@ -95,28 +99,27 @@ def handle_successful_navigation(page: Page, logger, cookie_file_config, shutdow
 
         try:
             # 检测并关闭interaction-modal遮罩层（如果出现）
-            dismiss_interaction_modal(page, logger)
+            dismiss_interaction_modal(page, logger, locators)
 
             # 在iframe内随机移动并点击保活
-            click_in_iframe(page, logger)
+            click_in_iframe(page, logger, locators)
             click_counter += 1
 
             # 检查WS状态是否发生变化
-            current_ws_status = get_ws_status(page, logger)
+            current_ws_status = get_ws_status(page, logger, locators)
             if current_ws_status != last_ws_status:
                 logger.warning(f"WS状态变更: {last_ws_status} -> {current_ws_status}")
-                
-                # 如果不是CONNECTED状态，尝试重连
-                if current_ws_status != "CONNECTED":
-                    logger.info("WS断开，尝试重连...")
-                    reconnect_ws(page, logger)
-                    current_ws_status = get_ws_status(page, logger)
-                    logger.info(f"重连后WS状态: {current_ws_status}")
+
+                # 如果状态变成IDLE，尝试重连
+                if current_ws_status == "IDLE":
+                    logger.info("WS状态为IDLE，尝试重连...")
+                    reconnect_ws(page, logger, locators)
+                    current_ws_status = get_ws_status(page, logger, locators)
                 
                 last_ws_status = current_ws_status
 
-            # 每360次点击（1小时）执行一次完整的Cookie验证
-            if cookie_validator and click_counter >= 360:  # 360 * 10秒 = 3600秒 = 1小时
+            # 每720次点击（约2小时）执行一次完整的Cookie验证
+            if cookie_validator and click_counter >= 720:  # 720 * ~10秒 ≈ 7200秒 ≈ 2小时
                 is_valid = cookie_validator.validate_cookies_in_main_thread()
 
                 if not is_valid:
@@ -125,8 +128,9 @@ def handle_successful_navigation(page: Page, logger, cookie_file_config, shutdow
 
                 click_counter = 0  # 重置计数器
 
-            # 使用可中断的睡眠，每秒检查一次关闭信号
-            for _ in range(10):  # 10秒 = 10次1秒检查
+            # 使用可中断的随机睡眠（8-15秒），每秒检查一次关闭信号
+            sleep_duration = random.randint(8, 15)
+            for _ in range(sleep_duration):
                 if shutdown_event and shutdown_event.is_set():
                     logger.info("收到关闭信号，正在优雅退出保持活动循环...")
                     return
@@ -143,4 +147,4 @@ def handle_successful_navigation(page: Page, logger, cookie_file_config, shutdow
                 logger.info(f"已在保持活动循环出错时截屏: {screenshot_filename}")
             except Exception as screenshot_e:
                 logger.error(f"在保持活动循环出错时截屏失败: {screenshot_e}")
-            raise KeepAliveError(f"在保持活动循环时出错: {e}")
+            raise KeepAliveError(f"在保持活动循环时出错: {e}")

browser/ws_helper.py

@@ -3,6 +3,65 @@ import random
 from playwright.sync_api import Page, FrameLocator
 
 
+class PageLocators:
+    """
+    缓存常用的 Locator 对象，避免每次保活循环都创建新对象导致内存泄漏。
+    Playwright 的 Locator 是惰性的，可以安全复用。
+    """
+    
+    def __init__(self, page: Page):
+        self.page = page
+        # 缓存常用的 locator
+        self._modal = None
+        self._iframe = None
+        self._frame = None
+        self._ws_status = None
+        self._disconnect_btn = None
+        self._connect_btn = None
+    
+    @property
+    def modal(self):
+        """interaction-modal 遮罩层"""
+        if self._modal is None:
+            self._modal = self.page.locator('div.interaction-modal')
+        return self._modal
+    
+    @property
+    def iframe(self):
+        """Preview iframe 元素"""
+        if self._iframe is None:
+            self._iframe = self.page.locator('iframe[title="Preview"]')
+        return self._iframe
+    
+    @property
+    def frame(self):
+        """Preview iframe 的 FrameLocator"""
+        if self._frame is None:
+            self._frame = self.page.frame_locator('iframe[title="Preview"]')
+        return self._frame
+    
+    @property
+    def ws_status(self):
+        """WS 状态文本元素"""
+        if self._ws_status is None:
+            self._ws_status = self.frame.locator('text=/WS:\\s*(CONNECTED|IDLE|CONNECTING|RECONNECTING)/i').first
+        return self._ws_status
+    
+    @property
+    def disconnect_btn(self):
+        """Disconnect 按钮"""
+        if self._disconnect_btn is None:
+            self._disconnect_btn = self.frame.locator('button:has-text("Disconnect")')
+        return self._disconnect_btn
+    
+    @property
+    def connect_btn(self):
+        """Connect 按钮"""
+        if self._connect_btn is None:
+            self._connect_btn = self.frame.locator('button:has-text("Connect")')
+        return self._connect_btn
+
+
 def get_preview_frame(page: Page, logger=None) -> FrameLocator:
     """
     获取预览iframe的FrameLocator。
@@ -17,23 +76,31 @@ def get_preview_frame(page: Page, logger=None) -> FrameLocator:
         return None
 
 
-def get_ws_status(page: Page, logger=None) -> str:
+def get_ws_status(page: Page, logger=None, locators: PageLocators = None) -> str:
     """
     获取页面中WS连接状态（在iframe内部）。
-    返回: CONNECTED, IDLE, CONNECTING 或 UNKNOWN
+    返回: CONNECTED, IDLE, CONNECTING, RECONNECTING 或 UNKNOWN
+    
+    Args:
+        page: Playwright Page 对象
+        logger: 日志记录器
+        locators: 可选的 PageLocators 缓存对象，传入可避免重复创建 locator
     """
     try:
-        frame = get_preview_frame(page, logger)
-        if not frame:
-            return "UNKNOWN"
+        if locators:
+            status_element = locators.ws_status
+        else:
+            frame = get_preview_frame(page, logger)
+            if not frame:
+                return "UNKNOWN"
+            status_element = frame.locator('text=/WS:\\s*(CONNECTED|IDLE|CONNECTING|RECONNECTING)/i').first
         
-        # 在iframe内查找包含 "WS:" 的状态文本元素
-        # 根据截图，状态显示为 "WS: CONNECTED" 等格式
-        status_element = frame.locator('text=/WS:\\s*(CONNECTED|IDLE|CONNECTING)/i').first
         if status_element.is_visible(timeout=3000):
             text = status_element.text_content()
             if text:
-                if "CONNECTED" in text.upper():
+                if "RECONNECTING" in text.upper():
+                    return "RECONNECTING"
+                elif "CONNECTED" in text.upper():
                     return "CONNECTED"
                 elif "IDLE" in text.upper():
                     return "IDLE"
@@ -46,16 +113,24 @@ def get_ws_status(page: Page, logger=None) -> str:
         return "UNKNOWN"
 
 
-def click_disconnect(page: Page, logger=None) -> bool:
+def click_disconnect(page: Page, logger=None, locators: PageLocators = None) -> bool:
     """
     点击Disconnect按钮断开WS连接（在iframe内部）。
+    
+    Args:
+        page: Playwright Page 对象
+        logger: 日志记录器
+        locators: 可选的 PageLocators 缓存对象
     """
     try:
-        frame = get_preview_frame(page, logger)
-        if not frame:
-            return False
+        if locators:
+            disconnect_btn = locators.disconnect_btn
+        else:
+            frame = get_preview_frame(page, logger)
+            if not frame:
+                return False
+            disconnect_btn = frame.locator('button:has-text("Disconnect")')
         
-        disconnect_btn = frame.locator('button:has-text("Disconnect")')
         if disconnect_btn.count() > 0 and disconnect_btn.first.is_visible(timeout=3000):
             disconnect_btn.first.click(timeout=5000)
             if logger:
@@ -71,16 +146,24 @@ def click_disconnect(page: Page, logger=None) -> bool:
         return False
 
 
-def click_connect(page: Page, logger=None) -> bool:
+def click_connect(page: Page, logger=None, locators: PageLocators = None) -> bool:
     """
     点击Connect按钮建立WS连接（在iframe内部）。
+    
+    Args:
+        page: Playwright Page 对象
+        logger: 日志记录器
+        locators: 可选的 PageLocators 缓存对象
     """
     try:
-        frame = get_preview_frame(page, logger)
-        if not frame:
-            return False
+        if locators:
+            connect_btn = locators.connect_btn
+        else:
+            frame = get_preview_frame(page, logger)
+            if not frame:
+                return False
+            connect_btn = frame.locator('button:has-text("Connect")')
         
-        connect_btn = frame.locator('button:has-text("Connect")')
         if connect_btn.count() > 0 and connect_btn.first.is_visible(timeout=3000):
             connect_btn.first.click(timeout=5000)
             if logger:
@@ -96,72 +179,87 @@ def click_connect(page: Page, logger=None) -> bool:
         return False
 
 
-def wait_for_ws_connected(page: Page, logger=None, timeout: int = 30) -> bool:
+def wait_for_ws_connected(page: Page, logger=None, timeout: int = 30, locators: PageLocators = None) -> bool:
     """
     等待WS状态变为CONNECTED。
     """
     start_time = time.time()
     while time.time() - start_time < timeout:
-        status = get_ws_status(page, logger)
+        status = get_ws_status(page, logger, locators)
         if status == "CONNECTED":
             return True
         time.sleep(1)
     return False
 
 
-def reconnect_ws(page: Page, logger=None) -> str:
+def reconnect_ws(page: Page, logger=None, locators: PageLocators = None) -> str:
     """
     执行断开再连接的流程，并返回最终WS状态。
     流程：关闭遮罩 -> Disconnect -> 等待IDLE -> Connect -> 等待CONNECTED -> 获取状态
+    
+    Args:
+        page: Playwright Page 对象
+        logger: 日志记录器
+        locators: 可选的 PageLocators 缓存对象
     """
     if logger:
         logger.info("开始执行WS重连流程: Disconnect -> Connect")
     
     # 先关闭 interaction-modal 遮罩层（如果存在）
-    dismiss_interaction_modal(page, logger)
+    dismiss_interaction_modal(page, logger, locators)
     
     # 先断开连接
-    click_disconnect(page, logger)
+    click_disconnect(page, logger, locators)
     time.sleep(2)
     
     # 检查是否变为IDLE
-    status = get_ws_status(page, logger)
+    status = get_ws_status(page, logger, locators)
     if logger:
         logger.info(f"断开后WS状态: {status}")
     
     # 再连接
-    click_connect(page, logger)
+    click_connect(page, logger, locators)
     time.sleep(2)
     
     # 等待连接成功
-    if wait_for_ws_connected(page, logger, timeout=15):
-        status = get_ws_status(page, logger)
+    if wait_for_ws_connected(page, logger, timeout=15, locators=locators):
+        status = get_ws_status(page, logger, locators)
         if logger:
             logger.info(f"重连后WS状态: {status}")
         return status
     else:
-        status = get_ws_status(page, logger)
+        status = get_ws_status(page, logger, locators)
         if logger:
             logger.warning(f"WS重连超时，当前状态: {status}")
         return status
 
 
-def dismiss_interaction_modal(page: Page, logger=None) -> bool:
+def dismiss_interaction_modal(page: Page, logger=None, locators: PageLocators = None) -> bool:
     """
     检测并关闭 interaction-modal 遮罩层。
     通过在 iframe 区域内模拟鼠标移动来触发遮罩层关闭。
     
+    Args:
+        page: Playwright Page 对象
+        logger: 日志记录器
+        locators: 可选的 PageLocators 缓存对象
+    
     返回: True 如果成功关闭遮罩，False 如果未找到遮罩或关闭失败
     """
     try:
-        modal = page.locator('div.interaction-modal')
+        if locators:
+            modal = locators.modal
+            iframe = locators.iframe
+        else:
+            modal = page.locator('div.interaction-modal')
+            iframe = page.locator('iframe[title="Preview"]')
+        
         if modal.count() == 0 or not modal.first.is_visible(timeout=500):
             return False
         
         if logger:
             logger.info("检测到 interaction-modal 遮罩层，尝试关闭...")
         
-        iframe = page.locator('iframe[title="Preview"]')
         if iframe.count() > 0:
             iframe_box = iframe.first.bounding_box()
             if iframe_box:
@@ -193,15 +291,24 @@ def dismiss_interaction_modal(page: Page, logger=None) -> bool:
         return False
 
 
-def click_in_iframe(page: Page, logger=None) -> bool:
+def click_in_iframe(page: Page, logger=None, locators: PageLocators = None) -> bool:
     """
     在 iframe 内随机移动鼠标并点击一次，用于保活。
     避开顶部（状态栏和按钮区域）和右侧区域。
     
+    Args:
+        page: Playwright Page 对象
+        logger: 日志记录器
+        locators: 可选的 PageLocators 缓存对象
+    
     返回: True 如果��功点击，False 如果失败
     """
     try:
-        iframe = page.locator('iframe[title="Preview"]')
+        if locators:
+            iframe = locators.iframe
+        else:
+            iframe = page.locator('iframe[title="Preview"]')
+        
         if iframe.count() == 0:
             return False
         

utils/common.py

@@ -5,6 +5,7 @@
 
 import os
 from pathlib import Path
+from urllib.parse import urlsplit, unquote
 
 def clean_env_value(value):
     """
@@ -49,4 +50,50 @@ def ensure_dir(path):
     """
     if isinstance(path, str):
         path = Path(path)
-    os.makedirs(path, exist_ok=True)
+    os.makedirs(path, exist_ok=True)
+
+
+def parse_proxy_config(proxy_value):
+    """
+    解析代理配置字符串为 Playwright/Camoufox 需要的 dict 结构
+
+    支持格式:
+    - scheme://user:pass@host:port
+    - scheme://host:port
+    - host:port
+    - user:pass@host:port (默认 http)
+
+    Returns:
+        dict or None: {"server": "...", "username": "...", "password": "..."} 或 None
+    """
+    if not proxy_value:
+        return None
+
+    proxy_value = proxy_value.strip()
+    if not proxy_value:
+        return None
+
+    if "://" in proxy_value:
+        parsed = urlsplit(proxy_value)
+        if not parsed.hostname:
+            return {"server": proxy_value}
+        scheme = parsed.scheme
+    else:
+        parsed = urlsplit(f"//{proxy_value}")
+        if not parsed.hostname:
+            return {"server": proxy_value}
+        scheme = "http"
+
+    host = parsed.hostname
+    if host and ":" in host and not host.startswith("["):
+        host = f"[{host}]"
+    server = f"{scheme}://{host}"
+    if parsed.port:
+        server += f":{parsed.port}"
+
+    result = {"server": server}
+    if parsed.username:
+        result["username"] = unquote(parsed.username)
+    if parsed.password:
+        result["password"] = unquote(parsed.password)
+    return result

utils/logger.py

@@ -26,19 +26,26 @@ def setup_logging(log_file, prefix=None, level=logging.INFO):
     配置日志记录器，使其输出到文件和控制台。
     支持一个可选的前缀，用于标识日志来源。
 
-    每次调用都会重新配置处理器，以适应多进程环境。
+    每个 (进程ID, prefix) 组合对应一个独立的 logger，首次调用时初始化，
+    后续调用直接返回已有 logger，避免重复创建 handler 导致内存泄漏。
     
     时间显示默认为 UTC+8 (北京时间)，可通过环境变量 TZ_OFFSET 修改。
 
-    :param log_file: 日志文件的路径。
+    :param log_file: 日志文件的路径（仅首次调用生效）。
     :param prefix: (可选) 要添加到每条日志消息开头的字符串前缀。
-    :param level: 日志级别。
+    :param level: 日志级别（仅首次调用生效）。
     """
-    logger = logging.getLogger('my_app_logger') 
+    # 使用进程ID + 前缀作为 logger 名称，避免不同进程/实例的 logger 互相干扰
+    logger_name = f'camoufox.{os.getpid()}'
+    if prefix:
+        logger_name += f'.{prefix}'
+    
+    logger = logging.getLogger(logger_name) 
     logger.setLevel(level)
 
+    # 如果该 logger 已有 handlers，说明已初始化过，直接返回
     if logger.hasHandlers():
-        logger.handlers.clear()
+        return logger
 
     base_format = '%(asctime)s - %(process)d - %(levelname)s - %(message)s'