1720 lines
72 KiB
Python
1720 lines
72 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
iOS Fastbot + GuiAgent 混合测试脚本
|
||
|
||
测试流程：
|
||
1. 复用 ios_start.py 基础设施（任务加载/管理、日志、安装）
|
||
2. 阶段1: AppleID + GuiAgent 处理权限/登录
|
||
3. 阶段2: Fastbot 快速自动化采集 + 后台页面卡住检测
|
||
4. 分级响应: 10次无变化→back, 30次无变化→暂停Fastbot→Agent处理→重启Fastbot
|
||
|
||
使用示例:
|
||
python ios_test.py -bundle_id com.apple.AppStore -duration 120
|
||
python ios_test.py -batch -app_list utils_ios/ios_only_apps.csv -batch_count 5
|
||
"""
|
||
|
||
import os
|
||
import sys
|
||
import time
|
||
import csv
|
||
import hashlib
|
||
import json
|
||
import threading
|
||
import argparse
|
||
import subprocess
|
||
import logging
|
||
from pathlib import Path
|
||
from datetime import datetime
|
||
from typing import Optional, Dict, Tuple
|
||
|
||
# 找到项目根目录
|
||
ROOT = Path(__file__).resolve().parent
|
||
if str(ROOT) not in sys.path:
|
||
sys.path.insert(0, str(ROOT))
|
||
|
||
from utils_ios.cert_manager import ensure_certs_valid, send_weCom_alert
|
||
|
||
# ============================================================
|
||
# 从 ios_start.py 复用模块
|
||
# ============================================================
|
||
from ios_start import (
|
||
TaskResult,
|
||
IOSBatchStatistics,
|
||
TeeOutput,
|
||
load_env_variables,
|
||
setup_iphone_proxy,
|
||
setup_infrastructure,
|
||
install_app_and_get_bundle_id,
|
||
get_app_info_from_csv,
|
||
load_apps_from_csv,
|
||
start_pcap,
|
||
stop_pcap,
|
||
EXIT_SUCCESS,
|
||
EXIT_ERROR_USER,
|
||
EXIT_WDA_ERROR,
|
||
EXIT_WDA_STUCK,
|
||
EXIT_NETWORK_ERROR,
|
||
EXIT_ERROR_GENERAL,
|
||
)
|
||
|
||
# DroidBot 及 GuiAgent 步数统计（droidbot 模式需要）
|
||
from DroidBot.droidbot import DroidBot
|
||
from DroidBot.guiagent_core.decision_maker import GuiAgentDecisionMaker
|
||
|
||
# WDA 异常类（droidbot 模式异常处理）
|
||
try:
|
||
from DroidBot.exceptions import WDA_RECOVERABLE_EXCEPTIONS
|
||
from DroidBot.platforms.ios.wda.exceptions import WDAStuckError
|
||
WDA_EXCEPTIONS = WDA_RECOVERABLE_EXCEPTIONS + (WDAStuckError,)
|
||
except ImportError:
|
||
WDA_EXCEPTIONS = ()
|
||
WDAStuckError = None
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# ============================================================
|
||
# 退出码扩展
|
||
# ============================================================
|
||
EXIT_FASTBOT_ERROR = 7 # Fastbot 启动/运行失败
|
||
|
||
|
||
# ============================================================
|
||
# 组件1: PageStuckDetector — 页面卡住检测器
|
||
# ============================================================
|
||
class PageStuckDetector:
|
||
"""
|
||
后台异步检测应用是否卡在某个页面
|
||
|
||
检测机制（双重）：
|
||
1. WDA 交互元素指纹：获取 Button/TextField 等元素的 label+value，
|
||
计算特征哈希，连续 N 次相同则判定"疑似卡住"
|
||
2. pcap 流量检测：监控 .flows.jsonl 文件行数增量，
|
||
无新增行说明无网络活动，辅助判定
|
||
|
||
分级响应：
|
||
- back_threshold 次无新特征 → 需要发送 back
|
||
- agent_threshold 次无新特征 → 需要调用 Agent
|
||
"""
|
||
|
||
# 用于提取指纹的交互元素类型
|
||
INTERACTIVE_TYPES = ['Button', 'TextField', 'SecureTextField', 'SearchField']
|
||
|
||
def __init__(self, wda_url: str, check_interval: int = 20,
|
||
back_threshold: int = 10, agent_threshold: int = 30,
|
||
pcap_csv_path: str = None, health_monitor=None):
|
||
"""
|
||
Args:
|
||
wda_url: WDA 服务地址
|
||
check_interval: 检测间隔（秒）
|
||
back_threshold: 发送 back 的阈值
|
||
agent_threshold: 调用 agent 的阈值
|
||
pcap_csv_path: pcap .flows.csv 文件路径
|
||
"""
|
||
self.wda_url = wda_url
|
||
self.check_interval = check_interval
|
||
self.back_threshold = back_threshold
|
||
self.agent_threshold = agent_threshold
|
||
self.pcap_csv_path = pcap_csv_path
|
||
self.health_monitor = health_monitor
|
||
|
||
# 内部状态
|
||
self._stuck_count = 0
|
||
self._last_fingerprint = None
|
||
self._stuck_count = 0
|
||
self._last_fingerprint = None
|
||
self._seen_domains = set()
|
||
self._stuck_info = {}
|
||
self._running = False
|
||
self._lock = threading.Lock()
|
||
self._thread = None
|
||
self._wda_client = None
|
||
|
||
def _get_wda_client(self):
|
||
"""获取或创建 WDA 客户端（http: 格式用 Client，UDID/空用 USBClient）"""
|
||
if self._wda_client is None:
|
||
sys.path.insert(0, str(ROOT / "DroidBot" / "platforms" / "ios"))
|
||
from wda import Client as WDAClient, USBClient as WDAUSBClient
|
||
if self.wda_url and self.wda_url.startswith("http:"):
|
||
self._wda_client = WDAClient(self.wda_url)
|
||
else:
|
||
self._wda_client = WDAUSBClient(udid=self.wda_url or "")
|
||
return self._wda_client
|
||
|
||
def _compute_page_fingerprint(self) -> Optional[str]:
|
||
"""
|
||
通过 WDA source(format='json') 提取交互元素的 label+value 特征字符串，
|
||
计算 hash 作为页面指纹。
|
||
|
||
使用 source(format='json') 一次性获取所有元素信息，
|
||
比逐个 find_elements 效率更高。
|
||
"""
|
||
try:
|
||
client = self._get_wda_client()
|
||
# 使用 JSON 格式获取页面结构，超时 10 秒
|
||
page_source = client.source(format='json', timeout=10)
|
||
|
||
# 递归提取交互元素的 label 和 value
|
||
features = []
|
||
self._extract_interactive_features(page_source, features)
|
||
|
||
if not features:
|
||
return None
|
||
|
||
# 排序以保证一致性，计算 hash
|
||
features.sort()
|
||
fingerprint = hashlib.md5("||".join(features).encode()).hexdigest()
|
||
return fingerprint
|
||
|
||
except Exception as e:
|
||
logger.warning(f"[StuckDetector] 获取页面指纹失败（可能 WDA 断联）: {e}")
|
||
if self.health_monitor:
|
||
logger.info("[StuckDetector] 触发 WDA 恢复并等待...")
|
||
recovered = self.health_monitor.trigger_recovery_and_wait(timeout=120)
|
||
if recovered:
|
||
logger.info("[StuckDetector] WDA 已恢复，重置客户端")
|
||
self._wda_client = None # 重置以便下次循环重建连接
|
||
else:
|
||
logger.error("[StuckDetector] WDA 恢复失败")
|
||
return None
|
||
|
||
def _extract_interactive_features(self, node: dict, features: list):
|
||
"""递归遍历 JSON 页面结构，提取交互元素的 label + value"""
|
||
if not isinstance(node, dict):
|
||
return
|
||
|
||
# 检查当前节点是否为交互元素
|
||
node_type = node.get('type', '')
|
||
# JSON source 中 type 可能带 XCUIElementType 前缀
|
||
short_type = node_type.replace('XCUIElementType', '')
|
||
|
||
if short_type in self.INTERACTIVE_TYPES:
|
||
label = str(node.get('label', ''))
|
||
value = str(node.get('value', ''))
|
||
features.append(f"{short_type}:{label}|{value}")
|
||
|
||
# 递归遍历子节点
|
||
children = node.get('children', [])
|
||
if isinstance(children, list):
|
||
for child in children:
|
||
self._extract_interactive_features(child, features)
|
||
|
||
def _check_flow_activity(self) -> bool:
|
||
"""检测 pcap CSV 是否有新增域名（网络活动）"""
|
||
if not self.pcap_csv_path or not os.path.exists(self.pcap_csv_path):
|
||
return True # 无法检测时默认有活动
|
||
|
||
try:
|
||
new_activity = False
|
||
# csv 可能会被持续写入，使用 errors='ignore' 避免编码问题
|
||
with open(self.pcap_csv_path, 'r', encoding='utf-8', errors='ignore') as f:
|
||
reader = csv.DictReader(f)
|
||
for row in reader:
|
||
domain = row.get('TargetDomain', '').strip()
|
||
if domain and domain not in self._seen_domains:
|
||
self._seen_domains.add(domain)
|
||
new_activity = True
|
||
|
||
return new_activity
|
||
|
||
except Exception as e:
|
||
logger.debug(f"[StuckDetector] 读取 flows.csv 失败: {e}")
|
||
return True # 读取失败时默认有活动
|
||
|
||
def _detection_loop(self):
|
||
"""后台检测循环"""
|
||
logger.info(f"[StuckDetector] 检测线程已启动 (间隔={self.check_interval}s, "
|
||
f"back阈值={self.back_threshold}, agent阈值={self.agent_threshold})")
|
||
|
||
while self._running:
|
||
try:
|
||
current_fingerprint = self._compute_page_fingerprint()
|
||
has_flow_activity = self._check_flow_activity()
|
||
|
||
with self._lock:
|
||
# 页面指纹相同 且 无网络活动 → 卡住计数+1
|
||
if (current_fingerprint is not None and
|
||
current_fingerprint == self._last_fingerprint and
|
||
not has_flow_activity):
|
||
self._stuck_count += 1
|
||
logger.debug(f"[StuckDetector] 页面无变化 "
|
||
f"(count={self._stuck_count}, "
|
||
f"fingerprint={current_fingerprint[:8]}...)")
|
||
# 仅页面指纹相同（有网络活动）→ 也计数但较慢
|
||
elif (current_fingerprint is not None and
|
||
current_fingerprint == self._last_fingerprint):
|
||
self._stuck_count += 0.5
|
||
logger.debug(f"[StuckDetector] 页面无变化但有网络活动 "
|
||
f"(count={self._stuck_count})")
|
||
else:
|
||
# 页面变化了，重置计数
|
||
if self._stuck_count > 0:
|
||
logger.debug(f"[StuckDetector] 页面已变化，重置计数 "
|
||
f"(was {self._stuck_count})")
|
||
self._stuck_count = 0
|
||
|
||
self._last_fingerprint = current_fingerprint
|
||
|
||
# 更新卡住详情
|
||
if self._stuck_count >= self.back_threshold:
|
||
self._stuck_info = {
|
||
'stuck_count': self._stuck_count,
|
||
'fingerprint': current_fingerprint,
|
||
'has_flow_activity': has_flow_activity,
|
||
'timestamp': datetime.now().isoformat(),
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.warning(f"[StuckDetector] 检测循环异常: {e}")
|
||
|
||
# 等待下次检测
|
||
for _ in range(self.check_interval):
|
||
if not self._running:
|
||
break
|
||
time.sleep(1)
|
||
|
||
logger.info("[StuckDetector] 检测线程已退出")
|
||
|
||
def start(self):
|
||
"""启动后台检测线程"""
|
||
if self._running:
|
||
return
|
||
self._running = True
|
||
self._stuck_count = 0
|
||
self._last_fingerprint = None
|
||
self._stuck_count = 0
|
||
self._last_fingerprint = None
|
||
self._seen_domains = set()
|
||
self._thread = threading.Thread(target=self._detection_loop, daemon=True)
|
||
self._thread.start()
|
||
|
||
def stop(self):
|
||
"""停止后台检测线程"""
|
||
self._running = False
|
||
if self._thread and self._thread.is_alive():
|
||
self._thread.join(timeout=self.check_interval + 5)
|
||
self._thread = None
|
||
|
||
def get_action_needed(self) -> Optional[str]:
|
||
"""
|
||
查询当前需要执行的动作
|
||
|
||
Returns:
|
||
'agent' — 需要调用 Agent 处理
|
||
'back' — 需要发送 back 键
|
||
None — 无需操作
|
||
"""
|
||
with self._lock:
|
||
if self._stuck_count >= self.agent_threshold:
|
||
return 'agent'
|
||
elif self._stuck_count >= self.back_threshold:
|
||
return 'back'
|
||
return None
|
||
|
||
def get_stuck_info(self) -> dict:
|
||
"""获取卡住详情"""
|
||
with self._lock:
|
||
return self._stuck_info.copy()
|
||
|
||
def reset(self):
|
||
"""重置计数（Agent 处理完后调用）"""
|
||
with self._lock:
|
||
self._stuck_count = 0
|
||
self._last_fingerprint = None
|
||
self._stuck_info = {}
|
||
logger.info("[StuckDetector] 计数已重置")
|
||
|
||
|
||
# ============================================================
|
||
# 组件2: FastbotAgentController — Fastbot + Agent 混合控制器
|
||
# ============================================================
|
||
class FastbotAgentController:
|
||
"""
|
||
协调 Fastbot 和 GuiAgent 的交替执行
|
||
|
||
核心流程：
|
||
1. 启动 Fastbot
|
||
2. 后台监控循环，检测页面卡住
|
||
3. 10次无新特征 → 通过 WDA 发送 back 键
|
||
4. 30次无新特征 → 停止 Fastbot → Agent 处理 → 重启 Fastbot
|
||
5. Fastbot 正常结束或超时 → 退出
|
||
"""
|
||
|
||
def __init__(self, runner, wda_url: str, bundle_id: str,
|
||
app_name: str = "",
|
||
check_interval: int = 20,
|
||
back_threshold: int = 10,
|
||
agent_threshold: int = 30,
|
||
agent_timeout: int = 120,
|
||
pcap_csv_path: str = None,
|
||
health_monitor=None):
|
||
"""
|
||
Args:
|
||
runner: GoIOSRunner 实例
|
||
wda_url: WDA 服务地址
|
||
bundle_id: 被测应用 Bundle ID
|
||
app_name: 应用真实名称（用于 Agent 提示词，如 'Snapchat'）
|
||
check_interval: 检测间隔（秒）
|
||
back_threshold: 发送 back 的阈值
|
||
agent_threshold: 调用 agent 的阈值
|
||
agent_timeout: Agent 单次处理超时（秒）
|
||
pcap_csv_path: pcap .flows.csv 文件路径
|
||
"""
|
||
self.runner = runner
|
||
self.wda_url = wda_url
|
||
self.bundle_id = bundle_id
|
||
self.app_name = app_name or bundle_id # 回退到 bundle_id
|
||
self.agent_timeout = agent_timeout
|
||
self.health_monitor = health_monitor
|
||
|
||
# 页面卡住检测器
|
||
self.detector = PageStuckDetector(
|
||
wda_url=wda_url,
|
||
check_interval=check_interval,
|
||
back_threshold=back_threshold,
|
||
agent_threshold=agent_threshold,
|
||
pcap_csv_path=pcap_csv_path,
|
||
health_monitor=health_monitor, # 传入统一健康监控
|
||
)
|
||
|
||
# WDA 客户端（懒加载）
|
||
self._wda_client = None
|
||
|
||
# GuiAgent（懒加载）
|
||
self._agent_bridge = None
|
||
|
||
# 统计
|
||
self.back_count = 0 # 执行 back 的次数
|
||
self.agent_count = 0 # 调用 Agent 的次数
|
||
self.fastbot_restarts = 0 # Fastbot 重启次数
|
||
|
||
def _get_wda_client(self):
|
||
"""获取 WDA 客户端（http: 格式用 Client，UDID/空用 USBClient）"""
|
||
if self._wda_client is None:
|
||
sys.path.insert(0, str(ROOT / "DroidBot" / "platforms" / "ios"))
|
||
from wda import Client as WDAClient, USBClient as WDAUSBClient
|
||
if self.wda_url and self.wda_url.startswith("http:"):
|
||
self._wda_client = WDAClient(self.wda_url)
|
||
else:
|
||
self._wda_client = WDAUSBClient(udid=self.wda_url or "")
|
||
return self._wda_client
|
||
|
||
def _init_agent(self):
|
||
"""初始化 GuiAgent for stuck_handler 场景"""
|
||
if self._agent_bridge is not None:
|
||
return
|
||
|
||
try:
|
||
sys.path.insert(0, str(ROOT / "DroidBot" / "platforms" / "ios"))
|
||
from wda import Client as WDAClient, USBClient as WDAUSBClient
|
||
from DroidBot.platforms.ios.ios_device import IOSDevice
|
||
from DroidBot.guiagent_bridge import GuiAgentBridge
|
||
|
||
# 创建轻量级 IOSDevice 用于 Agent 操作
|
||
# IOSDevice 需要 wda_url，用于截图和操作
|
||
device = IOSDevice.__new__(IOSDevice)
|
||
device.wda_url = self.wda_url
|
||
# 根据 wda_url 格式选择连接方式
|
||
if self.wda_url and self.wda_url.startswith("http:"):
|
||
_wda_client = WDAClient(self.wda_url)
|
||
else:
|
||
_wda_client = WDAUSBClient(udid=self.wda_url or "")
|
||
device._wda_client = _wda_client
|
||
device._platform_name = "ios"
|
||
device.get_platform_name = lambda: "ios"
|
||
# GuiAgentBridge._init_agent 需要的属性
|
||
device.display_info = None
|
||
device.output_dir = os.path.join(
|
||
self.output_dir, "agent_stuck"
|
||
) if hasattr(self, 'output_dir') and self.output_dir else "/tmp/agent_stuck"
|
||
os.makedirs(device.output_dir, exist_ok=True)
|
||
device.logger = logging.getLogger("IOSDevice.lightweight.fastbot")
|
||
device._window_size = None
|
||
device._consecutive_failures = 0
|
||
device.WDA_FAILURE_THRESHOLD = 3
|
||
device._wda_health_monitor = None
|
||
device._cached_state = None
|
||
device.bundle_id = self.bundle_id
|
||
device.pause_sending_event = False
|
||
device.cv_mode = False
|
||
|
||
# WDA 健康检查与恢复
|
||
_runner = self.runner if hasattr(self, 'runner') else None
|
||
_wda_url = self.wda_url
|
||
|
||
def _fastbot_wait_wda_ready(timeout=30):
|
||
try:
|
||
return _wda_client.wait_ready(timeout=timeout, noprint=True)
|
||
except Exception as e:
|
||
logging.getLogger("IOSDevice.lightweight.fastbot").warning(
|
||
f"_wait_wda_ready 异常: {e}")
|
||
return False
|
||
|
||
def _fastbot_on_wda_failure(reason=""):
|
||
"""WDA 失败处理：委托给 WDAHealthMonitor 统一处理"""
|
||
_logger = logging.getLogger("IOSDevice.lightweight.fastbot")
|
||
_logger.warning(f"WDA 操作失败 ({reason})，触发统一恢复...")
|
||
_health_mon = self.health_monitor
|
||
if _health_mon:
|
||
recovered = _health_mon.trigger_recovery_and_wait(timeout=120)
|
||
if recovered:
|
||
_logger.info("WDA 已恢复")
|
||
else:
|
||
_logger.error("WDA 恢复失败")
|
||
else:
|
||
_logger.warning("无 WDAHealthMonitor，无法自动恢复")
|
||
|
||
device._wait_wda_ready = _fastbot_wait_wda_ready
|
||
device._on_wda_failure = _fastbot_on_wda_failure
|
||
|
||
# 创建 GuiAgentBridge（使用真实应用名而非 bundle_id）
|
||
self._agent_bridge = GuiAgentBridge(
|
||
device=device,
|
||
app_name=self.app_name,
|
||
)
|
||
logger.info("[FastbotAgent] GuiAgent 初始化成功")
|
||
|
||
except Exception as e:
|
||
logger.error(f"[FastbotAgent] GuiAgent 初始化失败: {e}")
|
||
import traceback
|
||
logger.debug(traceback.format_exc())
|
||
|
||
def _send_back(self):
|
||
"""通过 WDA 发送 back/返回操作"""
|
||
try:
|
||
client = self._get_wda_client()
|
||
# iOS 没有 back 键，使用从左向右滑动模拟返回
|
||
window_size = client.window_size()
|
||
w, h = window_size
|
||
# 从屏幕左边缘向右滑动
|
||
client.swipe(0, h // 2, w // 2, h // 2, duration=0.3)
|
||
self.back_count += 1
|
||
logger.info(f"[FastbotAgent] 发送 back 手势 (总计 {self.back_count} 次)")
|
||
time.sleep(1)
|
||
except Exception as e:
|
||
logger.warning(f"[FastbotAgent] 发送 back 失败: {e}")
|
||
|
||
def _handle_stuck_with_agent(self, stuck_info: dict) -> bool:
|
||
"""
|
||
停止 Fastbot → Agent 处理卡住页面 → 重启 Fastbot
|
||
|
||
Returns:
|
||
是否成功处理
|
||
"""
|
||
logger.info(f"[FastbotAgent] ===== 开始 Agent 干预 =====")
|
||
logger.info(f"[FastbotAgent] 卡住信息: {stuck_info}")
|
||
|
||
# 1. 停止 Fastbot
|
||
logger.info("[FastbotAgent] 正在停止 Fastbot...")
|
||
try:
|
||
self.runner.stop_fastbot()
|
||
time.sleep(2)
|
||
logger.info("[FastbotAgent] Fastbot 已停止")
|
||
except Exception as e:
|
||
logger.warning(f"[FastbotAgent] 停止 Fastbot 异常: {e}")
|
||
|
||
# 2. 确保应用在前台
|
||
try:
|
||
client = self._get_wda_client()
|
||
# 等待 WDA 就绪
|
||
if not client.wait_ready(timeout=15, noprint=True):
|
||
logger.warning("[FastbotAgent] WDA 未就绪，跳过 Agent 干预")
|
||
return False
|
||
|
||
# 启动目标应用
|
||
client.app_launch(self.bundle_id)
|
||
time.sleep(2)
|
||
except Exception as e:
|
||
logger.warning(f"[FastbotAgent] 启动应用失败: {e}")
|
||
|
||
# 3. 调用 GuiAgent 处理
|
||
success = False
|
||
try:
|
||
self._init_agent()
|
||
if self._agent_bridge and self._agent_bridge.is_enabled:
|
||
result = self._agent_bridge.handle_with_guiagent(
|
||
category="stuck_handler",
|
||
context={"stuck_info": stuck_info}
|
||
)
|
||
success = result[0] if isinstance(result, tuple) else bool(result)
|
||
self.agent_count += 1
|
||
logger.info(f"[FastbotAgent] Agent 处理结果: "
|
||
f"{'成功' if success else '未解决'} "
|
||
f"(总计 {self.agent_count} 次)")
|
||
else:
|
||
logger.warning("[FastbotAgent] GuiAgent 不可用，跳过处理")
|
||
except Exception as e:
|
||
logger.error(f"[FastbotAgent] Agent 处理异常: {e}")
|
||
import traceback
|
||
logger.debug(traceback.format_exc())
|
||
|
||
logger.info(f"[FastbotAgent] ===== Agent 干预结束 =====")
|
||
return success
|
||
|
||
def run(self, duration: int = 600, throttle: int = 1000,
|
||
timeout: int = None) -> dict:
|
||
"""
|
||
主执行逻辑：Fastbot + 后台监控 + 分级响应
|
||
|
||
Args:
|
||
duration: Fastbot 单次运行时长（秒）
|
||
throttle: Fastbot 操作间隔（毫秒）
|
||
timeout: 总超时时间（秒），None 则使用 duration
|
||
|
||
Returns:
|
||
执行统计 dict
|
||
"""
|
||
if timeout is None:
|
||
timeout = duration
|
||
|
||
start_time = time.time()
|
||
remaining_duration = duration
|
||
|
||
logger.info(f"[FastbotAgent] 开始混合测试 "
|
||
f"(duration={duration}s, throttle={throttle}ms, timeout={timeout}s)")
|
||
|
||
# 启动检测器
|
||
self.detector.start()
|
||
|
||
# 启动 Fastbot
|
||
try:
|
||
fastbot_proc = self.runner.start_fastbot(
|
||
target_bundle_id=self.bundle_id,
|
||
duration=remaining_duration,
|
||
throttle=throttle,
|
||
)
|
||
logger.info(f"[FastbotAgent] Fastbot 已启动 (PID: {fastbot_proc.pid})")
|
||
except Exception as e:
|
||
logger.error(f"[FastbotAgent] Fastbot 启动失败: {e}")
|
||
self.detector.stop()
|
||
return self._build_stats(start_time, success=False, error="fastbot_start_failed")
|
||
|
||
# 主监控循环
|
||
try:
|
||
while True:
|
||
elapsed = time.time() - start_time
|
||
|
||
# 超时检查
|
||
if elapsed >= timeout:
|
||
logger.info(f"[FastbotAgent] 已达到超时 ({timeout}s)，结束测试")
|
||
break
|
||
|
||
# Fastbot 进程检查
|
||
if fastbot_proc.poll() is not None:
|
||
if elapsed < timeout:
|
||
logger.warning(f"[FastbotAgent] Fastbot 进程提前退出 "
|
||
f"(returncode={fastbot_proc.returncode}, "
|
||
f"已运行: {elapsed:.1f}s, 目标: {timeout}s)")
|
||
# 重启 Fastbot 补足时间
|
||
remaining_duration = max(60, int(timeout - elapsed))
|
||
try:
|
||
fastbot_proc = self.runner.start_fastbot(
|
||
target_bundle_id=self.bundle_id,
|
||
duration=remaining_duration,
|
||
throttle=throttle,
|
||
)
|
||
self.fastbot_restarts += 1
|
||
logger.info(f"[FastbotAgent] Fastbot 异常退出已重启 "
|
||
f"(PID: {fastbot_proc.pid}, "
|
||
f"remaining={remaining_duration}s, "
|
||
f"restarts={self.fastbot_restarts})")
|
||
except Exception as e:
|
||
logger.error(f"[FastbotAgent] Fastbot 异常退出后重启失败: {e}")
|
||
break
|
||
else:
|
||
logger.info(f"[FastbotAgent] Fastbot 进程已结束 "
|
||
f"(returncode={fastbot_proc.returncode})")
|
||
break
|
||
|
||
# 检测页面卡住状态
|
||
action = self.detector.get_action_needed()
|
||
|
||
if action == 'agent':
|
||
# 调用 Agent 处理
|
||
stuck_info = self.detector.get_stuck_info()
|
||
self._handle_stuck_with_agent(stuck_info)
|
||
|
||
# 重置检测器
|
||
self.detector.reset()
|
||
|
||
# 重新计算剩余时间
|
||
elapsed_after_agent = time.time() - start_time
|
||
remaining_duration = max(60, int(duration - elapsed_after_agent))
|
||
|
||
# 重启 Fastbot
|
||
try:
|
||
fastbot_proc = self.runner.start_fastbot(
|
||
target_bundle_id=self.bundle_id,
|
||
duration=remaining_duration,
|
||
throttle=throttle,
|
||
)
|
||
self.fastbot_restarts += 1
|
||
logger.info(f"[FastbotAgent] Fastbot 已重启 "
|
||
f"(PID: {fastbot_proc.pid}, "
|
||
f"remaining={remaining_duration}s, "
|
||
f"restarts={self.fastbot_restarts})")
|
||
except Exception as e:
|
||
logger.error(f"[FastbotAgent] Fastbot 重启失败: {e}")
|
||
break
|
||
|
||
elif action == 'back':
|
||
self._send_back()
|
||
|
||
# 等待一个检测周期
|
||
time.sleep(self.detector.check_interval)
|
||
|
||
except KeyboardInterrupt:
|
||
logger.info("[FastbotAgent] 收到中断信号，停止测试")
|
||
finally:
|
||
# 清理
|
||
self.detector.stop()
|
||
try:
|
||
self.runner.stop_fastbot()
|
||
except Exception:
|
||
pass
|
||
|
||
return self._build_stats(start_time, success=True)
|
||
|
||
def _build_stats(self, start_time: float, success: bool,
|
||
error: str = "") -> dict:
|
||
"""构建执行统计"""
|
||
return {
|
||
'success': success,
|
||
'error': error,
|
||
'duration': time.time() - start_time,
|
||
'back_count': self.back_count,
|
||
'agent_count': self.agent_count,
|
||
'fastbot_restarts': self.fastbot_restarts,
|
||
}
|
||
|
||
|
||
# ============================================================
|
||
# 组件3: IOSFastbotTestRunner — 测试执行器
|
||
# ============================================================
|
||
class IOSFastbotTestRunner:
|
||
"""
|
||
封装单次 Fastbot + GuiAgent 混合测试流程
|
||
|
||
流程：
|
||
1. 创建输出目录、配置日志、启动抓包
|
||
2. 阶段1: 权限处理 + 关键词检测 + GuiAgent 登录
|
||
3. 阶段2: FastbotAgentController.run() — Fastbot + 异步卡住检测
|
||
4. 返回 TaskResult
|
||
"""
|
||
|
||
def __init__(self, runner, wda_url: str, udid: str,
|
||
output_base: str = None, health_monitor=None):
|
||
"""
|
||
Args:
|
||
runner: GoIOSRunner 实例
|
||
wda_url: WDA 服务地址
|
||
udid: 设备 UDID
|
||
output_base: 输出目录基础路径
|
||
health_monitor: WDAHealthMonitor 实例（统一管理 WDA 断联预内恢复）
|
||
"""
|
||
self.runner = runner
|
||
self.wda_url = wda_url
|
||
self.udid = udid
|
||
self.output_base = output_base or os.path.join(ROOT, "output", "ios_test")
|
||
self.health_monitor = health_monitor
|
||
|
||
def run_test(self, bundle_id: str, app_id: str = "", app_name: str = "",raw_app_name: str = "",
|
||
duration: int = 600, throttle: int = 1000,
|
||
enable_login: bool = True,
|
||
check_interval: int = 20,
|
||
back_threshold: int = 10,
|
||
agent_threshold: int = 30,
|
||
agent_timeout: int = 300,
|
||
test_mode: str = "droidbot",
|
||
# droidbot 模式专用参数
|
||
policy: str = "memory_guided",
|
||
event_count: int = 10000,
|
||
cv_mode: bool = False,
|
||
debug_mode: bool = False,
|
||
guiagent_flag: bool = True,
|
||
random_input: bool = False) -> TaskResult:
|
||
"""
|
||
执行完整的混合测试
|
||
|
||
Args:
|
||
bundle_id: 被测应用 Bundle ID
|
||
app_name: 应用名称，来自iOS安装后显示名称（用于日志）
|
||
raw_app_name: 应用原始名称，来自采集名单（用于日志）
|
||
duration: 测试时长（秒）
|
||
throttle: Fastbot 操作间隔（毫秒）
|
||
enable_login: 是否启用登录处理
|
||
check_interval: 卡住检测间隔
|
||
back_threshold: back 阈值
|
||
agent_threshold: agent 阈值
|
||
agent_timeout: agent 超时
|
||
test_mode: 测试模式，'fastbot'（默认）或 'droidbot'
|
||
policy: [droidbot] 探索策略（默认: memory_guided）
|
||
event_count: [droidbot] 最大事件数（默认: 10000）
|
||
cv_mode: [droidbot] 是否启用 CV 模式
|
||
debug_mode: [droidbot] 是否启用调试模式
|
||
guiagent_flag: [droidbot] 是否启用 GuiAgent
|
||
random_input: [droidbot] 是否引入随机输入
|
||
|
||
Returns:
|
||
TaskResult
|
||
"""
|
||
start_time = time.time()
|
||
display_name = app_name or bundle_id
|
||
|
||
# 创建输出目录
|
||
safe_bundle = bundle_id.replace('.', '_')
|
||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
output_dir = os.path.join(
|
||
self.output_base,
|
||
f"{safe_bundle}_iOS_{timestamp}"
|
||
)
|
||
os.makedirs(output_dir, exist_ok=True)
|
||
|
||
# 设置 agent log 目录环境变量
|
||
# GuiAgentDecisionMaker 读取 GUIAGENT_LOG_DIR，其他组件读取 AGENT_LOG_DIR，两个都要设置
|
||
agent_log_dir = os.path.join(ROOT, "output", "agent_logs")
|
||
os.environ['AGENT_LOG_DIR'] = agent_log_dir
|
||
os.environ['GUIAGENT_LOG_DIR'] = agent_log_dir
|
||
os.makedirs(agent_log_dir, exist_ok=True)
|
||
|
||
# 配置日志输出到文件
|
||
log_file = os.path.join(output_dir, "test_log.txt")
|
||
tee = TeeOutput(log_file)
|
||
tee.setup_logging(debug_mode=debug_mode)
|
||
old_stdout, old_stderr = sys.stdout, sys.stderr
|
||
sys.stdout = tee
|
||
sys.stderr = tee
|
||
|
||
pcap_process = None
|
||
flows_jsonl_path = None
|
||
|
||
try:
|
||
print(f"\n{'='*60}")
|
||
print(f" iOS Fastbot+GuiAgent 混合测试")
|
||
print(f" 应用: {display_name} ({bundle_id})")
|
||
print(f" 时长: {duration}s | 间隔: {throttle}ms")
|
||
print(f" 输出: {output_dir}")
|
||
print(f"{'='*60}\n")
|
||
|
||
# ========== 启动抓包（默认启用） ==========
|
||
print("[INFO] 启动抓包...")
|
||
pcap_process = start_pcap(
|
||
bundle_id=bundle_id,
|
||
udid=self.udid,
|
||
output_dir=output_dir,
|
||
app_id=app_id,
|
||
app_name=app_name,
|
||
raw_app_name=raw_app_name,
|
||
)
|
||
time.sleep(2)
|
||
|
||
# 查找 flows.csv 文件路径
|
||
pcap_csv_path = self._find_pcap_csv(output_dir)
|
||
if pcap_csv_path:
|
||
print(f"[INFO] flows.csv 路径: {pcap_csv_path}")
|
||
else:
|
||
print("[WARN] 未找到 flows.csv 文件，流量检测将不可用")
|
||
|
||
# ========== 阶段1: 权限处理 + 关键词检测 + GuiAgent 登录 ==========
|
||
print(f"\n{'='*50}")
|
||
print(f"[阶段1] 权限处理 + 登录检测")
|
||
print(f"{'='*50}\n")
|
||
|
||
if enable_login:
|
||
import concurrent.futures
|
||
try:
|
||
from wda import Client as WDAClient, USBClient as WDAUSBClient
|
||
# 根据 wda_url 格式选择连接方式
|
||
if self.wda_url and self.wda_url.startswith("http:"):
|
||
wda_client = WDAClient(self.wda_url)
|
||
else:
|
||
wda_client = WDAUSBClient(udid=self.wda_url or "")
|
||
|
||
# 1. 启动应用
|
||
print(f"[INFO] 启动应用: {bundle_id}")
|
||
wda_client.session(bundle_id)
|
||
time.sleep(3)
|
||
|
||
# 2. 处理权限弹窗（最多尝试 5 轮）
|
||
print("[INFO] 处理权限弹窗...")
|
||
for _ in range(5):
|
||
try:
|
||
alert = wda_client.alert
|
||
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
|
||
future = executor.submit(lambda: alert.exists)
|
||
try:
|
||
has_alert = future.result(timeout=10)
|
||
except concurrent.futures.TimeoutError:
|
||
print("[WARN] 检查 Alert 超时，跳过")
|
||
break
|
||
if has_alert:
|
||
alert.accept()
|
||
print("[INFO] 已处理一个权限弹窗")
|
||
time.sleep(1)
|
||
else:
|
||
break
|
||
except Exception as e:
|
||
logger.debug(f"处理权限弹窗异常: {e}")
|
||
break
|
||
|
||
# 3. 关键词检测：检查页面是否包含登录/注册相关文案
|
||
LOGIN_KEYWORDS = [
|
||
"登录", "登陆", "login", "sign in", "log in",
|
||
"Apple 继续", "AppleID",
|
||
]
|
||
REGISTER_KEYWORDS = [
|
||
"注册", "register", "sign up", "create account",
|
||
]
|
||
|
||
detected_category = None
|
||
detected_keyword = None
|
||
|
||
def _check_keyword(kw):
|
||
"""检查单个关键词是否存在于页面（labelContains）"""
|
||
try:
|
||
return wda_client(labelContains=kw).exists
|
||
except Exception:
|
||
return False
|
||
time.sleep(5)
|
||
print("[INFO] 检测登录/注册关键词...")
|
||
# 先检测登录关键词
|
||
for kw in LOGIN_KEYWORDS:
|
||
try:
|
||
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
|
||
future = executor.submit(_check_keyword, kw)
|
||
found = future.result(timeout=8)
|
||
if found:
|
||
detected_category = "login"
|
||
detected_keyword = kw
|
||
print(f"[INFO] 检测到登录关键词: '{kw}'")
|
||
break
|
||
except concurrent.futures.TimeoutError:
|
||
logger.debug(f"检测关键词超时: {kw}")
|
||
continue
|
||
except Exception as e:
|
||
logger.debug(f"检测关键词异常: {kw} - {e}")
|
||
continue
|
||
|
||
# 未检测到登录，再检测注册
|
||
if not detected_category:
|
||
for kw in REGISTER_KEYWORDS:
|
||
try:
|
||
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
|
||
future = executor.submit(_check_keyword, kw)
|
||
found = future.result(timeout=8)
|
||
if found:
|
||
detected_category = "register"
|
||
detected_keyword = kw
|
||
print(f"[INFO] 检测到注册关键词: '{kw}'")
|
||
break
|
||
except concurrent.futures.TimeoutError:
|
||
logger.debug(f"检测关键词超时: {kw}")
|
||
continue
|
||
except Exception as e:
|
||
logger.debug(f"检测关键词异常: {kw} - {e}")
|
||
continue
|
||
|
||
# 4. 如果检测到登录/注册关键词，交给 GuiAgent 处理
|
||
if detected_category:
|
||
print(f"[INFO] 启动 GuiAgent 处理 {detected_category}...")
|
||
try:
|
||
from DroidBot.guiagent_bridge import GuiAgentBridge
|
||
from DroidBot.platforms.ios.ios_device import IOSDevice
|
||
|
||
# 创建轻量级 IOSDevice 用于 Agent 操作
|
||
device = IOSDevice.__new__(IOSDevice)
|
||
device.wda_url = self.wda_url
|
||
device._wda_client = wda_client
|
||
device._platform_name = "ios"
|
||
device.get_platform_name = lambda: "ios"
|
||
# GuiAgentBridge._init_agent 需要的属性
|
||
device.display_info = None # get_display_info 需要
|
||
device.output_dir = os.path.join(output_dir, "agent_login")
|
||
os.makedirs(device.output_dir, exist_ok=True)
|
||
device.logger = logging.getLogger("IOSDevice.lightweight")
|
||
device._window_size = None
|
||
device._consecutive_failures = 0
|
||
device.WDA_FAILURE_THRESHOLD = 3
|
||
device._wda_health_monitor = None
|
||
|
||
# WDA 就绪检查：委托给 WDAHealthMonitor（如有），否则轻量实现
|
||
_health_mon = self.health_monitor # 闭包捕获
|
||
|
||
def _lightweight_wait_wda_ready(timeout=30):
|
||
"""等待 WDA 就绪（委托给 health_monitor 或直接检等）"""
|
||
try:
|
||
return wda_client.wait_ready(timeout=timeout, noprint=True)
|
||
except Exception as e:
|
||
logging.getLogger("IOSDevice.lightweight").warning(
|
||
f"_wait_wda_ready 异常: {e}")
|
||
return False
|
||
|
||
def _lightweight_on_wda_failure(reason=""):
|
||
"""委托给 WDAHealthMonitor 统一处理"""
|
||
_logger = logging.getLogger("IOSDevice.lightweight")
|
||
_logger.warning(f"WDA 操作失败 ({reason})，触发统一恢复...")
|
||
if _health_mon:
|
||
recovered = _health_mon.trigger_recovery_and_wait(timeout=120)
|
||
if recovered:
|
||
_logger.info("WDA 已恢复")
|
||
else:
|
||
_logger.error("WDA 恢复失败")
|
||
else:
|
||
# 无 health_monitor 时保持原有轻量实现
|
||
_logger.warning("无 WDAHealthMonitor，无法自动恢复")
|
||
|
||
device._wait_wda_ready = _lightweight_wait_wda_ready
|
||
device._on_wda_failure = _lightweight_on_wda_failure
|
||
|
||
# get_current_state / send_event 需要的属性
|
||
device._cached_state = None
|
||
device.bundle_id = bundle_id
|
||
device.pause_sending_event = False
|
||
device.cv_mode = False
|
||
agent_bridge = GuiAgentBridge(
|
||
device=device,
|
||
app_name=display_name, # 使用真实应用名
|
||
)
|
||
|
||
if agent_bridge.is_enabled:
|
||
agent_result = agent_bridge.handle_with_guiagent(
|
||
category=detected_category,
|
||
max_steps=30,
|
||
max_error_steps=20,
|
||
)
|
||
agent_success = agent_result[0] if isinstance(agent_result, tuple) else bool(agent_result)
|
||
if agent_success:
|
||
print(f"[SUCCESS] GuiAgent {detected_category} 处理完成")
|
||
else:
|
||
print(f"[WARN] GuiAgent {detected_category} 处理未成功")
|
||
else:
|
||
print("[WARN] GuiAgent 不可用")
|
||
except Exception as e:
|
||
print(f"[WARN] GuiAgent 处理异常: {e}")
|
||
import traceback
|
||
logger.debug(traceback.format_exc())
|
||
else:
|
||
print("[INFO] 未检测到登录/注册关键词，跳过登录处理")
|
||
|
||
except Exception as e:
|
||
print(f"[WARN] 阶段1异常: {e}")
|
||
import traceback
|
||
logger.debug(traceback.format_exc())
|
||
else:
|
||
print("[INFO] 跳过登录处理")
|
||
|
||
# 等待应用稳定
|
||
time.sleep(3)
|
||
|
||
# ========== 阶段2: 核心测试（fastbot / droidbot 二选一） ==========
|
||
print(f"\n{'='*50}")
|
||
print(f"[阶段2] 核心测试模式: {test_mode}")
|
||
print(f"{'='*50}\n")
|
||
|
||
if test_mode == "droidbot":
|
||
# ---------- DroidBot 模式（对齐 ios_start.py IOSTestRunner 实现）----------
|
||
droidbot_output_dir = os.path.join(output_dir, "droidbot")
|
||
os.makedirs(droidbot_output_dir, exist_ok=True)
|
||
|
||
# 重置 GuiAgent 步数计数器（每轮任务独立统计）
|
||
GuiAgentDecisionMaker.total_steps = 0
|
||
|
||
droidbot_steps = 0
|
||
guiagent_steps = 0
|
||
_droidbot_ret_code = EXIT_ERROR_GENERAL
|
||
_droidbot_status = "FAILED"
|
||
_droidbot_error = ""
|
||
_user_interrupted = False
|
||
|
||
print(f"[INFO] 启动 DroidBot 测试 "
|
||
f"(policy={policy}, timeout={duration}s, "
|
||
f"event_interval={throttle/1000:.1f}s, event_count={event_count}) ...")
|
||
|
||
try:
|
||
droidbot = DroidBot(
|
||
package_name=bundle_id,
|
||
device_serial=self.udid,
|
||
is_emulator=False,
|
||
output_dir=droidbot_output_dir,
|
||
policy_name=policy,
|
||
random_input=random_input,
|
||
event_interval=throttle / 1000, # 毫秒转秒
|
||
timeout=duration,
|
||
event_count=event_count,
|
||
cv_mode=cv_mode,
|
||
debug_mode=debug_mode,
|
||
keep_app=True, # 不重装应用
|
||
keep_env=False,
|
||
profiling_method=None,
|
||
grant_perm=False,
|
||
enable_accessibility_hard=False,
|
||
humanoid=None,
|
||
ignore_ad=False,
|
||
replay_output=None,
|
||
enable_guiagent=guiagent_flag,
|
||
app_name=app_name,
|
||
platform="ios",
|
||
wda_url=self.wda_url,
|
||
)
|
||
|
||
# 注入 WDA 健康监控
|
||
if self.health_monitor and hasattr(droidbot, 'device'):
|
||
droidbot.device.set_health_monitor(self.health_monitor)
|
||
|
||
# 注入 pcap 流量目录，供 TrafficMonitor.get_traffic_domains() 读取
|
||
# pcap 工具写入 --output={output_dir}，flows.csv 在 output_dir 下
|
||
if hasattr(droidbot, 'device'):
|
||
droidbot.device.captured_traffic_dir = output_dir
|
||
# 同步 output_dir（TrafficMonitor 会从 device.output_dir 推断备用路径）
|
||
if not droidbot.device.output_dir:
|
||
droidbot.device.output_dir = output_dir
|
||
# 注入 pcap 进程引用，供 is_traffic_capture_running / restart_traffic_capture 使用
|
||
if pcap_process and hasattr(droidbot.device, 'set_pcap_process'):
|
||
droidbot.device.set_pcap_process(
|
||
pcap_process,
|
||
restart_kwargs=dict(
|
||
bundle_id=bundle_id,
|
||
udid=self.udid,
|
||
output_dir=output_dir,
|
||
app_id=app_id,
|
||
app_name=app_name,
|
||
raw_app_name=raw_app_name,
|
||
)
|
||
)
|
||
|
||
droidbot.start()
|
||
_droidbot_ret_code = EXIT_SUCCESS
|
||
_droidbot_status = "SUCCESS"
|
||
|
||
# 精确统计步数
|
||
droidbot_steps = droidbot.input_manager.total_exploring_steps
|
||
guiagent_steps = GuiAgentDecisionMaker.total_steps
|
||
|
||
print(f"[SUCCESS] DroidBot 测试完成: {bundle_id}")
|
||
|
||
except KeyboardInterrupt:
|
||
print(f"[WARN] 用户手动中断 DroidBot 测试: {bundle_id}")
|
||
_droidbot_ret_code = EXIT_ERROR_USER
|
||
_droidbot_status = "INTERRUPTED"
|
||
_droidbot_error = "用户手动中断"
|
||
_user_interrupted = True
|
||
except Exception as _e:
|
||
import traceback as _tb
|
||
# WDA 异常区分
|
||
if WDAStuckError and isinstance(_e, WDAStuckError):
|
||
print(f"[ERROR] WDA 卡死且恢复失败: {_e}")
|
||
_droidbot_ret_code = EXIT_WDA_STUCK
|
||
_droidbot_error = f"WDA 卡死恢复失败: {_e}"
|
||
elif WDA_EXCEPTIONS and isinstance(_e, WDA_EXCEPTIONS):
|
||
print(f"[ERROR] WDA 连接异常: {_e}")
|
||
_droidbot_ret_code = EXIT_WDA_ERROR
|
||
_droidbot_error = f"WDA 连接异常: {_e}"
|
||
else:
|
||
print(f"[ERROR] DroidBot 执行异常: {_e}")
|
||
_droidbot_error = f"执行异常: {_e}"
|
||
_droidbot_status = "FAILED"
|
||
logger.debug(_tb.format_exc())
|
||
finally:
|
||
# 尽量获取步数（即使 droidbot.start() 中途抛出异常也要读取）
|
||
try:
|
||
droidbot_steps = droidbot.input_manager.total_exploring_steps
|
||
except Exception:
|
||
pass
|
||
try:
|
||
guiagent_steps = GuiAgentDecisionMaker.total_steps
|
||
except Exception:
|
||
pass
|
||
|
||
elapsed = time.time() - start_time
|
||
total_steps_db = droidbot_steps + guiagent_steps
|
||
print(f"[INFO] DroidBot 步数: {droidbot_steps}")
|
||
print(f"[INFO] GuiAgent 步数: {guiagent_steps}")
|
||
print(f"[INFO] 总步数: {total_steps_db}")
|
||
|
||
_result = TaskResult(
|
||
status=_droidbot_status,
|
||
exit_code=_droidbot_ret_code,
|
||
error_reason=_droidbot_error,
|
||
droidbot_steps=droidbot_steps,
|
||
guiagent_steps=guiagent_steps,
|
||
total_steps=total_steps_db,
|
||
duration_seconds=elapsed,
|
||
test_timestamp=timestamp,
|
||
)
|
||
if _user_interrupted:
|
||
raise KeyboardInterrupt(_result)
|
||
return _result
|
||
|
||
else:
|
||
# ---------- Fastbot 模式（默认） ----------
|
||
controller = FastbotAgentController(
|
||
runner=self.runner,
|
||
wda_url=self.wda_url,
|
||
bundle_id=bundle_id,
|
||
app_name=app_name, # 传入真实应用名
|
||
check_interval=check_interval,
|
||
back_threshold=back_threshold,
|
||
agent_threshold=agent_threshold,
|
||
agent_timeout=agent_timeout,
|
||
pcap_csv_path=pcap_csv_path,
|
||
health_monitor=self.health_monitor, # 传入统一健康监控
|
||
)
|
||
|
||
stats = controller.run(
|
||
duration=duration,
|
||
throttle=throttle,
|
||
timeout=duration,
|
||
)
|
||
|
||
# ========== 构建结果 ==========
|
||
elapsed = time.time() - start_time
|
||
|
||
print(f"\n{'='*50}")
|
||
print(f" 测试完成")
|
||
print(f" 耗时: {elapsed:.1f}s")
|
||
print(f" Back 次数: {stats['back_count']}")
|
||
print(f" Agent 介入: {stats['agent_count']} 次")
|
||
print(f" Fastbot 重启: {stats['fastbot_restarts']} 次")
|
||
print(f"{'='*50}\n")
|
||
|
||
return TaskResult(
|
||
status="SUCCESS",
|
||
exit_code=EXIT_SUCCESS,
|
||
error_reason="",
|
||
droidbot_steps=0, # Fastbot 模式无 DroidBot 步数
|
||
guiagent_steps=stats['agent_count'],
|
||
total_steps=stats['back_count'] + stats['agent_count'],
|
||
duration_seconds=elapsed,
|
||
test_timestamp=timestamp,
|
||
)
|
||
|
||
except KeyboardInterrupt:
|
||
elapsed = time.time() - start_time
|
||
print(f"\n[INTERRUPTED] 用户中断测试 (耗时 {elapsed:.1f}s)")
|
||
return TaskResult(
|
||
status="INTERRUPTED",
|
||
exit_code=EXIT_ERROR_USER,
|
||
error_reason="用户中断",
|
||
droidbot_steps=0,
|
||
guiagent_steps=0,
|
||
total_steps=0,
|
||
duration_seconds=elapsed,
|
||
test_timestamp=timestamp,
|
||
)
|
||
|
||
except Exception as e:
|
||
elapsed = time.time() - start_time
|
||
import traceback
|
||
error_msg = str(e)
|
||
print(f"\n[ERROR] 测试异常: {error_msg}")
|
||
print(traceback.format_exc())
|
||
return TaskResult(
|
||
status="FAILED",
|
||
exit_code=EXIT_ERROR_GENERAL,
|
||
error_reason=error_msg,
|
||
droidbot_steps=0,
|
||
guiagent_steps=0,
|
||
total_steps=0,
|
||
duration_seconds=elapsed,
|
||
test_timestamp=timestamp,
|
||
)
|
||
|
||
finally:
|
||
# 停止抓包
|
||
stop_pcap(pcap_process)
|
||
|
||
# 恢复标准输出
|
||
sys.stdout = old_stdout
|
||
sys.stderr = old_stderr
|
||
tee.close()
|
||
|
||
def _find_pcap_csv(self, output_dir: str) -> Optional[str]:
|
||
"""查找 pcap 生成的 .flows.csv 文件"""
|
||
# pcap 工具生成的文件名格式: dump-{bundle_id}-{timestamp}.pcap.flows.csv
|
||
# 递归查找 traffic 子目录
|
||
traffic_dir = os.path.join(output_dir, "traffic")
|
||
search_dirs = [output_dir]
|
||
if os.path.exists(traffic_dir):
|
||
search_dirs.insert(0, traffic_dir)
|
||
|
||
for _ in range(2): # 尝试两次，中间等待
|
||
for d in search_dirs:
|
||
if not os.path.exists(d):
|
||
continue
|
||
try:
|
||
for fname in os.listdir(d):
|
||
if fname.endswith('.flows.csv'):
|
||
return os.path.join(d, fname)
|
||
except Exception:
|
||
pass
|
||
|
||
# 等待文件生成
|
||
time.sleep(5)
|
||
|
||
return None
|
||
|
||
|
||
# ============================================================
|
||
# 组件4: 命令行参数和主函数
|
||
# ============================================================
|
||
def parse_args():
|
||
"""解析命令行参数"""
|
||
parser = argparse.ArgumentParser(
|
||
description="iOS Fastbot + GuiAgent 混合测试脚本",
|
||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||
epilog="""
|
||
示例:
|
||
# 单个应用测试
|
||
python ios_test.py -bundle_id com.apple.AppStore -duration 120
|
||
|
||
# 批量模式
|
||
python ios_test.py -batch -app_list output/ios/app_magic_summary_apple_no_google.csv -batch_count 5
|
||
|
||
# 自定义检测参数
|
||
python ios_test.py -bundle_id com.example.app -duration 600 \\
|
||
-stuck_check_interval 15 -back_threshold 8 -agent_threshold 20
|
||
"""
|
||
)
|
||
|
||
# 基本参数
|
||
parser.add_argument('-bundle_id', type=str, default='',
|
||
help='被测应用的 Bundle ID')
|
||
parser.add_argument('-wda_url', type=str,
|
||
default='00008101-0016601022C0001E',
|
||
help='WDA 服务地址或设备 UDID (默认: 00008101-0016601022C0001E 或 http://localhost:8100)')
|
||
parser.add_argument('-udid', type=str, default='00008101-0016601022C0001E',
|
||
help='设备 UDID')
|
||
parser.add_argument('-duration', type=int, default=5400,
|
||
help='测试时长/秒 (默认: 5400)')
|
||
parser.add_argument('-throttle', type=int, default=500,
|
||
help='Fastbot 操作间隔/毫秒 (默认: 500)')
|
||
|
||
# 登录相关
|
||
parser.add_argument('-enable_login', action='store_true',
|
||
help='启用 AppleID 登录处理')
|
||
|
||
# 批量模式
|
||
parser.add_argument('-batch', action='store_true',
|
||
help='启用批量测试模式')
|
||
parser.add_argument('-app_list', type=str,
|
||
default=str(ROOT / 'output' / 'ios' / 'app_magic_summary_apple_no_google.csv'),
|
||
help='应用列表 CSV 文件路径')
|
||
parser.add_argument('-batch_start', type=int, default=-1,
|
||
help='批量测试起始 index（对应 CSV 中的 0-based 行号）。'
|
||
'不指定（默认 -1）时启用智能调度：未测优先，SKIPPED/FAILED 放队尾')
|
||
parser.add_argument('-batch_count', type=int, default=0,
|
||
help='批量测试数量, 0=全部 (默认: 0)')
|
||
parser.add_argument('-resume_from', type=str, default='',
|
||
help='断点续传指定的 previous batch result CSV 路径')
|
||
|
||
# 页面卡住检测参数
|
||
parser.add_argument('-stuck_check_interval', type=int, default=20,
|
||
help='页面卡住检测间隔/秒 (默认: 20)')
|
||
parser.add_argument('-back_threshold', type=int, default=10,
|
||
help='发送 back 的检测次数阈值 (默认: 10)')
|
||
parser.add_argument('-agent_threshold', type=int, default=30,
|
||
help='调用 Agent 的检测次数阈值 (默认: 30)')
|
||
parser.add_argument('-agent_timeout', type=int, default=300,
|
||
help='Agent 单次处理超时/秒 (默认: 300)')
|
||
|
||
# 测试模式
|
||
parser.add_argument('-test_mode', type=str, default='droidbot',
|
||
choices=['fastbot', 'droidbot'],
|
||
help='核心测试模式: fastbot（默认）或 droidbot')
|
||
|
||
# DroidBot 模式专用参数
|
||
parser.add_argument('-policy', type=str, default='memory_guided',
|
||
help='[droidbot] 探索策略 (默认: memory_guided)')
|
||
parser.add_argument('-event_count', type=int, default=10000,
|
||
help='[droidbot] 最大事件数 (默认: 10000)')
|
||
parser.add_argument('-cv_mode', action='store_true', default=False,
|
||
help='[droidbot] 启用 CV 模式')
|
||
parser.add_argument('-debug_mode', action='store_true', default=False,
|
||
help='[droidbot] 启用调试模式')
|
||
parser.add_argument('-guiagent_flag', type=bool, default=True,
|
||
help='[droidbot] 是否启用 GuiAgent')
|
||
parser.add_argument('-random_input', action='store_true', default=False,
|
||
help='[droidbot] 引入随机输入')
|
||
|
||
# 输出
|
||
parser.add_argument('-output_dir', type=str,
|
||
default=str(ROOT / 'output' / 'ios_test'),
|
||
help='输出目录 (默认: output/ios_test)')
|
||
|
||
return parser.parse_args()
|
||
|
||
|
||
def _read_tested_history(output_dir: str) -> dict:
|
||
"""读取历史测试记录，返回 {index: (status, error_reason)} 字典
|
||
|
||
扫描 output_dir 目录下所有 ios_batch_result_*.csv 文件，
|
||
同一个 index 的最新记录（按文件名时间戳排序）为准。
|
||
"""
|
||
import glob
|
||
result_dir = str(Path(output_dir).parent) if not output_dir.endswith('output') else output_dir
|
||
# 查找所有 batch result CSV（兼容 output/ 目录的父目录）
|
||
patterns = [
|
||
os.path.join(result_dir, 'ios_batch_result_*.csv'),
|
||
os.path.join(os.path.dirname(result_dir), 'ios_batch_result_*.csv'),
|
||
os.path.join(str(ROOT / 'output'), 'ios_batch_result_*.csv'),
|
||
]
|
||
files = []
|
||
for pat in patterns:
|
||
files.extend(glob.glob(pat))
|
||
files = sorted(set(files)) # 去重，按文件名时间排序
|
||
|
||
history = {} # index -> (status, error_reason)
|
||
for fpath in files:
|
||
try:
|
||
with open(fpath, 'r', encoding='utf-8') as f:
|
||
reader = csv.DictReader(f)
|
||
for row in reader:
|
||
try:
|
||
idx = int(row['index'])
|
||
status = row.get('status', '').strip()
|
||
error_reason = row.get('error_reason', '').strip()
|
||
if status:
|
||
history[idx] = (status, error_reason)
|
||
except (ValueError, KeyError):
|
||
pass
|
||
except Exception:
|
||
pass
|
||
return history
|
||
|
||
|
||
# 不应重试的永久性失败原因（应用本身问题，重试也无法成功）
|
||
PERMANENT_FAIL_REASONS = ["应用不可用", "付费应用"]
|
||
|
||
|
||
def _is_permanent_failure(status: str, error_reason: str) -> bool:
|
||
"""判断是否为永久性失败（不应重试）"""
|
||
if status == 'SUCCESS':
|
||
return True
|
||
return any(reason in error_reason for reason in PERMANENT_FAIL_REASONS)
|
||
|
||
|
||
def load_apps_smart_schedule(csv_path: str, batch_count: int = 0) -> list:
|
||
"""智能调度：未测应用优先，失败放队尾
|
||
|
||
Args:
|
||
csv_path: 应用列表 CSV
|
||
batch_count: 调度数量上限，0=全部
|
||
|
||
Returns:
|
||
排好序的 app_info 列表（每条含 index、app_id、name）
|
||
顺序：未测（按 CSV 顺序）→ SKIPPED/FAILED（按 CSV 顺序）
|
||
"""
|
||
output_dir = str(ROOT / 'output')
|
||
history = _read_tested_history(output_dir)
|
||
|
||
# 加载全量应用
|
||
all_apps = load_apps_from_csv(csv_path)
|
||
total = len(all_apps)
|
||
|
||
# 成功/永久性失败 不重测；未测 & 可重试失败 分开
|
||
untested = []
|
||
failed = []
|
||
permanent_fail_count = 0
|
||
for app in all_apps:
|
||
idx = app['index']
|
||
record = history.get(idx)
|
||
if record is None:
|
||
untested.append(app) # 未测
|
||
else:
|
||
status, error_reason = record
|
||
if _is_permanent_failure(status, error_reason):
|
||
if status != 'SUCCESS':
|
||
permanent_fail_count += 1
|
||
continue # 已成功或永久性失败，跳过
|
||
else:
|
||
failed.append(app) # SKIPPED / FAILED（可重试）
|
||
|
||
scheduled = untested + failed
|
||
tested_count = total - len(untested) - len(failed) - permanent_fail_count
|
||
print(f"[INFO] 历史记录：共 {len(history)} 条 | 已成功: {tested_count} | 永久失败: {permanent_fail_count} | 未测: {len(untested)} | 待重试: {len(failed)}")
|
||
|
||
if batch_count > 0:
|
||
scheduled = scheduled[:batch_count]
|
||
return scheduled
|
||
|
||
|
||
def run_batch_mode(args, runner, udid: str):
|
||
"""批量测试模式"""
|
||
# 初始化统计
|
||
stats = IOSBatchStatistics(output_dir=args.output_dir)
|
||
|
||
# 修改详细数据存储位置
|
||
if args.output_dir.endswith('ios_test') or args.output_dir.endswith('ios_test/'):
|
||
base_dir = os.path.dirname(args.output_dir.rstrip('/'))
|
||
args.output_dir = os.path.join(base_dir, f"ios_test_{stats.start_time.strftime('%Y%m%d_%H%M%S')}")
|
||
stats.output_dir = args.output_dir
|
||
|
||
# ----- 决定应用列表 -----
|
||
# 若指定了 batch_start，则从指定位置顺序加载（精确控制）
|
||
# 若未指定（默认 -1），则启用智能调度：未测优先，失败放队尾
|
||
use_smart_schedule = (args.batch_start < 0)
|
||
|
||
if use_smart_schedule:
|
||
print(f"\n{'='*60}")
|
||
print(f" iOS Fastbot+GuiAgent 批量测试模式（智能调度）")
|
||
print(f" CSV: {args.app_list}")
|
||
print(f" 模式: 未测优先，SKIPPED/FAILED 放队尾")
|
||
print(f"{'='*60}\n")
|
||
apps = load_apps_smart_schedule(args.app_list, batch_count=args.batch_count)
|
||
else:
|
||
print(f"\n{'='*60}")
|
||
print(f" iOS Fastbot+GuiAgent 批量测试模式")
|
||
print(f" CSV: {args.app_list}")
|
||
print(f" 起始 index: {args.batch_start} | 数量: {args.batch_count or '全部'}")
|
||
print(f"{'='*60}\n")
|
||
apps = load_apps_from_csv(
|
||
csv_path=args.app_list,
|
||
start_index=args.batch_start,
|
||
count=args.batch_count,
|
||
)
|
||
|
||
if not apps:
|
||
print("[ERROR] 未找到可测试的应用")
|
||
return
|
||
|
||
print(f"[INFO] 加载 {len(apps)} 个应用")
|
||
|
||
# 定期报告：每6小时发送一次采集情况
|
||
REPORT_INTERVAL = 6 * 3600 # 6小时（秒）
|
||
last_report_time = time.time()
|
||
batch_start_time = time.time()
|
||
|
||
# 初始化 WDA 健康监控（用于卡死检测与异步恢复）
|
||
from utils_ios.wda_health import WDAHealthMonitor
|
||
wda_health_monitor = WDAHealthMonitor(
|
||
wda_url=args.wda_url,
|
||
go_ios_runner=runner,
|
||
)
|
||
print("[INFO] WDA 健康监控已初始化")
|
||
|
||
# 测试执行器
|
||
test_runner = IOSFastbotTestRunner(
|
||
runner=runner,
|
||
wda_url=args.wda_url,
|
||
udid=udid,
|
||
output_base=args.output_dir,
|
||
health_monitor=wda_health_monitor, # 传入统一健康监控
|
||
)
|
||
|
||
# 遍历应用列表
|
||
for i, app_info in enumerate(apps):
|
||
app_id = app_info['app_id']
|
||
app_name = app_info.get('name', '')
|
||
index = app_info['index'] # CSV 中的 0-based 唯一行号
|
||
|
||
print(f"\n{'='*60}")
|
||
print(f" [index={index}] ({i+1}/{len(apps)}) {app_name or app_id}")
|
||
print(f"{'='*60}\n")
|
||
|
||
wda_health_monitor.reset_attempts()
|
||
|
||
# 安装前检查证书有效性（证书过期会导致 WDA/Fastbot 无法运行）
|
||
if not ensure_certs_valid(udid, runner, threshold_hours=24):
|
||
send_weCom_alert("证书更新异常，采集终止")
|
||
break
|
||
|
||
# 安装应用
|
||
bundle_id, reason = install_app_and_get_bundle_id(
|
||
app_id=app_id,
|
||
wda_url=args.wda_url,
|
||
udid=udid,
|
||
health_monitor=wda_health_monitor
|
||
)
|
||
|
||
# 安装完成后先使用go-ios ps -apps获取运行应用信息（json），过滤Name为WebDriverAgentRunner-Runner的应用，其他应用关闭
|
||
try:
|
||
import json
|
||
import subprocess
|
||
print("[INFO] 开始清理后台常驻应用...")
|
||
go_ios_bin = str(ROOT / "utils_ios" / "go_ios" / "bin" / "ios-darwin-arm64")
|
||
if not os.path.exists(go_ios_bin):
|
||
go_ios_bin = "ios"
|
||
|
||
ps_cmd = [go_ios_bin, "ps", "--apps", "--udid", udid]
|
||
ps_result = subprocess.run(ps_cmd, capture_output=True, text=True, timeout=15)
|
||
if ps_result.returncode == 0:
|
||
apps_info = json.loads(ps_result.stdout)
|
||
for app in apps_info:
|
||
name = app.get("Name", "")
|
||
pid = app.get("Pid")
|
||
if name and name != "WebDriverAgentRunner-Runner" and pid:
|
||
kill_cmd = [go_ios_bin, "kill", f"--pid={pid}", "--udid", udid]
|
||
subprocess.run(kill_cmd, capture_output=True, timeout=5)
|
||
print(f"[INFO] 已关闭后台应用: {name} (PID: {pid})")
|
||
except Exception as e:
|
||
print(f"[WARN] 清理后台应用异常: {e}")
|
||
|
||
# 安装失败处理（WDA 断联已在底层安装过程中自动处理+等待恢复）
|
||
# 到达此处的失败均为：付费应用、应用不可用、安装超时等真实业务失败
|
||
if not bundle_id:
|
||
csv_app_id_fail = app_id if not app_id.isdigit() else f"id{app_id}"
|
||
# 永久性失败（应用不可用、付费应用）记录为 FAILED，避免后续重试
|
||
if any(r in (reason or "") for r in PERMANENT_FAIL_REASONS):
|
||
print(f"[FAIL] 应用永久性失败: {csv_app_id_fail} - {reason}")
|
||
stats.add_fail_record(index, app_name, app_name, csv_app_id_fail, reason)
|
||
else:
|
||
print(f"[SKIP] 应用安装失败: {csv_app_id_fail} - {reason}")
|
||
stats.add_skip_record(index, app_name, app_name, csv_app_id_fail, reason or "安装失败")
|
||
stats.save_csv()
|
||
continue
|
||
|
||
# 从 appstore_mapping.csv 读取真实应用名（模型更容易识别）
|
||
csv_file = os.path.join(ROOT, "output", "ios", "appstore_mapping.csv")
|
||
csv_app_id = app_id if not app_id.isdigit() else f"id{app_id}"
|
||
csv_info = get_app_info_from_csv(csv_app_id, csv_file)
|
||
real_app_name = csv_info.get('app_name', '') or app_name
|
||
raw_app_name = app_name # 原始 app_name
|
||
if real_app_name and real_app_name != app_name:
|
||
print(f"[INFO] 使用真实应用名: {real_app_name} (原始: {app_name or bundle_id})")
|
||
app_name = real_app_name
|
||
|
||
# 执行测试
|
||
result = test_runner.run_test(
|
||
bundle_id=bundle_id,
|
||
app_id=csv_app_id,
|
||
app_name=app_name,
|
||
raw_app_name=raw_app_name,
|
||
duration=args.duration,
|
||
throttle=args.throttle,
|
||
enable_login=args.enable_login,
|
||
check_interval=args.stuck_check_interval,
|
||
back_threshold=args.back_threshold,
|
||
agent_threshold=args.agent_threshold,
|
||
agent_timeout=args.agent_timeout,
|
||
test_mode=args.test_mode,
|
||
policy=args.policy,
|
||
event_count=args.event_count,
|
||
cv_mode=args.cv_mode,
|
||
debug_mode=args.debug_mode,
|
||
guiagent_flag=args.guiagent_flag,
|
||
random_input=args.random_input,
|
||
)
|
||
|
||
# 记录结果（手动中断时不写入 CSV，直接终止批量循环）
|
||
if result.status == "INTERRUPTED":
|
||
print(f"[WARN] 用户手动中断，跳过 CSV 写入，终止批量测试")
|
||
break
|
||
|
||
stats.add_record(index, app_name, raw_app_name, csv_app_id, bundle_id, result)
|
||
stats.save_csv()
|
||
|
||
# 测试成功后重置 WDA 恢复计数
|
||
if result.status == "SUCCESS":
|
||
wda_health_monitor.reset_recover_count()
|
||
|
||
print(f"[RESULT] {app_name}: {result.status} "
|
||
f"(耗时 {result.duration_seconds:.1f}s)")
|
||
|
||
# 测试完成后卸载应用（不论成功/失败）
|
||
try:
|
||
go_ios_bin = str(ROOT / "utils_ios" / "go_ios" / "bin" / "ios-darwin-arm64")
|
||
uninstall_cmd = [go_ios_bin, "uninstall", bundle_id, "--udid", udid]
|
||
subprocess.run(uninstall_cmd, timeout=30, capture_output=True)
|
||
print(f"[INFO] 已卸载应用: {bundle_id}")
|
||
except Exception as e:
|
||
print(f"[WARN] 卸载应用失败: {bundle_id} - {e}")
|
||
|
||
# 每6小时发送采集情况报告
|
||
if time.time() - last_report_time >= REPORT_INTERVAL:
|
||
total = len(stats.records)
|
||
success = sum(1 for r in stats.records if r["status"] == "SUCCESS")
|
||
failed = sum(1 for r in stats.records if r["status"] == "FAILED")
|
||
skipped = sum(1 for r in stats.records if r["status"] == "SKIPPED")
|
||
progress = (i + 1) / len(apps) * 100
|
||
report_msg = (
|
||
f" iOS 采集情况报告\n"
|
||
f"━━━━━━━━━━━━━━━━\n"
|
||
f" 进度: {i + 1}/{len(apps)} ({progress:.1f}%)\n"
|
||
f" 成功: {success}\n"
|
||
f" 失败: {failed}\n"
|
||
f" 跳过: {skipped}\n"
|
||
f"━━━━━━━━━━━━━━━━"
|
||
)
|
||
try:
|
||
send_weCom_alert(report_msg)
|
||
print(f"[INFO] 已发送6小时采集情况报告")
|
||
except Exception as e:
|
||
print(f"[WARN] 发送采集报告失败: {e}")
|
||
last_report_time = time.time()
|
||
|
||
# 打印摘要
|
||
stats.print_summary()
|
||
|
||
|
||
def main():
|
||
"""主入口"""
|
||
# 加载环境变量
|
||
load_env_variables()
|
||
|
||
# 解析参数
|
||
args = parse_args()
|
||
|
||
# 启动基础设施
|
||
runner, udid = setup_infrastructure(args)
|
||
|
||
if args.batch:
|
||
# 批量模式
|
||
run_batch_mode(args, runner, udid)
|
||
else:
|
||
# 单个应用模式
|
||
if not args.bundle_id:
|
||
print("[ERROR] 单个模式需要指定 -bundle_id")
|
||
sys.exit(EXIT_ERROR_USER)
|
||
|
||
# 安装应用（如果是 app_id 格式）
|
||
bundle_id = args.bundle_id
|
||
if bundle_id.isdigit() or bundle_id.startswith('id'):
|
||
from utils_ios.wda_health import WDAHealthMonitor
|
||
wda_health_monitor = WDAHealthMonitor(
|
||
wda_url=args.wda_url,
|
||
go_ios_runner=runner,
|
||
)
|
||
installed_bundle_id, reason = install_app_and_get_bundle_id(
|
||
app_id=bundle_id,
|
||
wda_url=args.wda_url,
|
||
udid=udid,
|
||
health_monitor=wda_health_monitor
|
||
)
|
||
if installed_bundle_id:
|
||
bundle_id = installed_bundle_id
|
||
else:
|
||
print(f"[ERROR] 应用安装失败: {bundle_id} - {reason}")
|
||
sys.exit(EXIT_FASTBOT_ERROR)
|
||
|
||
# 执行测试
|
||
test_runner = IOSFastbotTestRunner(
|
||
runner=runner,
|
||
wda_url=args.wda_url,
|
||
udid=udid,
|
||
output_base=args.output_dir,
|
||
)
|
||
|
||
result = test_runner.run_test(
|
||
bundle_id=bundle_id,
|
||
duration=args.duration,
|
||
throttle=args.throttle,
|
||
enable_login=args.enable_login,
|
||
check_interval=args.stuck_check_interval,
|
||
back_threshold=args.back_threshold,
|
||
agent_threshold=args.agent_threshold,
|
||
agent_timeout=args.agent_timeout,
|
||
test_mode=args.test_mode,
|
||
policy=args.policy,
|
||
event_count=args.event_count,
|
||
cv_mode=args.cv_mode,
|
||
debug_mode=args.debug_mode,
|
||
guiagent_flag=args.guiagent_flag,
|
||
random_input=args.random_input,
|
||
)
|
||
|
||
print(f"\n[FINAL] 状态: {result.status} | 退出码: {result.exit_code}")
|
||
sys.exit(result.exit_code)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|