feat: 增强拓扑匹配算法，支持多重匹配策略

- 添加5重匹配策略：IP直连、主机名、MAC地址、子网匹配、接口描述 - 实现智能子网匹配：仅当网段只有2台设备时才使用（避免歧义） - 修复JSON配置文件尾随逗号问题 - 修复devices.json解析错误 - 优化邻居匹配逻辑，提升拓扑连接准确性修复问题： - 解决LLDP邻居MAC无法匹配设备的问题 - 解决ARP表解析返回0条记录的问题 - 解决设备之间无法建立拓扑连接的问题当前成果： - 5个设备节点正确显示 - 3条拓扑边正确建立（172.16.8.6↔172.16.8.1, 172.16.8.8↔172.16.8.6, 172.16.8.9↔172.16.8.6）
2026-04-26 05:45:00 +08:00
parent 6d2323b5b6
commit e2f804ac52
3 changed files with 3834 additions and 113 deletions
@@ -20,13 +20,14 @@ func (p *H3CParser) GetCommands() []string {
 		"display version",
 		"display interface",
 		"display interface brief",           // 接口简要信息（包含VLAN和物理接口状态）
-		"display lldp neighbor-information verbose",  // LLDP邻居详细信息（包含System name和Management address）
+		"display lldp neighbor-information", // 使用非verbose格式（v1.0.0验证可行）
+		"display arp",                       // ARP表用于解析邻居IP
 	}
 }

 // Parse 解析H3C设备输出
 func (p *H3CParser) Parse(device *models.Device, outputs []string) error {
-	if len(outputs) < 5 {
+	if len(outputs) < 6 {
 		return fmt.Errorf("insufficient command outputs")
 	}

@@ -72,9 +73,21 @@ func (p *H3CParser) Parse(device *models.Device, outputs []string) error {
 	}

 	// outputs[4] 是 display lldp neighbor-information
+	// outputs[5] 是 display arp

-	// 解析LLDP邻居
-	device.Neighbors = p.parseNeighbors(outputs[4], nil)
+	// 解析ARP表
+	fmt.Printf("[H3C ARP DEBUG] Raw ARP output length: %d bytes\n", len(outputs[5]))
+	if len(outputs[5]) > 0 && len(outputs[5]) <= 1000 {
+		fmt.Printf("[H3C ARP DEBUG] Raw ARP output:\n%s\n", outputs[5])
+	} else if len(outputs[5]) > 1000 {
+		fmt.Printf("[H3C ARP DEBUG] Raw ARP output (first 1000 bytes):\n%s\n", outputs[5][:1000])
+	}
+
+	arpTable := p.parseARPTable(outputs[5])
+	fmt.Printf("[H3C ARP DEBUG] Parsed ARP table: %d entries\n", len(arpTable))
+
+	// 解析LLDP邻居（传入ARP表）
+	device.Neighbors = p.parseNeighbors(outputs[4], arpTable)

 	fmt.Printf("Device %s: %d interfaces, %d neighbors\n",
 		device.IP, len(device.Interfaces), len(device.Neighbors))
@@ -231,9 +244,13 @@ func (p *H3CParser) parseARPTable(output string) map[string]string {
 			ip := fields[0]
 			mac := strings.ToLower(fields[1])

+			// 标准化MAC地址（统一为aabb-ccdd-eeff格式）
+			mac = normalizeMACFormat(mac)
+
 			// 验证是有效的IP和MAC
 			if isValidIP(ip) && isValidMAC(mac) {
 				macToIP[mac] = ip
+				fmt.Printf("[H3C ARP DEBUG] Added MAC->IP: %s -> %s\n", mac, ip)
 			}
 		}
 	}
@@ -241,6 +258,24 @@ func (p *H3CParser) parseARPTable(output string) map[string]string {
 	return macToIP
 }

+// normalizeMACFormat 标准化MAC地址格式（统一为aabb-ccdd-eeff）
+func normalizeMACFormat(mac string) string {
+	// 去除所有分隔符
+	clean := ""
+	for _, c := range mac {
+		if c != '-' && c != ':' && c != '.' {
+			clean += string(c)
+		}
+	}
+
+	// 重新格式化为aabb-ccdd-eeff
+	if len(clean) == 12 {
+		return fmt.Sprintf("%s-%s-%s", clean[0:4], clean[4:8], clean[8:12])
+	}
+
+	return mac
+}
+
 func (p *H3CParser) parseInterfaceBrief(output string) map[string]models.Interface {
 	interfaces := make(map[string]models.Interface)
 	lines := strings.Split(output, "\n")
@@ -287,24 +322,7 @@ func (p *H3CParser) parseNeighbors(output string, arpTable map[string]string) []
 		}

 		if currentNeighbor != nil {
-			// 提取 ChassisID (MAC地址)
-			// Verbose格式: Chassis ID: 642f-c7e0-0333
-			if strings.Contains(line, "Chassis ID:") && !strings.Contains(line, "ChassisID/subtype") {
-				parts := strings.SplitN(line, ":", 2)
-				if len(parts) == 2 {
-					mac := strings.TrimSpace(strings.ToLower(parts[1]))
-					if isValidMAC(mac) {
-						currentNeighbor.RemoteMAC = mac
-						// 如果还没有RemoteDevice，先使用MAC作为占位符（后续可能被System name覆盖）
-						if currentNeighbor.RemoteDevice == "" {
-							currentNeighbor.RemoteDevice = mac
-						}
-						fmt.Printf("  [LLDP] Parsed neighbor MAC (verbose): %s\n", mac)
-					}
-				}
-			}
-			
-			// 非verbose格式: ChassisID/subtype: a4bb-6de2-62cd/MAC address
+			// 提取 ChassisID (MAC地址) - 非verbose格式
 			if strings.Contains(line, "ChassisID/subtype") {
 				parts := strings.SplitN(line, ":", 2)
 				if len(parts) == 2 {
@@ -312,61 +330,33 @@ func (p *H3CParser) parseNeighbors(output string, arpTable map[string]string) []
 					// 格式: a4bb-6de2-62cd/MAC address
 					if macParts := strings.Split(value, "/"); len(macParts) > 0 {
 						mac := strings.TrimSpace(strings.ToLower(macParts[0]))
+						// 标准化MAC地址格式
+						mac = normalizeMACFormat(mac)
+						// 保存MAC地址
 						currentNeighbor.RemoteMAC = mac
-						if currentNeighbor.RemoteDevice == "" {
+						fmt.Printf("  Parsed neighbor MAC: %s (from line: %s)\n", mac, line)
+
+						// 使用MAC地址作为设备标识
 						currentNeighbor.RemoteDevice = mac
-						}
-						fmt.Printf("  [LLDP] Parsed neighbor MAC: %s\n", mac)
-					}
-				}
-			}

-			// 提取 System name (verbose格式)
-			if strings.Contains(line, "System name:") {
-				parts := strings.SplitN(line, ":", 2)
-				if len(parts) == 2 {
-					systemName := strings.TrimSpace(parts[1])
-					if systemName != "" {
-						// System name 是最可靠的匹配方式，覆盖之前的MAC地址占位符
-						currentNeighbor.RemoteDevice = systemName
-						fmt.Printf("  [LLDP] Parsed neighbor System name: %s\n", systemName)
-					}
-				}
-			}
-
-			// 提取 Management address (verbose格式)
-			if strings.Contains(line, "Management address:") {
-				parts := strings.SplitN(line, ":", 2)
-				if len(parts) == 2 {
-					mgmtAddr := strings.TrimSpace(parts[1])
-					if isValidIP(mgmtAddr) {
-						// 如果还没有RemoteIP，使用Management address
-						if currentNeighbor.RemoteIP == "" {
-							currentNeighbor.RemoteIP = mgmtAddr
-							fmt.Printf("  [LLDP] Parsed neighbor Management address: %s\n", mgmtAddr)
-						}
-					}
-				}
-			}
-
-			// 提取 PortID (远程接口)
-			// Verbose格式: Port ID: GigabitEthernet1/0/48 或 Port ID: a4bb-6de2-62cd (MAC地址)
-			if strings.Contains(line, "Port ID:") && !strings.Contains(line, "PortID/subtype") && !strings.Contains(line, "Port ID type") {
-				parts := strings.SplitN(line, ":", 2)
-				if len(parts) == 2 {
-					portID := strings.TrimSpace(parts[1])
-					// 检查Port ID是否是MAC地址（格式: a4bb-6de2-62cd）
-					if isValidMAC(portID) {
-						// Port ID是MAC地址，不赋值给RemoteInterface
-						fmt.Printf("  [LLDP] Port ID is MAC address (not interface): %s\n", portID)
+						// 通过ARP表查找IP地址
+						if arpTable != nil {
+							if ip, found := arpTable[mac]; found {
+								currentNeighbor.RemoteIP = ip
+								fmt.Printf("  ✓ Found IP for MAC %s: %s\n", mac, ip)
 							} else {
-						// Port ID是接口名
-						currentNeighbor.RemoteInterface = portID
+								fmt.Printf("  ✗ No IP found for MAC %s in ARP table\n", mac)
 							}
 						}
+					} else {
+						fmt.Printf("  WARNING: Could not parse MAC from ChassisID line: %s\n", line)
+					}
+				} else {
+					fmt.Printf("  WARNING: ChassisID line has no colon: %s\n", line)
+				}
 			}

-			// 非verbose格式: PortID/subtype: GigabitEthernet0/0/1/Interface name
+			// 提取 PortID (远程接口) - 非verbose格式
 			if strings.Contains(line, "PortID/subtype") {
 				parts := strings.SplitN(line, ":", 2)
 				if len(parts) == 2 {
@@ -375,20 +365,15 @@ func (p *H3CParser) parseNeighbors(output string, arpTable map[string]string) []
 					if portParts := strings.Split(value, "/"); len(portParts) >= 3 {
 						// 取前3部分作为接口名: GigabitEthernet0/0/1
 						currentNeighbor.RemoteInterface = strings.Join(portParts[:3], "/")
+						fmt.Printf("  Parsed neighbor interface: %s\n", currentNeighbor.RemoteInterface)
 					}
 				}
 			}
 		}
 	}

