Baobhan Sith
337 lines
16 KiB
TypeScript
337 lines
16 KiB
TypeScript
import { Client } from 'ssh2';
|
|
import { WebSocket } from 'ws';
|
|
import { ClientState } from '../websocket'; // 导入统一的 ClientState
|
|
|
|
// 定义服务器状态的数据结构 (与前端 StatusMonitor.vue 匹配)
|
|
interface ServerStatus {
|
|
cpuPercent?: number;
|
|
memPercent?: number;
|
|
memUsed?: number; // MB
|
|
memTotal?: number; // MB
|
|
swapPercent?: number;
|
|
swapUsed?: number; // MB
|
|
swapTotal?: number; // MB
|
|
diskPercent?: number;
|
|
diskUsed?: number; // KB
|
|
diskTotal?: number; // KB
|
|
cpuModel?: string;
|
|
netRxRate?: number; // Bytes per second
|
|
netTxRate?: number; // Bytes per second
|
|
netInterface?: string;
|
|
osName?: string;
|
|
loadAvg?: number[]; // 系统平均负载 [1min, 5min, 15min]
|
|
timestamp: number; // 状态获取时间戳
|
|
}
|
|
|
|
// Interface for parsed network stats
|
|
interface NetworkStats {
|
|
[interfaceName: string]: {
|
|
rx_bytes: number;
|
|
tx_bytes: number;
|
|
}
|
|
}
|
|
|
|
const DEFAULT_POLLING_INTERVAL = 1000; // 修改为 1 秒轮询间隔 (毫秒)
|
|
// 用于存储上一次的网络统计信息以计算速率
|
|
const previousNetStats = new Map<string, { rx: number, tx: number, timestamp: number }>();
|
|
|
|
export class StatusMonitorService {
|
|
private clientStates: Map<string, ClientState>; // 使用导入的 ClientState
|
|
|
|
constructor(clientStates: Map<string, ClientState>) {
|
|
this.clientStates = clientStates;
|
|
}
|
|
|
|
/**
|
|
* 启动指定会话的状态轮询
|
|
* @param sessionId 会话 ID
|
|
* @param interval 轮询间隔 (毫秒)，可选，默认为 DEFAULT_POLLING_INTERVAL
|
|
*/
|
|
startStatusPolling(sessionId: string, interval: number = DEFAULT_POLLING_INTERVAL): void {
|
|
const state = this.clientStates.get(sessionId);
|
|
if (!state || !state.sshClient) {
|
|
console.warn(`[StatusMonitor] 无法为会话 ${sessionId} 启动状态轮询：状态无效或 SSH 客户端不存在。`);
|
|
return;
|
|
}
|
|
if (state.statusIntervalId) {
|
|
console.warn(`[StatusMonitor] 会话 ${sessionId} 的状态轮询已在运行中。`);
|
|
return;
|
|
}
|
|
console.log(`[StatusMonitor] 为会话 ${sessionId} 启动状态轮询，间隔 ${interval}ms`);
|
|
this.fetchAndSendServerStatus(sessionId); // 立即执行一次
|
|
state.statusIntervalId = setInterval(() => {
|
|
this.fetchAndSendServerStatus(sessionId);
|
|
}, interval);
|
|
}
|
|
|
|
/**
|
|
* 停止指定会话的状态轮询
|
|
* @param sessionId 会话 ID
|
|
*/
|
|
stopStatusPolling(sessionId: string): void {
|
|
const state = this.clientStates.get(sessionId);
|
|
if (state?.statusIntervalId) {
|
|
console.log(`[StatusMonitor] 停止会话 ${sessionId} 的状态轮询。`);
|
|
clearInterval(state.statusIntervalId);
|
|
state.statusIntervalId = undefined;
|
|
previousNetStats.delete(sessionId); // 清理网络统计缓存
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取并发送服务器状态给客户端
|
|
* @param sessionId 会话 ID
|
|
*/
|
|
private async fetchAndSendServerStatus(sessionId: string): Promise<void> {
|
|
const state = this.clientStates.get(sessionId);
|
|
if (!state || !state.sshClient || state.ws.readyState !== WebSocket.OPEN) {
|
|
console.warn(`[StatusMonitor] 无法获取会话 ${sessionId} 的状态，停止轮询。原因：状态无效、SSH断开或WS关闭。`);
|
|
this.stopStatusPolling(sessionId);
|
|
return;
|
|
}
|
|
try {
|
|
// 传递 sessionId 给 fetchServerStatus 以便查找 previousNetStats
|
|
const status = await this.fetchServerStatus(state.sshClient, sessionId);
|
|
state.ws.send(JSON.stringify({ type: 'status_update', payload: { connectionId: state.dbConnectionId, status } }));
|
|
} catch (error: any) {
|
|
console.error(`[StatusMonitor] 获取会话 ${sessionId} 服务器状态失败:`, error);
|
|
state.ws.send(JSON.stringify({ type: 'status_error', payload: { connectionId: state.dbConnectionId, message: `获取状态失败: ${error.message}` } }));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 通过 SSH 执行命令获取服务器状态信息
|
|
* @param sshClient SSH 客户端实例
|
|
* @param sessionId 当前会话 ID，用于网络速率计算
|
|
* @returns Promise<ServerStatus> 服务器状态信息
|
|
*/
|
|
private async fetchServerStatus(sshClient: Client, sessionId: string): Promise<ServerStatus> {
|
|
console.debug(`[StatusMonitor ${sessionId}] Fetching server status...`);
|
|
const timestamp = Date.now();
|
|
let status: Partial<ServerStatus> = { timestamp };
|
|
|
|
try {
|
|
// --- OS Name ---
|
|
try {
|
|
const osReleaseOutput = await this.executeSshCommand(sshClient, 'cat /etc/os-release');
|
|
const nameMatch = osReleaseOutput.match(/^PRETTY_NAME="?([^"]+)"?/m);
|
|
status.osName = nameMatch ? nameMatch[1] : (osReleaseOutput.match(/^NAME="?([^"]+)"?/m)?.[1] ?? 'Unknown');
|
|
} catch (err) { console.warn(`[StatusMonitor ${sessionId}] Failed to get OS name:`, err); }
|
|
|
|
// --- CPU Model ---
|
|
try {
|
|
const lscpuOutput = await this.executeSshCommand(sshClient, "lscpu | grep 'Model name:'");
|
|
status.cpuModel = lscpuOutput.match(/Model name:\s+(.*)/)?.[1].trim() ?? 'Unknown';
|
|
} catch (err) { console.warn(`[StatusMonitor ${sessionId}] Failed to get CPU model:`, err); }
|
|
|
|
// --- Memory and Swap ---
|
|
try {
|
|
const freeOutput = await this.executeSshCommand(sshClient, 'free -m');
|
|
const lines = freeOutput.split('\n');
|
|
const memLine = lines.find(line => line.startsWith('Mem:'));
|
|
const swapLine = lines.find(line => line.startsWith('Swap:'));
|
|
if (memLine) {
|
|
const parts = memLine.split(/\s+/);
|
|
if (parts.length >= 4) {
|
|
const total = parseInt(parts[1], 10);
|
|
const used = parseInt(parts[2], 10);
|
|
if (!isNaN(total) && !isNaN(used)) {
|
|
status.memTotal = total; status.memUsed = used;
|
|
status.memPercent = total > 0 ? parseFloat(((used / total) * 100).toFixed(1)) : 0;
|
|
}
|
|
}
|
|
}
|
|
if (swapLine) {
|
|
const parts = swapLine.split(/\s+/);
|
|
if (parts.length >= 4) {
|
|
const total = parseInt(parts[1], 10);
|
|
const used = parseInt(parts[2], 10);
|
|
if (!isNaN(total) && !isNaN(used)) {
|
|
status.swapTotal = total; status.swapUsed = used;
|
|
status.swapPercent = total > 0 ? parseFloat(((used / total) * 100).toFixed(1)) : 0;
|
|
}
|
|
}
|
|
} else { status.swapTotal = 0; status.swapUsed = 0; status.swapPercent = 0; }
|
|
} catch (err) { console.warn(`[StatusMonitor ${sessionId}] Failed to get memory/swap usage:`, err); }
|
|
|
|
// --- Disk Usage (Root Partition) ---
|
|
try {
|
|
const dfOutput = await this.executeSshCommand(sshClient, "df -k / | tail -n 1");
|
|
const parts = dfOutput.split(/\s+/);
|
|
if (parts.length >= 5) {
|
|
const total = parseInt(parts[1], 10); const used = parseInt(parts[2], 10);
|
|
const percentMatch = parts[4].match(/(\d+)%/);
|
|
if (!isNaN(total) && !isNaN(used) && percentMatch) {
|
|
status.diskTotal = total; status.diskUsed = used;
|
|
status.diskPercent = parseFloat(percentMatch[1]);
|
|
}
|
|
}
|
|
} catch (err) { console.warn(`[StatusMonitor ${sessionId}] Failed to get disk usage:`, err); }
|
|
|
|
// --- CPU Usage (Simplified from top) ---
|
|
try {
|
|
const topOutput = await this.executeSshCommand(sshClient, "top -bn1 | grep '%Cpu(s)' | head -n 1");
|
|
const idleMatch = topOutput.match(/(\d+\.?\d*)\s+id/); // Adjusted regex for float
|
|
if (idleMatch) {
|
|
const idlePercent = parseFloat(idleMatch[1]);
|
|
status.cpuPercent = parseFloat((100 - idlePercent).toFixed(1));
|
|
}
|
|
} catch (err) { console.warn(`[StatusMonitor ${sessionId}] Failed to get CPU usage from top:`, err); }
|
|
|
|
// --- Load Average ---
|
|
try {
|
|
const uptimeOutput = await this.executeSshCommand(sshClient, 'uptime');
|
|
const match = uptimeOutput.match(/load average(?:s)?:\s*([\d.]+)[, ]?\s*([\d.]+)[, ]?\s*([\d.]+)/);
|
|
if (match) status.loadAvg = [parseFloat(match[1]), parseFloat(match[2]), parseFloat(match[3])];
|
|
} catch (err) { console.warn(`[StatusMonitor ${sessionId}] Failed to get uptime/load average:`, err); }
|
|
|
|
// --- Network Rates ---
|
|
try {
|
|
const currentStats = await this.parseProcNetDev(sshClient);
|
|
if (currentStats) {
|
|
const defaultInterface = await this.getDefaultInterface(sshClient) || Object.keys(currentStats).find(iface => iface !== 'lo'); // Detect or fallback excluding loopback
|
|
|
|
if (defaultInterface && currentStats[defaultInterface]) {
|
|
status.netInterface = defaultInterface;
|
|
const currentRx = currentStats[defaultInterface].rx_bytes;
|
|
const currentTx = currentStats[defaultInterface].tx_bytes;
|
|
const prevStats = previousNetStats.get(sessionId);
|
|
|
|
if (prevStats && prevStats.timestamp < timestamp) { // Ensure time has passed
|
|
const timeDiffSeconds = (timestamp - prevStats.timestamp) / 1000;
|
|
if (timeDiffSeconds > 0.1) { // Avoid division by zero or tiny intervals
|
|
status.netRxRate = Math.max(0, Math.round((currentRx - prevStats.rx) / timeDiffSeconds));
|
|
status.netTxRate = Math.max(0, Math.round((currentTx - prevStats.tx) / timeDiffSeconds));
|
|
} else { status.netRxRate = 0; status.netTxRate = 0; } // Rate is 0 if interval too small
|
|
} else { status.netRxRate = 0; status.netTxRate = 0; } // First run or no time diff
|
|
|
|
previousNetStats.set(sessionId, { rx: currentRx, tx: currentTx, timestamp });
|
|
} else { console.warn(`[StatusMonitor ${sessionId}] Could not find stats for default interface ${defaultInterface}`); }
|
|
}
|
|
} catch (err) { console.warn(`[StatusMonitor ${sessionId}] Failed to get network stats:`, err); }
|
|
|
|
} catch (error) {
|
|
console.error(`[StatusMonitor ${sessionId}] General error fetching server status:`, error);
|
|
}
|
|
|
|
return status as ServerStatus;
|
|
}
|
|
|
|
/**
|
|
* 解析 /proc/net/dev 的输出
|
|
* @param sshClient SSH 客户端实例
|
|
* @returns Promise<NetworkStats | null> 解析后的网络统计信息或 null
|
|
*/
|
|
private async parseProcNetDev(sshClient: Client): Promise<NetworkStats | null> {
|
|
let output: string;
|
|
try {
|
|
// 将命令执行放入 try...catch
|
|
output = await this.executeSshCommand(sshClient, 'cat /proc/net/dev');
|
|
} catch (error) {
|
|
// 如果命令失败，记录警告并返回 null
|
|
console.warn("[StatusMonitor] Failed to execute 'cat /proc/net/dev':", error);
|
|
return null;
|
|
}
|
|
// 如果命令成功，继续解析
|
|
try {
|
|
const lines = output.split('\n').slice(2); // Skip header lines
|
|
const stats: NetworkStats = {};
|
|
for (const line of lines) {
|
|
const parts = line.trim().split(/:\s+|\s+/);
|
|
if (parts.length < 17) continue; // Need at least interface name + 16 stats
|
|
const interfaceName = parts[0];
|
|
const rx_bytes = parseInt(parts[1], 10);
|
|
const tx_bytes = parseInt(parts[9], 10); // TX bytes is the 10th field (index 9)
|
|
if (!isNaN(rx_bytes) && !isNaN(tx_bytes)) {
|
|
stats[interfaceName] = { rx_bytes, tx_bytes };
|
|
}
|
|
}
|
|
return Object.keys(stats).length > 0 ? stats : null;
|
|
} catch (parseError) {
|
|
// 如果解析失败，记录错误并返回 null
|
|
console.error("[StatusMonitor] Error parsing /proc/net/dev output:", parseError);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取默认网络接口名称 (Linux specific)
|
|
* @param sshClient SSH 客户端实例
|
|
* @returns Promise<string | null> 默认接口名称或 null
|
|
*/
|
|
private async getDefaultInterface(sshClient: Client): Promise<string | null> {
|
|
try {
|
|
// 使用 ip route 命令查找默认路由对应的接口
|
|
const output = await this.executeSshCommand(sshClient, "ip route get 1.1.1.1 | grep -oP 'dev\\s+\\K\\S+'");
|
|
const interfaceName = output.trim();
|
|
if (interfaceName) return interfaceName;
|
|
// 如果 ip route 没返回有效接口名，也尝试 fallback
|
|
console.warn("[StatusMonitor] 'ip route' did not return a valid interface name. Falling back...");
|
|
|
|
} catch (error) {
|
|
console.warn("[StatusMonitor] Failed to get default interface using 'ip route', falling back:", error);
|
|
// Fallback: 尝试查找第一个非 lo 接口
|
|
try {
|
|
const netDevOutput = await this.executeSshCommand(sshClient, 'cat /proc/net/dev');
|
|
const lines = netDevOutput.split('\n').slice(2);
|
|
for (const line of lines) {
|
|
const iface = line.trim().split(':')[0];
|
|
if (iface && iface !== 'lo') {
|
|
return iface;
|
|
}
|
|
}
|
|
} catch (fallbackError) {
|
|
console.error("[StatusMonitor] Failed to fallback to /proc/net/dev for interface:", fallbackError);
|
|
}
|
|
// Ensure null is returned if both primary and fallback fail within the outer catch
|
|
return null;
|
|
}
|
|
// This part should ideally not be reached if the first try succeeded or the catch block returned.
|
|
// Adding a final return null for safety and to satisfy TS if logic paths are complex.
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* 在 SSH 连接上执行单个命令
|
|
* @param sshClient SSH 客户端实例
|
|
* @param command 要执行的命令
|
|
* @returns Promise<string> 命令的标准输出
|
|
* @throws Error 如果命令执行失败
|
|
*/
|
|
private executeSshCommand(sshClient: Client, command: string): Promise<string> {
|
|
return new Promise((resolve, reject) => {
|
|
let output = '';
|
|
sshClient.exec(command, (err, stream) => {
|
|
if (err) {
|
|
return reject(new Error(`执行命令 '${command}' 失败: ${err.message}`));
|
|
}
|
|
stream.on('close', (code: number, signal?: string) => {
|
|
// Don't reject on non-zero exit code, as some commands might return non-zero normally
|
|
// if (code !== 0) {
|
|
// console.warn(`[StatusMonitor] Command '${command}' exited with code ${code}`);
|
|
// }
|
|
resolve(output.trim());
|
|
}).on('data', (data: Buffer) => {
|
|
output += data.toString('utf8');
|
|
}).stderr.on('data', (data: Buffer) => {
|
|
console.warn(`[StatusMonitor] Command '${command}' stderr: ${data.toString('utf8').trim()}`);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 查找与给定 SSH 客户端关联的会话 ID (辅助函数)
|
|
* @param sshClientToFind 要查找的 SSH 客户端实例
|
|
* @returns string | undefined 找到的会话 ID 或 undefined
|
|
*/
|
|
private findSessionIdForClient(sshClientToFind: Client): string | undefined {
|
|
for (const [sessionId, state] of this.clientStates.entries()) {
|
|
if (state.sshClient === sshClientToFind) {
|
|
return sessionId;
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
}
|