Files
CodexandClaude Opus 4.7 4557dfb306 operations/screenshot_service: print → logging
- 新增模块级 _svc_log(msg, level):统一走 logging,失败兜底 stdout
- 全部 24 处 print 改为 _svc_log,保留消息中"[截图服务]"前缀以兼容历史搜索
- 默认 level=INFO,告警分级(WARNING/ERROR 等)后续再细化

回归:149 .py 全量编译通过;test_filter_logging / check_web_gui_config_sync 通过。

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-21 09:37:56 +08:00

379 lines
18 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""后台截图服务:持续截图,主流程直接读取最新截图
功能:
1. 后台持续截图,避免主流程等待
2. 截图缓存机制,减少重复截图
3. 智能线程数配置,根据CPU核心数自动调整
"""
from __future__ import annotations
import atexit
import os
import threading
import time
from typing import Optional
from datetime import datetime
from douyin.core import path_config
from operations.screenshot_operations import ScreenshotOperations
import logging as _logging
# 模块级 logger:原代码用 print 输出截图服务日志,这里统一走 logging。
# 保留消息中已有的"[截图服务]"前缀,避免改变历史搜索习惯。
_LOGGER = _logging.getLogger("operations.screenshot_service")
def _svc_log(msg: str, level: str = "INFO") -> None:
"""统一截图服务日志出口;失败兜底 stdout 以避免静默丢失。"""
try:
lv = str(level or "INFO").upper()
if lv == "ERROR":
_LOGGER.error(str(msg))
elif lv == "WARNING":
_LOGGER.warning(str(msg))
elif lv == "DEBUG":
_LOGGER.debug(str(msg))
else:
_LOGGER.info(str(msg))
except Exception:
try:
_svc_log(str(msg))
except Exception:
pass
class ScreenshotService:
"""后台截图服务:持续截图,避免主流程等待"""
_instance: Optional['ScreenshotService'] = None
_lock = threading.Lock()
def __init__(self):
self._running: bool = False
self._thread: Optional[threading.Thread] = None
self._screenshot_ops: ScreenshotOperations = ScreenshotOperations()
self._current_device_id: Optional[str] = None
# 初始化为过去时间,避免第一次请求时出现异常行为
self._last_screenshot_time = time.time() - 10.0
self._screenshot_interval = 3.5
self._cache_valid_duration = 4.0
self._screenshot_path: Optional[str] = None
self._last_success = False
@classmethod
def get_instance(cls) -> 'ScreenshotService':
if cls._instance is None:
with cls._lock:
if cls._instance is None:
cls._instance = cls()
# 类型检查确保:此处在返回前 cls._instance 已被初始化
assert cls._instance is not None
return cls._instance
def start(self, device_id: str, interval: float = 1.5):
with self._lock:
if self._running:
if self._current_device_id == device_id:
return
self.stop()
self._current_device_id = device_id
self._screenshot_interval = max(0.5, interval)
self._running = True
try:
self._screenshot_path = path_config.get_screenshot_path()
except (ImportError, AttributeError, OSError):
self._screenshot_path = os.path.join("pic", "screenshot.png")
self._thread = threading.Thread(
target=self._screenshot_loop, daemon=True, name="ScreenshotService"
)
self._thread.start()
self._last_screenshot_time = time.time() - self._cache_valid_duration - 1.0
timetag = datetime.now().strftime("%H:%M:%S")
_svc_log(f"[{timetag}] [截图服务] 已启动后台截图服务,设备: {device_id}, 间隔: {interval}秒")
def stop(self):
"""停止后台截图服务"""
with self._lock:
if not self._running:
return
self._running = False
if self._thread and self._thread.is_alive():
self._thread.join(timeout=2.0)
timetag = datetime.now().strftime("%H:%M:%S")
_svc_log(f"[{timetag}] [截图服务] 已停止后台截图服务")
def _screenshot_loop(self):
"""后台截图循环"""
loop_count = 0
while self._running:
try:
device_id = self._current_device_id
if not device_id:
time.sleep(0.1)
continue
loop_count += 1
timetag = datetime.now().strftime("%H:%M:%S")
screenshot_start = time.time()
# 执行截图(禁用服务模式,避免递归)
success = self._screenshot_ops.get_screenshot(device_id, use_service=False) # type: ignore[arg-type]
screenshot_elapsed = (time.time() - screenshot_start) * 1000
if success:
# 验证文件完整性后再更新时间戳(避免读取到不完整的文件)
if self._screenshot_path and os.path.exists(self._screenshot_path):
try:
file_size = os.path.getsize(self._screenshot_path)
if file_size >= 1024:
with open(self._screenshot_path, 'rb') as f:
header = f.read(4)
if header == b'\x89PNG':
self._last_screenshot_time = time.time()
self._last_success = True
_svc_log(f"[{timetag}] [截图服务] 后台截图完成 #{loop_count},耗时: {screenshot_elapsed:.0f}ms,文件大小: {file_size/1024:.1f}KB")
else:
self._last_success = False
_svc_log(f"[{timetag}] [截图服务] 后台截图文件格式错误 #{loop_count},耗时: {screenshot_elapsed:.0f}ms")
else:
self._last_success = False
_svc_log(f"[{timetag}] [截图服务] 后台截图文件太小 #{loop_count} ({file_size}B),耗时: {screenshot_elapsed:.0f}ms")
except (OSError, IOError, ValueError) as e:
self._last_success = False
_svc_log(f"[{timetag}] [截图服务] 后台截图文件验证失败 #{loop_count}: {e},耗时: {screenshot_elapsed:.0f}ms")
else:
self._last_success = False
_svc_log(f"[{timetag}] [截图服务] 后台截图文件不存在 #{loop_count},耗时: {screenshot_elapsed:.0f}ms")
else:
self._last_success = False
_svc_log(f"[{timetag}] [截图服务] 后台截图失败 #{loop_count},耗时: {screenshot_elapsed:.0f}ms")
# 等待间隔时间,确保不小于0.5秒
remaining_interval = max(0.5, self._screenshot_interval - screenshot_elapsed / 1000)
time.sleep(remaining_interval)
except Exception as e:
try:
timetag = datetime.now().strftime("%H:%M:%S")
_svc_log(f"[{timetag}] [截图服务] 后台截图异常: {e}")
import traceback
traceback.print_exc()
except Exception:
pass
time.sleep(1.0) # 异常时等待1秒再继续
def get_screenshot(self, device_id: str, force: bool = False) -> bool:
"""获取截图(优先使用缓存)
参数:
device_id: 设备ID
force: 是否强制重新截图(忽略缓存)
返回:
是否成功获取截图
"""
request_start = time.time()
timetag = datetime.now().strftime("%H:%M:%S")
# 如果设备ID不同,需要重新启动服务
if self._current_device_id != device_id:
_svc_log(f"[{timetag}] [截图服务] 设备ID变更,重新启动服务: {device_id}")
self.start(device_id)
# 等待第一次截图完成
time.sleep(0.1)
# 检查缓存是否有效
if not force:
now = time.time()
time_since_last = now - self._last_screenshot_time
# 修复:添加边界检查,避免负数或异常值
if time_since_last < 0:
time_since_last = 0 # 避免时钟回拨导致的负数
elif time_since_last > 86400: # 如果超过24小时,可能是时间戳错误
time_since_last = 10.0 # 重置为10秒前
# 检查缓存是否有效(时间 + 文件存在 + 文件完整性)
if time_since_last < self._cache_valid_duration:
if self._screenshot_path and os.path.exists(self._screenshot_path):
# 验证文件完整性(避免读取到不完整的文件)
# 使用重试机制,等待文件写入完成
for retry in range(3):
try:
file_size = os.path.getsize(self._screenshot_path)
if file_size >= 1024: # PNG文件至少1KB
# 尝试快速验证文件头(PNG文件头:89 50 4E 47)
with open(self._screenshot_path, 'rb') as f:
header = f.read(4)
if header == b'\x89PNG':
# 验证文件尾(PNG文件尾:IEND)
# 更宽松的验证:检查文件末尾50字节内是否有IEND
try:
# 读取文件末尾50字节
read_size = min(50, file_size)
f.seek(-read_size, 2)
footer = f.read(read_size)
if b'IEND' in footer:
elapsed = (time.time() - request_start) * 1000
_svc_log(f"[{timetag}] [截图服务] [OK] 缓存命中,耗时: {elapsed:.1f}ms (距离上次截图: {time_since_last*1000:.0f}ms, 文件大小: {file_size/1024:.1f}KB)")
return True
elif retry < 2:
# 文件可能还在写入,等待一下
time.sleep(0.1)
continue
else:
_svc_log(f"[{timetag}] [截图服务] [WARN] 缓存文件不完整(文件尾验证失败),等待后台截图")
except (OSError, IOError) as e:
if retry < 2:
time.sleep(0.1)
continue
else:
_svc_log(f"[{timetag}] [截图服务] [WARN] 缓存文件读取失败: {e},等待后台截图")
else:
_svc_log(f"[{timetag}] [截图服务] [WARN] 缓存文件格式错误,等待后台截图")
break
else:
if retry < 2:
time.sleep(0.05)
continue
else:
_svc_log(f"[{timetag}] [截图服务] [WARN] 缓存文件太小 ({file_size}B),等待后台截图")
except (OSError, IOError) as e:
if retry < 2:
time.sleep(0.05)
continue
else:
_svc_log(f"[{timetag}] [截图服务] [WARN] 缓存文件检查失败: {e},等待后台截图")
except ValueError as e:
_svc_log(f"[{timetag}] [截图服务] [WARN] 缓存文件检查异常: {e},等待后台截图")
break
else:
_svc_log(f"[{timetag}] [截图服务] [WARN] 缓存文件不存在,等待后台截图")
else:
_svc_log(f"[{timetag}] [截图服务] [WARN] 缓存已过期 (距离上次: {time_since_last*1000:.0f}ms > {self._cache_valid_duration*1000:.0f}ms),等待后台截图")
# 缓存无效或强制刷新
if force:
_svc_log(f"[{timetag}] [截图服务] 🔄 强制刷新,忽略缓存")
# 等待后台截图完成
if self._running:
wait_start = time.time()
time_since_last_before_wait = time.time() - self._last_screenshot_time
# 修复:添加边界检查
if time_since_last_before_wait < 0:
time_since_last_before_wait = 0
elif time_since_last_before_wait > 86400:
time_since_last_before_wait = 10.0
_svc_log(f"[{timetag}] [截图服务] [WAIT] 缓存未命中,等待后台截图 (距离上次: {time_since_last_before_wait*1000:.0f}ms)")
# 等待最多6秒,让后台线程完成截图(适应较慢的截图操作)
max_wait_time = 6.0
while time.time() - wait_start < max_wait_time:
if self._last_screenshot_time > wait_start - 0.1:
# 截图已完成,验证文件完整性
if self._screenshot_path and os.path.exists(self._screenshot_path):
try:
file_size = os.path.getsize(self._screenshot_path)
if file_size >= 1024:
with open(self._screenshot_path, 'rb') as f:
header = f.read(4)
if header == b'\x89PNG':
# 验证文件尾(更宽松的验证)
read_size = min(50, file_size)
f.seek(-read_size, 2)
footer = f.read(read_size)
if b'IEND' in footer:
wait_elapsed = (time.time() - wait_start) * 1000
total_elapsed = (time.time() - request_start) * 1000
status = "[OK]" if self._last_success else "[FAIL]"
_svc_log(f"[{timetag}] [截图服务] {status} 后台截图完成,等待耗时: {wait_elapsed:.1f}ms,总耗时: {total_elapsed:.1f}ms,文件大小: {file_size/1024:.1f}KB")
return self._last_success
# 文件尾验证失败,继续等待
# 文件太小或格式错误,继续等待
except (OSError, IOError, ValueError):
# 文件验证失败,继续等待
pass
time.sleep(0.1)
# 等待超时
wait_elapsed = (time.time() - wait_start) * 1000
_svc_log(f"[{timetag}] [截图服务] [TIMEOUT] 等待超时 ({wait_elapsed:.1f}ms),回退到直接截图")
# 如果后台服务未运行或等待超时,直接执行截图(禁用服务模式,避免递归)
direct_start = time.time()
result = self._screenshot_ops.get_screenshot(device_id, use_service=False) # type: ignore[arg-type]
direct_elapsed = (time.time() - direct_start) * 1000
total_elapsed = (time.time() - request_start) * 1000
status = "[OK]" if result else "[FAIL]"
_svc_log(f"[{timetag}] [截图服务] {status} 直接截图完成,耗时: {direct_elapsed:.0f}ms,总耗时: {total_elapsed:.1f}ms")
return result
def is_running(self) -> bool:
"""检查服务是否正在运行"""
return self._running
def get_last_screenshot_time(self) -> float:
"""获取最后一次截图的时间戳"""
return self._last_screenshot_time
def get_cache_info(self) -> dict:
"""获取缓存信息(用于调试)"""
return {
"running": self._running,
"device_id": self._current_device_id,
"last_screenshot_time": self._last_screenshot_time,
"interval": self._screenshot_interval,
"cache_valid_duration": self._cache_valid_duration,
"last_success": self._last_success,
}
def get_optimal_workers() -> int:
"""根据CPU核心数获取最优线程数,支持环境变量手动覆盖。
环境变量:
FUDAI_OCR_WORKERS: 手动指定并行线程数,优先级最高。
返回:
推荐的线程数
"""
# 用户可通过环境变量强制指定线程数,便于在高核机器上做A/B测试
try:
env_workers = int(os.environ.get("FUDAI_OCR_WORKERS", ""))
if env_workers >= 1:
# 线程数上限不超过并行OCR子任务数(6)再稍微放宽到8,避免极端过载
return max(1, min(env_workers, 8))
except ValueError:
pass
cpu_count = os.cpu_count() or 4
# 默认策略:与子任务数(6)持平或略低,避免4核CPU过度抢占
if cpu_count >= 12:
return 8
if cpu_count >= 8:
return 5
if cpu_count >= 4:
return 4
if cpu_count >= 2:
return 3
return 2
def _shutdown_screenshot_service() -> None:
"""atexit 注册的清理函数,确保进程退出时优雅关闭截图服务"""
try:
if ScreenshotService._instance is not None:
ScreenshotService._instance.stop()
except Exception:
pass
atexit.register(_shutdown_screenshot_service)