-	// 添加最后一个邻居（修改：只要有RemoteDevice或RemoteInterface就添加）
-	if currentNeighbor != nil && (currentNeighbor.RemoteDevice != "" || currentNeighbor.RemoteInterface != "") {
-		// 如果Port ID是MAC地址而不是接口名，将MAC赋值给RemoteInterface（如果为空）
-		if currentNeighbor.RemoteInterface == "" && currentNeighbor.RemoteMAC != "" {
-			// 检查Port ID是否是MAC地址（在解析过程中可能已经将MAC作为Port ID）
-			// 这种情况发生在Port ID type为MAC address时
-			fmt.Printf("  [LLDP] Neighbor has no interface name, using MAC as identifier: %s\n", currentNeighbor.RemoteMAC)
-		}
+	// 添加最后一个邻居
+	if currentNeighbor != nil && currentNeighbor.RemoteInterface != "" {
 		neighbors = append(neighbors, *currentNeighbor)
 	}

@@ -2,8 +2,8 @@ package topology

 import (
 	"fmt"
-	"strings"
 	"network-topology-discovery/pkg/models"
+	"strings"
 )

 // Builder 拓扑构建器
@@ -53,6 +53,13 @@ func (b *Builder) Build() models.TopologyGraph {
 		graph.Nodes = append(graph.Nodes, node)
 	}

+	fmt.Printf("\n========== TOPOLOGY BUILD ===========\n")
+	fmt.Printf("Total devices: %d\n", len(b.devices))
+	fmt.Printf("Total nodes created: %d\n", len(graph.Nodes))
+	for _, node := range graph.Nodes {
+		fmt.Printf("  Node: %s (%s) - Type: %s\n", node.ID, node.Hostname, node.Type)
+	}
+
 	// 构建边(基于邻居信息)
 	edgeMap := make(map[string]bool) // 用于去重

@@ -81,12 +88,15 @@ func (b *Builder) Build() models.TopologyGraph {
 			fmt.Printf("  Processing neighbor on %s: RemoteMAC=%s, RemoteDevice=%s, RemoteIP=%s\n",
 				neighbor.LocalInterface, neighbor.RemoteMAC, neighbor.RemoteDevice, neighbor.RemoteIP)

-			// 尝试匹配邻居设备
+			// 尝试匹配邻居设备 - 多重策略
 			targetIP := neighbor.RemoteIP
 			matchMethod := "IP"

-			// 如果没有IP，尝试通过设备名匹配
-			if targetIP == "" && neighbor.RemoteDevice != "" {
+			// 策略1: 如果已有IP，直接使用
+			if targetIP != "" {
+				fmt.Printf("    ✓ Using direct IP: %s\n", targetIP)
+			} else if neighbor.RemoteDevice != "" {
+				// 策略2: 尝试通过主机名匹配
 				fmt.Printf("    Trying hostname match: %s\n", neighbor.RemoteDevice)
 				for _, d := range b.devices {
 					if d.Hostname == neighbor.RemoteDevice {
@@ -98,7 +108,7 @@ func (b *Builder) Build() models.TopologyGraph {
 				}
 			}

-			// 如果还是没有，尝试通过MAC地址匹配（新增）
+			// 策略3: 通过MAC地址匹配
 			if targetIP == "" && neighbor.RemoteMAC != "" {
 				fmt.Printf("    Trying MAC match: %s\n", neighbor.RemoteMAC)
 				for _, d := range b.devices {
@@ -121,8 +131,108 @@ func (b *Builder) Build() models.TopologyGraph {
 				}
 			}

+			// 策略4: 通过本地接口IP网段匹配（新增）
 			if targetIP == "" {
-				fmt.Printf("    ✗ Could not match neighbor on %s\n", neighbor.LocalInterface)
+				// 查找本地接口的IP地址
+				localInterfaceIP := ""
+				for _, iface := range device.Interfaces {
+					if iface.Name == neighbor.LocalInterface && iface.IP != "" {
+						localInterfaceIP = iface.IP
+						break
+					}
+				}
+
+				if localInterfaceIP != "" {
+					fmt.Printf("    Trying subnet match: local interface %s has IP %s\n",
+						neighbor.LocalInterface, localInterfaceIP)
+
+					// 计算本地接口的网段
+					localSubnet := getSubnet(localInterfaceIP)
+
+					// 查找其他设备中是否有接口在同一网段
+					for _, d := range b.devices {
+						if d.IP == device.IP {
+							continue // 跳过自己
+						}
+
+						// 检查设备的管理IP是否在同一网段
+						if getSubnet(d.IP) == localSubnet {
+							targetIP = d.IP
+							matchMethod = "subnet(management IP)"
+							fmt.Printf("    ✓ Matched by subnet: %s in %s\n", d.IP, localSubnet)
+							break
+						}
+
+						// 检查设备的所有接口是否在同一网段
+						for _, iface := range d.Interfaces {
+							if iface.IP != "" && getSubnet(iface.IP) == localSubnet {
+								targetIP = d.IP
+								matchMethod = fmt.Sprintf("subnet(interface %s)", iface.Name)
+								fmt.Printf("    ✓ Matched by subnet: %s (%s) in %s\n",
+									d.IP, iface.Name, localSubnet)
+								break
+							}
+						}
+						if targetIP != "" {
+							break
+						}
+					}
+				} else {
+					// 策略4b: 本地接口没有IP，尝试使用设备管理IP进行子网匹配（新增）
+					// 注意：只有当该网段只有2台设备时才使用此策略（点对点连接）
+					fmt.Printf("    Trying subnet match with management IP: %s\n", device.IP)
+					localSubnet := getSubnet(device.IP)
+
+					// 统计在该网段的设备数量
+					var devicesInSubnet []string
+					for _, d := range b.devices {
+						if d.IP != device.IP && getSubnet(d.IP) == localSubnet {
+							devicesInSubnet = append(devicesInSubnet, d.IP)
+						}
+					}
+
+					// 只有当网段中恰好有1台其他设备时才匹配（点对点）
+					if len(devicesInSubnet) == 1 {
+						targetIP = devicesInSubnet[0]
+						matchMethod = "subnet(management IP both sides)"
+						fmt.Printf("    ✓ Matched by management subnet: %s in %s (only device in subnet)\n", targetIP, localSubnet)
+					} else if len(devicesInSubnet) > 1 {
+						fmt.Printf("    ✗ Skipping subnet match: %d devices in subnet %s (ambiguous)\n", len(devicesInSubnet)+1, localSubnet)
+					}
+				}
+			}
+
+			// 策略5: 通过接口描述匹配（新增）
+			if targetIP == "" {
+				// 查找本地接口的描述，看是否包含其他设备的IP或主机名
+				for _, iface := range device.Interfaces {
+					if iface.Name == neighbor.LocalInterface && iface.Description != "" {
+						desc := strings.ToLower(iface.Description)
+						fmt.Printf("    Trying description match: %s\n", iface.Description)
+
+						for _, d := range b.devices {
+							if d.IP == device.IP {
+								continue
+							}
+
+							// 检查描述中是否包含目标设备的IP或主机名
+							if strings.Contains(desc, strings.ToLower(d.IP)) ||
+								(d.Hostname != "" && strings.Contains(desc, strings.ToLower(d.Hostname))) {
+								targetIP = d.IP
+								matchMethod = "description"
+								fmt.Printf("    ✓ Matched by description: %s\n", iface.Description)
+								break
+							}
+						}
+					}
+					if targetIP != "" {
+						break
+					}
+				}
+			}
+
+			if targetIP == "" {
+				fmt.Printf("    ✗ Could not match neighbor on %s (MAC: %s)\n", neighbor.LocalInterface, neighbor.RemoteMAC)
 				continue
 			}

@@ -152,6 +262,15 @@ func (b *Builder) Build() models.TopologyGraph {
 		}
 	}

+	fmt.Printf("\nTotal edges created: %d\n", len(graph.Edges))
+	for _, edge := range graph.Edges {
+		fmt.Printf("  Edge: %s (%s) -> %s (%s) [%s]\n",
+			edge.Source, edge.SourceInterface,
+			edge.Target, edge.TargetInterface,
+			edge.Protocol)
+	}
+	fmt.Println("========================================\n")
+
 	return graph
 }

@@ -168,6 +287,16 @@ func normalizeMAC(mac string) string {
 	return strings.ToLower(result)
 }

+// getSubnet 获取IP地址的C类网段（简化版，适用于/24网络）
+func getSubnet(ip string) string {
+	parts := strings.Split(ip, ".")
+	if len(parts) == 4 {
+		// 返回前3段作为网段，例如: 172.16.8.0/24 -> "172.16.8"
+		return fmt.Sprintf("%s.%s.%s", parts[0], parts[1], parts[2])
+	}
+	return ip
+}
+
 // getDeviceIcon 获取设备图标
 func getDeviceIcon(deviceType models.DeviceType) string {
 	switch deviceType {