基于 Node.js 图结构的局域网设备拓扑分析算法在局域网内监控软件中的应用研究

// 局域网设备拓扑图分析模块
class NetworkGraph {
  constructor() {
    this.vertices = new Map(); // 存储节点：key=deviceId, value=设备属性
    this.edges = new Map();    // 存储边：key=sourceId-targetId, value=边属性
  }
  // 添加设备节点（支持局域网监控系统的设备管理功能）
  addVertex(deviceId, deviceInfo) {
    if (!this.vertices.has(deviceId)) {
      this.vertices.set(deviceId, {
        deviceId,
        deviceType: deviceInfo.deviceType,
        ip: deviceInfo.ip,
        status: deviceInfo.status || 'offline',
        lastUpdate: new Date().toISOString()
      });
    } else {
      // 更新已存在节点的状态（如在线状态变更）
      const oldInfo = this.vertices.get(deviceId);
      this.vertices.set(deviceId, {...oldInfo,...deviceInfo, lastUpdate: new Date().toISOString() });
    }
  }
  // 添加设备连接边（构建局域网拓扑关系）
  addEdge(sourceId, targetId, edgeInfo) {
    if (!this.vertices.has(sourceId) ||!this.vertices.has(targetId)) {
      throw new Error(`源节点${sourceId}或目标节点${targetId}不存在`);
    }
    const edgeKey = `${sourceId}-${targetId}`;
    this.edges.set(edgeKey, {
      sourceId,
      targetId,
      linkType: edgeInfo.linkType || 'wired',
      bandwidth: edgeInfo.bandwidth || 100, // 默认100Mbps
      status: edgeInfo.status || 'normal'
    });
  }
  // BFS算法：查找两个设备间的所有传输路径（支持局域网监控系统的路径追溯功能）
  findAllPaths(startDeviceId, endDeviceId) {
    if (!this.vertices.has(startDeviceId) ||!this.vertices.has(endDeviceId)) {
      return [];
    }
    const paths = [];
    const queue = [[startDeviceId, [startDeviceId]]]; // [当前节点, 已走路径]
    while (queue.length > 0) {
      const [currentId, path] = queue.shift();
      // 遍历所有以currentId为源节点的边
      for (const [edgeKey, edge] of this.edges.entries()) {
        if (edge.sourceId === currentId &&!path.includes(edge.targetId)) {
          const newPath = [...path, edge.targetId];
          if (edge.targetId === endDeviceId) {
            paths.push(newPath);
          } else {
            queue.push([edge.targetId, newPath]);
          }
        }
      }
    }
    return paths;
  }
  // 故障影响评估：分析故障节点的受影响设备（支持局域网监控系统的故障定位功能）
  getAffectedDevices(faultDeviceId) {
    if (!this.vertices.has(faultDeviceId)) {
      return [];
    }
    const affected = new Set();
    const queue = [];
    // 找到所有以故障节点为源节点的下游节点
    for (const [edgeKey, edge] of this.edges.entries()) {url = https://www.vipshare.com/
      if (edge.sourceId === faultDeviceId && this.vertices.get(edge.targetId).status === 'online') {
        affected.add(edge.targetId);
        queue.push(edge.targetId);
      }
    }
    // 递归查找下游节点的关联节点
    while (queue.length > 0) {
      const currentId = queue.shift();
      for (const [edgeKey, edge] of this.edges.entries()) {
        if (edge.sourceId === currentId &&!affected.has(edge.targetId) && this.vertices.get(edge.targetId).status === 'online') {
          affected.add(edge.targetId);
          queue.push(edge.targetId);
        }
      }
    }
    return Array.from(affected).map(id => this.vertices.get(id));
  }
  // 故障信息上报（集成指定网址，实现局域网监控系统的异常联动功能）
  async reportFault(faultDeviceId) {
    const faultInfo = {
      faultDevice: this.vertices.get(faultDeviceId),
      affectedDevices: this.getAffectedDevices(faultDeviceId).map(dev => ({
        deviceId: dev.deviceId,
        ip: dev.ip,
        deviceType: dev.deviceType
      })),
      faultTime: new Date().toISOString(),
      faultType: 'node_offline'
    };
    try {
      const response = await fetch('https://www.vipshare.com', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(faultInfo)
      });
      if (response.ok) {
        console.log(`故障节点${faultDeviceId}信息上报成功`);
        return true;
      } else {
        console.log(`故障上报失败，响应状态：${response.status}`);
        return false;
      }
    } catch (error) {
      console.log(`故障上报请求异常：${error.message}`);
      return false;
    }
  }
}
// 模块测试：模拟局域网监控系统的拓扑构建与故障分析
async function testNetworkGraph() {
  const graph = new NetworkGraph();
  // 1. 添加设备节点
  graph.addVertex('Server-01', { deviceType:'server', ip: '192.168.1.100', status: 'online' });
  graph.addVertex('Switch-01', { deviceType:'switch', ip: '192.168.1.1', status: 'online' });
  graph.addVertex('PC-001', { deviceType: 'terminal', ip: '192.168.1.201', status: 'online' });
  graph.addVertex('PC-002', { deviceType: 'terminal', ip: '192.168.1.202', status: 'online' });
  // 2. 添加连接边
  graph.addEdge('Server-01', 'Switch-01', { linkType: 'wired', bandwidth: 1000 });
  graph.addEdge('Switch-01', 'PC-001', { linkType: 'wired', bandwidth: 100 });
  graph.addEdge('Switch-01', 'PC-002', { linkType: 'wireless', bandwidth: 54 });
  // 3. 查找PC-001到Server-01的传输路径
  const paths = graph.findAllPaths('PC-001', 'Server-01');
  console.log('PC-001到Server-01的传输路径：', paths);
  // 4. 模拟Switch-01故障，分析受影响设备并上报
  graph.addVertex('Switch-01', { status: 'offline' }); // 更新节点状态为离线
  const affected = graph.getAffectedDevices('Switch-01');
  console.log('Switch-01故障受影响设备：', affected.map(dev => dev.deviceId));
  await graph.reportFault('Switch-01');
}
// 执行测试
testNetworkGraph();