QWQLwToo
1230 lines
48 KiB
JavaScript
1230 lines
48 KiB
JavaScript
// src/js/toolHealthChecker.js
|
||
/**
|
||
* [重构] 工具健康检查器
|
||
* 实现真实的 ping 和 API 测试，检查工具的健康状态
|
||
*/
|
||
import configManager from './configManager.js';
|
||
import { toolRegistry } from './tool-registry.js';
|
||
import toolStatusManager from './toolStatusManager.js';
|
||
import i18n from './i18n.js';
|
||
|
||
class ToolHealthChecker {
|
||
constructor() {
|
||
this.checkResults = {};
|
||
this.isChecking = false;
|
||
this.isBackgroundChecking = false;
|
||
this.checkProgress = {
|
||
total: 0,
|
||
checked: 0,
|
||
success: 0,
|
||
failed: 0
|
||
};
|
||
this.currentCheckTool = null;
|
||
this.checkStartTime = null;
|
||
this.checkPromise = null; // [修复] 添加检查 Promise 引用
|
||
|
||
// 从数据库加载上次检查日期
|
||
this.loadLastCheckDate();
|
||
this.lockedTools = new Set();
|
||
this.loadLockedTools();
|
||
|
||
// 检查进度回调
|
||
this.progressCallbacks = [];
|
||
|
||
// 初始化时加载上次检查日期
|
||
this.loadLastCheckDate().catch(error => {
|
||
console.error('[ToolHealthChecker] 初始化加载检查日期失败:', error);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 注册进度回调
|
||
* @param {Function} callback - 回调函数 (progress) => {}
|
||
*/
|
||
onProgress(callback) {
|
||
this.progressCallbacks.push(callback);
|
||
}
|
||
|
||
/**
|
||
* 移除进度回调
|
||
* @param {Function} callback - 回调函数
|
||
*/
|
||
offProgress(callback) {
|
||
const index = this.progressCallbacks.indexOf(callback);
|
||
if (index > -1) {
|
||
this.progressCallbacks.splice(index, 1);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 触发进度更新
|
||
* @param {Object} progress - 进度信息
|
||
*/
|
||
_emitProgress(progress) {
|
||
this.progressCallbacks.forEach(callback => {
|
||
try {
|
||
callback(progress);
|
||
} catch (error) {
|
||
console.error('[ToolHealthChecker] 进度回调执行失败:', error);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 从数据库加载上次检查日期
|
||
*/
|
||
async loadLastCheckDate() {
|
||
try {
|
||
// 优先从汇总表获取
|
||
if (window.electronAPI && window.electronAPI.getLastHealthCheckDate) {
|
||
const result = await window.electronAPI.getLastHealthCheckDate();
|
||
if (result && result.success && result.data) {
|
||
this.lastCheckDate = result.data;
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 兼容旧系统：从配置获取
|
||
const savedDate = configManager.config?.tool_health_last_check || null;
|
||
if (savedDate) {
|
||
this.lastCheckDate = savedDate;
|
||
}
|
||
} catch (error) {
|
||
console.error('[ToolHealthChecker] 加载上次检查日期失败:', error);
|
||
// 从配置获取
|
||
const savedDate = configManager.config?.tool_health_last_check || null;
|
||
if (savedDate) {
|
||
this.lastCheckDate = savedDate;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 从配置中加载已锁定的工具
|
||
*/
|
||
loadLockedTools() {
|
||
const locked = configManager.config?.locked_tools || [];
|
||
this.lockedTools = new Set(locked);
|
||
}
|
||
|
||
/**
|
||
* 保存已锁定的工具到配置
|
||
*/
|
||
saveLockedTools() {
|
||
try {
|
||
if (!configManager.config) {
|
||
configManager.config = {};
|
||
}
|
||
configManager.config.locked_tools = Array.from(this.lockedTools);
|
||
|
||
// 尝试保存到数据库（如果 electronAPI 可用）
|
||
if (window.electronAPI && window.electronAPI.setConfig) {
|
||
window.electronAPI.setConfig('locked_tools', Array.from(this.lockedTools));
|
||
}
|
||
} catch (error) {
|
||
console.error('[ToolHealthChecker] 保存锁定工具失败:', error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 判断工具是否需要网络检查
|
||
*/
|
||
isNetworkTool(toolId) {
|
||
// 定义需要网络检查的工具列表
|
||
const networkTools = [
|
||
'earthquake-info',
|
||
'car-info',
|
||
'cctv-news',
|
||
'oil-price',
|
||
'history-today',
|
||
'domain-price',
|
||
'tech-news',
|
||
'gold-price',
|
||
'zhihu-hot',
|
||
'movie-box-office',
|
||
'football-news',
|
||
'train-query',
|
||
'baidu-hot',
|
||
'bili-hot-ranking',
|
||
'ip-query',
|
||
'ip-info',
|
||
'dns-query',
|
||
'wx-domain-check',
|
||
'smart-search',
|
||
'hotboard',
|
||
'ai-translation',
|
||
'weather-details'
|
||
];
|
||
return networkTools.includes(toolId);
|
||
}
|
||
|
||
/**
|
||
* 获取工具的 API URL 和测试参数
|
||
* @param {string} toolId - 工具ID
|
||
* @returns {Object} { url, method, testParams, expectedStatus }
|
||
*/
|
||
getToolApiConfig(toolId) {
|
||
const apiConfigs = {
|
||
// 地震信息
|
||
'earthquake-info': {
|
||
url: 'https://www.cunyuapi.top/earthquake',
|
||
method: 'GET',
|
||
testParams: null,
|
||
expectedStatus: [200, 201, 400, 401, 403, 404, 500, 502, 503] // 任何响应都表示API可用
|
||
},
|
||
// 车辆信息
|
||
'car-info': {
|
||
url: 'https://api.jkyai.top/API/clxxcx.php',
|
||
method: 'GET',
|
||
testParams: { car: 'test' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 央视新闻
|
||
'cctv-news': {
|
||
url: 'https://api.jkyai.top/API/ysxwrd.php',
|
||
method: 'GET',
|
||
testParams: { type: 'json' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 油价查询
|
||
'oil-price': {
|
||
url: 'https://api.jkyai.top/API/yjcx.php',
|
||
method: 'GET',
|
||
testParams: { city: '北京' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 历史上的今天
|
||
'history-today': {
|
||
url: 'https://api.jkyai.top/API/lssdjt.php',
|
||
method: 'GET',
|
||
testParams: { type: 'json' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 域名价格
|
||
'domain-price': {
|
||
url: 'https://api.jkyai.top/API/ymbjcx.php',
|
||
method: 'GET',
|
||
testParams: { domain: 'example.com' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 科技资讯
|
||
'tech-news': {
|
||
url: 'https://api.jkyai.top/API/kjzx.php',
|
||
method: 'GET',
|
||
testParams: { type: 'json' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 金价查询
|
||
'gold-price': {
|
||
url: 'https://api.pearktrue.cn/api/goldprice/',
|
||
method: 'GET',
|
||
testParams: null,
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 知乎热榜
|
||
'zhihu-hot': {
|
||
url: 'http://shanhe.kim/api/za/zhihu.php',
|
||
method: 'GET',
|
||
testParams: null,
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 电影票房
|
||
'movie-box-office': {
|
||
url: 'https://api.pearktrue.cn/api/maoyan/',
|
||
method: 'GET',
|
||
testParams: null,
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 足球新闻
|
||
'football-news': {
|
||
url: 'https://api.jkyai.top/API/zqssrd.php',
|
||
method: 'GET',
|
||
testParams: { type: 'json' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 火车查询
|
||
'train-query': {
|
||
url: 'https://api.jkyai.top/API/hcpccx.php',
|
||
method: 'GET',
|
||
testParams: { from: '北京', to: '上海', date: new Date().toISOString().split('T')[0] },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// 百度热榜
|
||
'baidu-hot': {
|
||
url: 'https://api.suyanw.cn/api/bdrs.php',
|
||
method: 'GET',
|
||
testParams: { msg: '百度' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// B站热榜
|
||
'bili-hot-ranking': {
|
||
url: 'https://api.suyanw.cn/api/bl.php',
|
||
method: 'GET',
|
||
testParams: { hh: '\n' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// IP查询
|
||
'ip-query': {
|
||
url: 'https://api.ipify.org',
|
||
method: 'GET',
|
||
testParams: { format: 'json' },
|
||
expectedStatus: [200, 400, 404, 500]
|
||
},
|
||
// IP/域名归属查询
|
||
'ip-info': {
|
||
url: 'https://uapis.cn/api/v1/network/ipinfo',
|
||
method: 'GET',
|
||
testParams: { ip: '8.8.8.8' },
|
||
expectedStatus: [200, 400, 401, 403, 404, 500]
|
||
},
|
||
// DNS查询
|
||
'dns-query': {
|
||
url: 'https://uapis.cn/api/v1/network/dns',
|
||
method: 'GET',
|
||
testParams: { domain: 'google.com', type: 'A' },
|
||
expectedStatus: [200, 400, 401, 403, 404, 500]
|
||
},
|
||
// 微信域名检测
|
||
'wx-domain-check': {
|
||
url: 'https://uapis.cn/api/v1/network/wxdomain',
|
||
method: 'GET',
|
||
testParams: { domain: 'qq.com' },
|
||
expectedStatus: [200, 400, 401, 403, 404, 500]
|
||
},
|
||
// 智能搜索
|
||
'smart-search': {
|
||
url: 'https://uapis.cn/api/v1/search/aggregate',
|
||
method: 'POST',
|
||
testParams: { query: 'test', timeout_ms: 5000, fetch_full: false },
|
||
expectedStatus: [200, 400, 401, 403, 404, 500]
|
||
},
|
||
// 多平台热榜
|
||
'hotboard': {
|
||
url: 'https://uapis.cn/api/v1/misc/hotboard',
|
||
method: 'GET',
|
||
testParams: { type: 'zhihu' },
|
||
expectedStatus: [200, 400, 401, 403, 404, 500]
|
||
},
|
||
// AI翻译
|
||
'ai-translation': {
|
||
url: 'https://uapis.cn/api/v1/ai/translate',
|
||
method: 'POST',
|
||
testParams: { text: 'test', from: 'zh', to: 'en' },
|
||
expectedStatus: [200, 400, 401, 403, 404, 500]
|
||
},
|
||
// 天气详情
|
||
'weather-details': {
|
||
url: 'https://uapis.cn/api/v1/misc/weather',
|
||
method: 'GET',
|
||
testParams: { city: '北京' },
|
||
expectedStatus: [200, 400, 401, 403, 404, 500]
|
||
}
|
||
};
|
||
|
||
return apiConfigs[toolId] || null;
|
||
}
|
||
|
||
/**
|
||
* [重构] 执行 ping 测试（通过 HEAD 请求）
|
||
* @param {string} url - 目标URL
|
||
* @param {number} timeout - 超时时间（毫秒）
|
||
* @returns {Promise<boolean>} ping 是否成功
|
||
*/
|
||
async pingUrl(url, timeout = 5000) {
|
||
try {
|
||
const controller = new AbortController();
|
||
const timeoutId = setTimeout(() => controller.abort(), timeout);
|
||
|
||
const response = await fetch(url, {
|
||
method: 'HEAD',
|
||
signal: controller.signal,
|
||
headers: {
|
||
'User-Agent': 'YMhut-Box/1.0'
|
||
}
|
||
});
|
||
|
||
clearTimeout(timeoutId);
|
||
|
||
// 任何响应都表示服务器可达
|
||
return response.status >= 200 && response.status < 600;
|
||
} catch (error) {
|
||
// ping 失败
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* [重构] 检查单个工具的健康状态
|
||
* 1. 先执行 ping 测试
|
||
* 2. 然后执行 API 测试请求
|
||
* 3. 如果 ping 失败或 API 无响应，则工具不健康
|
||
* @param {string} toolId - 工具ID
|
||
* @param {number} retries - 重试次数，默认2次
|
||
* @returns {Promise<Object>} 检查结果
|
||
*/
|
||
async checkToolHealth(toolId, retries = 2) {
|
||
const checkStartTime = Date.now();
|
||
|
||
try {
|
||
// 更新检查状态
|
||
toolStatusManager.updateHealthStatus(toolId, 'checking', {});
|
||
this.currentCheckTool = toolId;
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新检查状态失败 [${toolId}]:`, error);
|
||
// 继续执行检查，不因状态更新失败而中断
|
||
}
|
||
|
||
// 获取工具配置
|
||
const toolClass = toolRegistry[toolId];
|
||
let healthCheckConfig = null;
|
||
let timeout = 10000; // 默认超时时间10秒
|
||
|
||
if (toolClass && toolClass.healthCheckConfig) {
|
||
healthCheckConfig = toolClass.healthCheckConfig;
|
||
if (healthCheckConfig.retries !== undefined) {
|
||
retries = healthCheckConfig.retries;
|
||
}
|
||
if (healthCheckConfig.timeout !== undefined) {
|
||
timeout = healthCheckConfig.timeout;
|
||
}
|
||
if (healthCheckConfig.enabled === false) {
|
||
try {
|
||
toolStatusManager.updateHealthStatus(toolId, 'healthy', {
|
||
message: '健康检查已禁用',
|
||
skipCheck: true
|
||
});
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新健康状态失败 [${toolId}]:`, error);
|
||
}
|
||
return { toolId, status: 'success', reason: 'health_check_disabled' };
|
||
}
|
||
}
|
||
|
||
// 获取 API 配置
|
||
const apiConfig = this.getToolApiConfig(toolId);
|
||
if (!apiConfig) {
|
||
// 如果没有 API 配置，说明是离线工具，直接返回成功
|
||
try {
|
||
toolStatusManager.updateHealthStatus(toolId, 'healthy', {
|
||
message: '离线工具，无需健康检查',
|
||
skipCheck: true
|
||
});
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新健康状态失败 [${toolId}]:`, error);
|
||
}
|
||
return { toolId, status: 'success', reason: 'offline_tool' };
|
||
}
|
||
|
||
// 提取域名用于 ping
|
||
let domain = null;
|
||
try {
|
||
const urlObj = new URL(apiConfig.url);
|
||
domain = urlObj.hostname;
|
||
} catch (e) {
|
||
// URL 解析失败，使用完整 URL
|
||
domain = apiConfig.url;
|
||
}
|
||
|
||
// 执行健康检查
|
||
for (let attempt = 1; attempt <= retries; attempt++) {
|
||
try {
|
||
// 步骤1: Ping 测试
|
||
const pingSuccess = await this.pingUrl(apiConfig.url, 5000);
|
||
if (!pingSuccess) {
|
||
if (attempt === retries) {
|
||
// 记录到数据库
|
||
try {
|
||
await this._recordHealthCheck(toolId, 'failed', null, 'ping_failed', attempt);
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 记录健康检查结果失败 [${toolId}]:`, error);
|
||
}
|
||
try {
|
||
toolStatusManager.updateHealthStatus(toolId, 'unhealthy', {
|
||
reason: 'ping_failed',
|
||
message: '服务器无法访问（ping 失败）',
|
||
autoLock: true
|
||
});
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新健康状态失败 [${toolId}]:`, error);
|
||
}
|
||
this.lockedTools.add(toolId);
|
||
return { toolId, status: 'failed', reason: 'ping_failed', attempt };
|
||
}
|
||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||
continue;
|
||
}
|
||
|
||
// 步骤2: API 测试请求
|
||
const controller = new AbortController();
|
||
const timeoutId = setTimeout(() => controller.abort(), timeout);
|
||
|
||
let requestUrl = apiConfig.url;
|
||
let requestOptions = {
|
||
method: apiConfig.method || 'GET',
|
||
signal: controller.signal,
|
||
headers: {
|
||
'User-Agent': 'YMhut-Box/1.0',
|
||
'Accept': '*/*'
|
||
}
|
||
};
|
||
|
||
// 添加测试参数
|
||
if (apiConfig.testParams) {
|
||
if (apiConfig.method === 'POST') {
|
||
requestOptions.headers['Content-Type'] = 'application/json';
|
||
requestOptions.body = JSON.stringify(apiConfig.testParams);
|
||
} else {
|
||
const params = new URLSearchParams(apiConfig.testParams);
|
||
requestUrl = `${apiConfig.url}?${params.toString()}`;
|
||
}
|
||
}
|
||
|
||
// 如果是智能搜索，添加 API Key（如果有）
|
||
if (toolId === 'smart-search' && configManager.config?.api_keys?.uapipro) {
|
||
requestOptions.headers['Authorization'] = `Bearer ${configManager.config.api_keys.uapipro}`;
|
||
}
|
||
|
||
const response = await fetch(requestUrl, requestOptions);
|
||
clearTimeout(timeoutId);
|
||
|
||
// 检查响应状态码
|
||
// 如果状态码在预期列表中，或者有响应（即使是错误），都认为 API 可用
|
||
const hasResponse = response.status >= 200 && response.status < 600;
|
||
const isExpectedStatus = apiConfig.expectedStatus && apiConfig.expectedStatus.includes(response.status);
|
||
|
||
if (hasResponse && (isExpectedStatus || response.status < 500)) {
|
||
// API 可用，返回成功
|
||
const responseTime = Date.now() - checkStartTime;
|
||
try {
|
||
await this._recordHealthCheck(toolId, 'success', responseTime, null, attempt, response.status);
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 记录健康检查结果失败 [${toolId}]:`, error);
|
||
}
|
||
|
||
try {
|
||
toolStatusManager.updateHealthStatus(toolId, 'healthy', {
|
||
httpStatus: response.status,
|
||
attempt,
|
||
responseTime
|
||
});
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新健康状态失败 [${toolId}]:`, error);
|
||
}
|
||
this.lockedTools.delete(toolId);
|
||
return { toolId, status: 'success', httpStatus: response.status, attempt };
|
||
}
|
||
|
||
// 5xx 错误表示服务器问题
|
||
if (response.status >= 500) {
|
||
if (attempt === retries) {
|
||
try {
|
||
await this._recordHealthCheck(toolId, 'failed', null, 'server_error', attempt, response.status);
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 记录健康检查结果失败 [${toolId}]:`, error);
|
||
}
|
||
try {
|
||
toolStatusManager.updateHealthStatus(toolId, 'unhealthy', {
|
||
reason: 'server_error',
|
||
httpStatus: response.status,
|
||
message: `服务器错误 (HTTP ${response.status})`,
|
||
autoLock: true
|
||
});
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新健康状态失败 [${toolId}]:`, error);
|
||
}
|
||
this.lockedTools.add(toolId);
|
||
return { toolId, status: 'failed', httpStatus: response.status, reason: 'server_error', attempt };
|
||
}
|
||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||
continue;
|
||
}
|
||
|
||
// 其他状态码（如 4xx）也认为 API 可用（至少 API 是响应的）
|
||
const responseTime = Date.now() - checkStartTime;
|
||
try {
|
||
await this._recordHealthCheck(toolId, 'success', responseTime, null, attempt, response.status);
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 记录健康检查结果失败 [${toolId}]:`, error);
|
||
}
|
||
try {
|
||
toolStatusManager.updateHealthStatus(toolId, 'healthy', {
|
||
httpStatus: response.status,
|
||
attempt,
|
||
responseTime,
|
||
message: 'API 可用（返回了响应）'
|
||
});
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新健康状态失败 [${toolId}]:`, error);
|
||
}
|
||
this.lockedTools.delete(toolId);
|
||
return { toolId, status: 'success', httpStatus: response.status, reason: 'api_available', attempt };
|
||
|
||
} catch (error) {
|
||
// 处理各种错误类型
|
||
const errorMessage = error.message || String(error);
|
||
const isNetworkError = errorMessage.includes('network') ||
|
||
errorMessage.includes('fetch') ||
|
||
errorMessage.includes('Failed to fetch') ||
|
||
errorMessage.includes('NetworkError') ||
|
||
errorMessage.includes('ERR_INTERNET_DISCONNECTED') ||
|
||
errorMessage.includes('ERR_NETWORK_CHANGED');
|
||
|
||
const isTimeoutError = errorMessage.includes('timeout') ||
|
||
errorMessage.includes('aborted') ||
|
||
error.name === 'AbortError';
|
||
|
||
if (attempt === retries) {
|
||
let reason = 'network_error';
|
||
if (isTimeoutError) reason = 'timeout';
|
||
else if (isNetworkError) reason = 'network_error';
|
||
|
||
try {
|
||
await this._recordHealthCheck(toolId, 'failed', null, reason, attempt);
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 记录健康检查结果失败 [${toolId}]:`, error);
|
||
}
|
||
try {
|
||
toolStatusManager.updateHealthStatus(toolId, 'unhealthy', {
|
||
reason: reason,
|
||
error: errorMessage,
|
||
message: this.getHealthCheckErrorMessage(reason),
|
||
autoLock: true
|
||
});
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新健康状态失败 [${toolId}]:`, error);
|
||
}
|
||
this.lockedTools.add(toolId);
|
||
return {
|
||
toolId,
|
||
status: 'failed',
|
||
error: errorMessage,
|
||
reason: reason,
|
||
attempt
|
||
};
|
||
}
|
||
|
||
// 等待后重试
|
||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||
}
|
||
}
|
||
|
||
// 所有重试都失败
|
||
try {
|
||
await this._recordHealthCheck(toolId, 'failed', null, 'max_retries', retries);
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 记录健康检查结果失败 [${toolId}]:`, error);
|
||
}
|
||
try {
|
||
toolStatusManager.updateHealthStatus(toolId, 'unhealthy', {
|
||
reason: 'max_retries',
|
||
message: '重试次数超限',
|
||
autoLock: true
|
||
});
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新健康状态失败 [${toolId}]:`, error);
|
||
}
|
||
this.lockedTools.add(toolId);
|
||
return { toolId, status: 'failed', reason: 'max_retries' };
|
||
}
|
||
|
||
/**
|
||
* 记录健康检查结果到数据库
|
||
* @param {string} toolId - 工具ID
|
||
* @param {string} status - 状态 ('success' | 'failed')
|
||
* @param {number} responseTime - 响应时间（毫秒）
|
||
* @param {string} errorMessage - 错误消息
|
||
* @param {number} attempt - 尝试次数
|
||
* @param {number} httpStatus - HTTP 状态码
|
||
*/
|
||
async _recordHealthCheck(toolId, status, responseTime, errorMessage, attempt, httpStatus) {
|
||
try {
|
||
const checkDate = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
|
||
|
||
// [日志] 记录单个工具检查结果
|
||
if (configManager && configManager.logAction) {
|
||
// 获取工具名称（从 toolRegistry 或使用 toolId）
|
||
let toolName = toolId;
|
||
try {
|
||
const ToolClass = toolRegistry[toolId];
|
||
if (ToolClass && ToolClass.name) {
|
||
toolName = ToolClass.name;
|
||
}
|
||
} catch (e) {
|
||
// 忽略错误，使用 toolId
|
||
}
|
||
|
||
if (status === 'success') {
|
||
configManager.logAction(
|
||
`工具健康检查: ${toolName} 正常 (响应时间: ${responseTime || 'N/A'}ms)`,
|
||
'tool_health_check'
|
||
);
|
||
} else {
|
||
configManager.logAction(
|
||
`工具健康检查: ${toolName} 异常 (${errorMessage || '未知错误'})`,
|
||
'tool_health_check'
|
||
);
|
||
}
|
||
}
|
||
|
||
// 记录到工具健康检查结果表
|
||
if (window.electronAPI && window.electronAPI.recordToolHealthCheckResult) {
|
||
await window.electronAPI.recordToolHealthCheckResult({
|
||
toolId: toolId,
|
||
checkDate: checkDate,
|
||
status: status,
|
||
responseTime: responseTime || null,
|
||
errorMessage: errorMessage || null,
|
||
httpStatus: httpStatus || null,
|
||
attempt: attempt || 1,
|
||
reason: errorMessage || null
|
||
});
|
||
}
|
||
|
||
// 同时记录到接口健康度表（兼容旧系统）
|
||
if (window.electronAPI && window.electronAPI.recordApiHealth) {
|
||
await window.electronAPI.recordApiHealth({
|
||
apiId: `tool-${toolId}`,
|
||
status: status === 'success' ? 'healthy' : 'unhealthy',
|
||
responseTime: responseTime || null,
|
||
errorMessage: errorMessage || null
|
||
});
|
||
}
|
||
|
||
// 同时记录接口调用
|
||
if (window.electronAPI && window.electronAPI.recordApiCall) {
|
||
await window.electronAPI.recordApiCall({
|
||
apiId: `tool-${toolId}`,
|
||
method: 'GET',
|
||
url: this.getToolApiConfig(toolId)?.url || '',
|
||
statusCode: httpStatus || null,
|
||
responseTime: responseTime || null,
|
||
success: status === 'success',
|
||
errorMessage: errorMessage || null
|
||
});
|
||
}
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 记录健康检查结果失败 [${toolId}]:`, error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检查距离上次检查是否超过5天
|
||
* @returns {boolean} true 表示需要强制检查
|
||
*/
|
||
shouldForceCheck() {
|
||
if (!this.lastCheckDate) {
|
||
return true; // 从未检查过，需要检查
|
||
}
|
||
|
||
const lastCheck = new Date(this.lastCheckDate);
|
||
const now = new Date();
|
||
const daysDiff = Math.floor((now - lastCheck) / (1000 * 60 * 60 * 24));
|
||
|
||
return daysDiff >= 5; // 超过5天需要强制检查
|
||
}
|
||
|
||
/**
|
||
* 检查今天是否已经检查过（不修改日期，只检查）
|
||
* @param {boolean} updateDate - 是否更新检查日期，默认false
|
||
* @returns {boolean} true表示今天已经检查过，false表示未检查
|
||
*/
|
||
hasCheckedToday(updateDate = false) {
|
||
const today = new Date().toDateString();
|
||
const savedDate = this.lastCheckDate || configManager.config?.tool_health_last_check || null;
|
||
|
||
if (savedDate === today) {
|
||
if (updateDate) {
|
||
this.lastCheckDate = today;
|
||
}
|
||
return true; // 今天已经检查过
|
||
}
|
||
|
||
if (updateDate) {
|
||
this.lastCheckDate = today;
|
||
try {
|
||
if (!configManager.config) {
|
||
configManager.config = {};
|
||
}
|
||
configManager.config.tool_health_last_check = today;
|
||
|
||
// 尝试保存到数据库（如果 electronAPI 可用）
|
||
if (window.electronAPI && window.electronAPI.setConfig) {
|
||
window.electronAPI.setConfig('tool_health_last_check', today);
|
||
}
|
||
} catch (error) {
|
||
console.error('[ToolHealthChecker] 保存检查日期失败:', error);
|
||
}
|
||
}
|
||
return false; // 今天未检查
|
||
}
|
||
|
||
/**
|
||
* 检查今天是否应该检查（用于shouldCheckToday的兼容性）
|
||
* @returns {boolean} true表示应该检查，false表示今天已经检查过
|
||
*/
|
||
shouldCheckToday() {
|
||
return !this.hasCheckedToday(false);
|
||
}
|
||
|
||
/**
|
||
* 获取上次检查日期
|
||
*/
|
||
getLastCheckDate() {
|
||
return this.lastCheckDate || configManager.config?.tool_health_last_check || null;
|
||
}
|
||
|
||
/**
|
||
* 执行所有网络工具的健康检查
|
||
* @param {boolean} force - 是否强制检查（忽略每日限制）
|
||
* @param {boolean} background - 是否在后台运行
|
||
* @returns {Promise<Array>} 检查结果列表
|
||
*/
|
||
async checkAllTools(force = false, background = false) {
|
||
// [日志] 记录健康检查开始
|
||
if (configManager && configManager.logAction) {
|
||
configManager.logAction(
|
||
`开始工具健康检查 (强制: ${force}, 后台: ${background})`,
|
||
'tool_health_check'
|
||
);
|
||
}
|
||
|
||
// [修复] 如果正在检查且不是后台模式，直接返回当前检查的 Promise
|
||
if (this.isChecking && this.checkPromise) {
|
||
if (!background) {
|
||
// 如果已经有检查在进行，返回当前检查的 Promise
|
||
console.log('[ToolHealthChecker] 检查已在进行中，返回现有 Promise');
|
||
if (configManager && configManager.logAction) {
|
||
configManager.logAction('工具健康检查已在进行中，跳过重复检查', 'tool_health_check');
|
||
}
|
||
return this.checkPromise;
|
||
}
|
||
// 后台模式允许继续（但通常不应该发生）
|
||
}
|
||
|
||
// [修复] 如果不是强制检查，检查今天是否已经检查过
|
||
if (!force) {
|
||
const hasCheckedToday = this.hasCheckedToday(false);
|
||
const shouldForce = this.shouldForceCheck();
|
||
|
||
// 如果今天已经检查过且不需要强制检查，直接返回已有结果
|
||
if (hasCheckedToday && !shouldForce) {
|
||
// 返回已有的检查结果
|
||
if (this.checkResults && Object.keys(this.checkResults).length > 0) {
|
||
return Object.values(this.checkResults);
|
||
}
|
||
// 如果没有结果，说明检查已完成但结果已清空，不需要重新检查
|
||
return [];
|
||
}
|
||
}
|
||
|
||
this.isChecking = true;
|
||
this.isBackgroundChecking = background;
|
||
|
||
// [修复] 如果已有检查结果，保留它们（用于恢复显示）
|
||
if (!this.checkResults || Object.keys(this.checkResults).length === 0) {
|
||
this.checkResults = {};
|
||
}
|
||
this.checkStartTime = Date.now();
|
||
|
||
const allTools = Object.keys(toolRegistry);
|
||
const networkTools = allTools.filter(toolId => this.isNetworkTool(toolId));
|
||
|
||
// [修复] 重置进度（每次检查都重新开始，避免重复检查）
|
||
this.checkProgress = {
|
||
total: networkTools.length,
|
||
checked: 0,
|
||
success: 0,
|
||
failed: 0
|
||
};
|
||
|
||
// [修复] 如果已有检查结果，先统计已有的结果
|
||
if (this.checkResults && Object.keys(this.checkResults).length > 0) {
|
||
// 如果所有工具都已检查过，直接返回结果
|
||
const checkedTools = Object.keys(this.checkResults);
|
||
if (checkedTools.length === networkTools.length) {
|
||
console.log('[ToolHealthChecker] 所有工具已检查过，返回已有结果');
|
||
// 恢复进度统计
|
||
Object.values(this.checkResults).forEach(result => {
|
||
if (result.status === 'success') {
|
||
this.checkProgress.success++;
|
||
} else {
|
||
this.checkProgress.failed++;
|
||
}
|
||
});
|
||
this.checkProgress.checked = networkTools.length;
|
||
this.isChecking = false;
|
||
return Object.values(this.checkResults);
|
||
}
|
||
}
|
||
|
||
// [修复] 创建检查 Promise
|
||
const checkPromise = this._performCheck(networkTools);
|
||
this.checkPromise = checkPromise;
|
||
|
||
return checkPromise;
|
||
}
|
||
|
||
/**
|
||
* [新增] 执行实际的检查逻辑
|
||
* @private
|
||
*/
|
||
async _performCheck(networkTools) {
|
||
const results = [];
|
||
|
||
// 逐个检查工具
|
||
for (let i = 0; i < networkTools.length; i++) {
|
||
const toolId = networkTools[i];
|
||
|
||
// [修复] 如果这个工具已经检查过，跳过（避免重复检查）
|
||
if (this.checkResults[toolId]) {
|
||
console.log(`[ToolHealthChecker] 工具 ${toolId} 已检查过，跳过`);
|
||
const existingResult = this.checkResults[toolId];
|
||
results.push(existingResult);
|
||
|
||
// 更新统计
|
||
if (existingResult.status === 'success') {
|
||
this.checkProgress.success++;
|
||
} else {
|
||
this.checkProgress.failed++;
|
||
}
|
||
|
||
// [优化] 更新进度（确保进度只增不减）
|
||
const existingChecked = Math.max(this.checkProgress.checked, i + 1);
|
||
this.checkProgress.checked = existingChecked;
|
||
this._emitProgress({
|
||
...this.checkProgress,
|
||
currentTool: toolId,
|
||
currentToolIndex: i + 1,
|
||
lastResult: existingResult
|
||
});
|
||
continue;
|
||
}
|
||
|
||
try {
|
||
// [优化] 更新进度（确保进度只增不减）
|
||
let newChecked = Math.max(this.checkProgress.checked, i);
|
||
this.checkProgress.checked = newChecked;
|
||
this._emitProgress({
|
||
...this.checkProgress,
|
||
currentTool: toolId,
|
||
currentToolIndex: i + 1
|
||
});
|
||
|
||
// 执行健康检查，添加错误处理防止卡住
|
||
let result;
|
||
try {
|
||
result = await Promise.race([
|
||
this.checkToolHealth(toolId),
|
||
new Promise((_, reject) =>
|
||
setTimeout(() => reject(new Error('健康检查超时')), 30000)
|
||
)
|
||
]);
|
||
} catch (checkError) {
|
||
console.error(`[ToolHealthChecker] 检查工具 ${toolId} 失败:`, checkError);
|
||
// 检查失败，记录为失败状态
|
||
result = {
|
||
toolId,
|
||
status: 'failed',
|
||
reason: checkError.message || '检查异常',
|
||
error: checkError.message
|
||
};
|
||
// 更新状态管理器
|
||
try {
|
||
toolStatusManager.updateHealthStatus(toolId, 'unhealthy', {
|
||
reason: 'check_error',
|
||
error: checkError.message,
|
||
message: '健康检查异常',
|
||
autoLock: true
|
||
});
|
||
} catch (error) {
|
||
console.error(`[ToolHealthChecker] 更新健康状态失败 [${toolId}]:`, error);
|
||
}
|
||
this.lockedTools.add(toolId);
|
||
}
|
||
|
||
results.push(result);
|
||
this.checkResults[toolId] = result;
|
||
|
||
// 更新统计
|
||
if (result.status === 'success') {
|
||
this.checkProgress.success++;
|
||
} else {
|
||
this.checkProgress.failed++;
|
||
}
|
||
|
||
// [优化] 更新进度（确保进度只增不减）
|
||
newChecked = Math.max(this.checkProgress.checked, i + 1);
|
||
this.checkProgress.checked = newChecked;
|
||
this._emitProgress({
|
||
...this.checkProgress,
|
||
currentTool: toolId,
|
||
currentToolIndex: i + 1,
|
||
lastResult: result
|
||
});
|
||
|
||
// [重构] 如果是在后台运行，可以稍微延迟，避免阻塞UI
|
||
if (this.isBackgroundChecking && i < networkTools.length - 1) {
|
||
await new Promise(resolve => setTimeout(resolve, 100));
|
||
}
|
||
} catch (error) {
|
||
// 捕获循环中的任何错误，防止整个检查流程卡住
|
||
console.error(`[ToolHealthChecker] 处理工具 ${toolId} 时发生错误:`, error);
|
||
const errorResult = {
|
||
toolId,
|
||
status: 'failed',
|
||
reason: 'processing_error',
|
||
error: error.message
|
||
};
|
||
results.push(errorResult);
|
||
this.checkResults[toolId] = errorResult;
|
||
this.checkProgress.failed++;
|
||
// [优化] 更新进度（确保进度只增不减）
|
||
const errorChecked = Math.max(this.checkProgress.checked, i + 1);
|
||
this.checkProgress.checked = errorChecked;
|
||
|
||
// 继续检查下一个工具
|
||
this._emitProgress({
|
||
...this.checkProgress,
|
||
currentTool: toolId,
|
||
currentToolIndex: i + 1,
|
||
lastResult: errorResult
|
||
});
|
||
}
|
||
}
|
||
|
||
// 保存锁定工具（添加错误处理）
|
||
try {
|
||
this.saveLockedTools();
|
||
} catch (error) {
|
||
console.error('[ToolHealthChecker] 保存锁定工具失败:', error);
|
||
}
|
||
|
||
// 更新检查日期（添加错误处理）
|
||
try {
|
||
this.hasCheckedToday(true);
|
||
} catch (error) {
|
||
console.error('[ToolHealthChecker] 更新检查日期失败:', error);
|
||
}
|
||
|
||
// 保存检查结果到数据库（添加错误处理）
|
||
try {
|
||
await this._saveCheckResults(results);
|
||
} catch (error) {
|
||
console.error('[ToolHealthChecker] 保存检查结果失败:', error);
|
||
// [日志] 记录保存失败
|
||
if (configManager && configManager.logAction) {
|
||
configManager.logAction(`保存工具健康检查结果失败: ${error.message}`, 'error');
|
||
}
|
||
}
|
||
|
||
// [日志] 记录健康检查完成
|
||
if (configManager && configManager.logAction) {
|
||
const successCount = this.checkProgress.success || 0;
|
||
const failedCount = this.checkProgress.failed || 0;
|
||
const totalCount = this.checkProgress.total || 0;
|
||
configManager.logAction(
|
||
`工具健康检查完成: 总计 ${totalCount}，正常 ${successCount}，异常 ${failedCount}`,
|
||
'tool_health_check'
|
||
);
|
||
}
|
||
|
||
// [修复] 确保状态正确重置
|
||
this.isChecking = false;
|
||
this.isBackgroundChecking = false;
|
||
this.currentCheckTool = null;
|
||
|
||
// 触发完成事件
|
||
this._emitProgress({
|
||
...this.checkProgress,
|
||
completed: true
|
||
});
|
||
|
||
// [修复] 延迟清除检查 Promise，确保所有等待的 Promise 都能获取结果
|
||
setTimeout(() => {
|
||
this.checkPromise = null;
|
||
}, 1000);
|
||
|
||
return results;
|
||
}
|
||
|
||
/**
|
||
* 保存检查结果到数据库
|
||
* @param {Array} results - 检查结果列表
|
||
*/
|
||
async _saveCheckResults(results) {
|
||
try {
|
||
const checkDate = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
|
||
const checkDateTime = new Date().toISOString(); // 完整的日期时间（用于显示）
|
||
const checkDuration = this.checkStartTime ? Date.now() - this.checkStartTime : null;
|
||
const summary = {
|
||
total: results.length,
|
||
success: results.filter(r => r.status === 'success').length,
|
||
failed: results.filter(r => r.status === 'failed').length,
|
||
checkDate: checkDate
|
||
};
|
||
|
||
// [日志] 记录检查汇总信息
|
||
if (configManager && configManager.logAction) {
|
||
const durationText = checkDuration ? `${Math.round(checkDuration / 1000)}秒` : '未知';
|
||
configManager.logAction(
|
||
`工具健康检查汇总: 总计 ${summary.total}，正常 ${summary.success}，异常 ${summary.failed}，耗时 ${durationText}`,
|
||
'tool_health_check'
|
||
);
|
||
}
|
||
|
||
// [修复] 更新上次检查日期（使用完整的日期时间字符串）
|
||
this.lastCheckDate = checkDateTime;
|
||
|
||
// 保存汇总到数据库
|
||
if (window.electronAPI && window.electronAPI.saveToolHealthCheckSummary) {
|
||
await window.electronAPI.saveToolHealthCheckSummary({
|
||
checkDate: checkDate,
|
||
totalTools: summary.total,
|
||
successCount: summary.success,
|
||
failedCount: summary.failed,
|
||
checkDuration: checkDuration
|
||
});
|
||
}
|
||
|
||
// [修复] 保存检查日期到配置（兼容旧系统）
|
||
try {
|
||
if (!configManager.config) {
|
||
configManager.config = {};
|
||
}
|
||
// 保存检查日期（用于兼容旧系统）
|
||
configManager.config.tool_health_last_check = checkDate;
|
||
|
||
configManager.config.tool_health_check_results = {
|
||
...summary,
|
||
results: results.map(r => ({
|
||
toolId: r.toolId,
|
||
status: r.status,
|
||
reason: r.reason,
|
||
httpStatus: r.httpStatus
|
||
}))
|
||
};
|
||
|
||
// 尝试保存到数据库（如果 electronAPI 可用）
|
||
if (window.electronAPI && window.electronAPI.setConfig) {
|
||
window.electronAPI.setConfig('tool_health_check_results', configManager.config.tool_health_check_results);
|
||
window.electronAPI.setConfig('tool_health_last_check', checkDate);
|
||
}
|
||
|
||
// 保存配置
|
||
configManager.saveConfig();
|
||
} catch (error) {
|
||
console.error('[ToolHealthChecker] 保存检查结果到配置失败:', error);
|
||
}
|
||
|
||
// [修复] 通知主页面更新统计信息
|
||
if (window.mainPage && typeof window.mainPage.updateToolHealthStats === 'function') {
|
||
// 延迟更新，确保数据库操作完成
|
||
setTimeout(() => {
|
||
window.mainPage.updateToolHealthStats();
|
||
}, 500);
|
||
}
|
||
} catch (error) {
|
||
console.error('[ToolHealthChecker] 保存检查结果失败:', error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检查工具是否被锁定
|
||
* @param {string} toolId - 工具ID
|
||
* @returns {boolean} 工具是否被锁定
|
||
*/
|
||
isToolLocked(toolId) {
|
||
const toolStatus = toolStatusManager.getToolStatus(toolId);
|
||
if (toolStatus.healthStatus === 'unhealthy' || toolStatus.lockReason) {
|
||
return true;
|
||
}
|
||
return this.lockedTools.has(toolId);
|
||
}
|
||
|
||
/**
|
||
* 获取健康检查错误消息
|
||
* @param {string} reason - 错误原因
|
||
* @returns {string} 错误消息
|
||
*/
|
||
getHealthCheckErrorMessage(reason) {
|
||
const errorMessages = {
|
||
'ping_failed': '服务器无法访问（ping 失败）',
|
||
'ssl_error': 'SSL证书验证失败',
|
||
'timeout': '请求超时',
|
||
'network_error': '网络连接失败',
|
||
'server_error': '服务器错误',
|
||
'http_error': 'HTTP请求失败',
|
||
'max_retries': '重试次数超限',
|
||
'health_check_failed': '工具健康检查失败'
|
||
};
|
||
return errorMessages[reason] || '工具健康检查失败';
|
||
}
|
||
|
||
/**
|
||
* 解锁工具
|
||
* @param {string} toolId - 工具ID
|
||
*/
|
||
unlockTool(toolId) {
|
||
toolStatusManager.updateHealthStatus(toolId, 'healthy', {
|
||
message: '工具已解锁',
|
||
autoUnlock: true
|
||
});
|
||
this.lockedTools.delete(toolId);
|
||
this.saveLockedTools();
|
||
}
|
||
|
||
/**
|
||
* 锁定工具
|
||
* @param {string} toolId - 工具ID
|
||
* @param {string} reason - 锁定原因（可选）
|
||
*/
|
||
lockTool(toolId, reason = 'health_check_failed') {
|
||
toolStatusManager.updateHealthStatus(toolId, 'unhealthy', {
|
||
reason: reason,
|
||
message: '工具已锁定',
|
||
autoLock: true
|
||
});
|
||
this.lockedTools.add(toolId);
|
||
this.saveLockedTools();
|
||
}
|
||
|
||
/**
|
||
* 获取检查进度
|
||
* @returns {Object} 检查进度
|
||
*/
|
||
getProgress() {
|
||
return { ...this.checkProgress };
|
||
}
|
||
|
||
/**
|
||
* 获取当前检查的工具
|
||
* @returns {string|null} 当前检查的工具ID
|
||
*/
|
||
getCurrentCheckTool() {
|
||
return this.currentCheckTool;
|
||
}
|
||
|
||
/**
|
||
* [新增] 获取检查结果
|
||
* @returns {Object} 检查结果映射
|
||
*/
|
||
getCheckResults() {
|
||
return this.checkResults ? { ...this.checkResults } : {};
|
||
}
|
||
|
||
/**
|
||
* [新增] 清除检查结果（用于重新开始检查）
|
||
*/
|
||
clearCheckResults() {
|
||
this.checkResults = {};
|
||
this.checkProgress = {
|
||
total: 0,
|
||
checked: 0,
|
||
success: 0,
|
||
failed: 0
|
||
};
|
||
}
|
||
}
|
||
|
||
export default new ToolHealthChecker();
|