fix(network-map): якорить сервисы на выходную ноду

Пунктир от EN, а не от JH; перетаскивание узлов сервисов; иконка Google без foreignObject.

Co-authored-by: Cursor <[email protected]>

backend/src/services/traffic-flow-map-hops.test.ts

@@ -208,7 +208,9 @@ try {
   const google = six.services?.find((s) => s.id === "svc:google")
   assert.ok(google, "Google ≥ 5%")
   assert.ok(google.share >= 0.05)
-  assert.ok(six.serviceEdges?.some((e) => e.toId === "svc:google" && e.fromId === "9"))
+  const googleEdge = six.serviceEdges?.find((e) => e.toId === "svc:google" && e.fromId === "9")
+  assert.ok(googleEdge)
+  assert.equal(googleEdge.clientName, "Alice")
 } finally {
   resetFlowRingsForTests()
   resetIfaceCacheForTests()
@@ -327,4 +329,46 @@ try {
   resetFlowCatalogForTests()
 }
 
+resetFlowRingsForTests()
+resetIfaceCacheForTests()
+resetRipeCacheForTests()
+disableRipeEnqueueForTests()
+seedFlowTopologyForTests(topo)
+rememberServerIfaces(7, [
+  { ".id": "*1", name: "SWE-VEESP" },
+  { ".id": "*2", name: "gre-client" },
+  { ".id": "*3", name: "gre-jh-en" },
+])
+ingestParsedFlowsForServerForTests(7, [
+  payloadFlow("8.8.8.8", 500),
+  {
+    src: "173.194.151.65",
+    dst: "10.200.100.53",
+    proto: 6,
+    srcPort: 443,
+    dstPort: 57182,
+    bytes: 8_000,
+    packets: 80,
+    inIface: "1",
+    outIface: "1",
+    nextHop: "",
+  },
+])
+try {
+  resetFlowMapHopsCacheForTests()
+  const wan = buildFlowMapHops({ minutes: 5, minSharePct: 0 })
+  const googleEdge = wan.serviceEdges?.find((e) => e.toId === "svc:google")
+  assert.ok(googleEdge, "Google с WAN JH")
+  assert.equal(googleEdge.fromId, "9", "якорь на EN, не на JH")
+  assert.ok(!(wan.serviceEdges ?? []).some((e) => e.fromId === "7"), "нет пунктира с JH")
+  const viaGre = wan.serviceEdges?.find((e) => e.toId === "svc:google")
+  assert.ok(viaGre?.clients?.some((c) => c.name === "Alice") || viaGre?.clientName === "Alice")
+} finally {
+  seedFlowTopologyForTests(null)
+  resetFlowRingsForTests()
+  resetIfaceCacheForTests()
+  resetRipeCacheForTests()
+  resetFlowCatalogForTests()
+}
+
 console.log("traffic-flow-map-hops.test.ts: ok")

backend/src/services/traffic-flow-map-hops.ts

@@ -15,7 +15,7 @@ import { classifyFlowPlane, shouldKeepPlane } from "./traffic-flow-planes.js"
 import { pickInternetPeer } from "./traffic-flow-ip.js"
 import { lookupRipeCached, type FlowIpMeta } from "./traffic-flow-ripe.js"
 import { getTrafficFlowSettingsRow } from "./traffic-flow-settings.js"
-import { loadFlowTopology, resolveEn } from "./traffic-flow-topology.js"
+import { loadFlowTopology, resolveClient, resolveEn } from "./traffic-flow-topology.js"
 
 export const DEFAULT_MAP_SERVICE_MIN_SHARE_PCT = 5
 export const MAP_SERVICE_NODE_CAP = 20
@@ -45,12 +45,29 @@ interface HopAcc {
   bytesRev: number
 }
 
+interface FromAcc {
+  bytes: number
+  clients: Map<string, string>
+}
+
 interface DstAcc {
   bytes: number
   proto: number
   dstPort: number
   srcPort: number
-  fromBytes: Map<string, number>
+  fromBytes: Map<string, FromAcc>
+}
+
+function bumpFrom(acc: DstAcc, exporterId: string, bytes: number, client: { userId: string; name: string } | null): void {
+  const prev = acc.fromBytes.get(exporterId)
+  if (prev) {
+    prev.bytes += bytes
+    if (client) prev.clients.set(client.userId, client.name)
+    return
+  }
+  const clients = new Map<string, string>()
+  if (client) clients.set(client.userId, client.name)
+  acc.fromBytes.set(exporterId, { bytes, clients })
 }
 
 let hopsCache: { key: string; at: number; dto: FlowMapHopsDto } | null = null
@@ -190,6 +207,8 @@ function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number): Flo
   const working = wantDedup ? dedupFlowRowsMaxBytes(matched) : matched
   const hops = new Map<string, HopAcc>()
   const dstAcc = new Map<string, DstAcc>()
+  const jhToEn = new Map<number, number>()
+  const enIds = new Set(topo.enNodes.map((n) => n.id))
   let totalBytes = 0
 
   for (const r of working) {
@@ -241,6 +260,7 @@ function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number): Flo
     const en = (enOut && enOut.id !== r.serverId ? enOut : null)
       ?? (enIn && enIn.id !== r.serverId ? enIn : null)
     if (en) {
+      jhToEn.set(r.serverId, en.id)
       const toId = String(en.id)
       const dir: "fwd" | "rev" = enOut && enOut.id === en.id ? "fwd" : "rev"
       const greIface = dir === "fwd" && ifaceUsable(outName) ? outName : (ifaceUsable(inName) ? inName : undefined)
@@ -278,25 +298,42 @@ function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number): Flo
     }
 
     totalBytes += r.bytes
-    const svcFromId = String((enOut ?? enIn)?.id ?? r.serverId)
     const peer = pickInternetPeer(r.src, r.dst, r.srcPort, r.dstPort)
+    const client = resolveClient(topo, r.serverId, inName)
     const prevDst = dstAcc.get(peer)
     if (prevDst) {
       prevDst.bytes += r.bytes
-      prevDst.fromBytes.set(svcFromId, (prevDst.fromBytes.get(svcFromId) ?? 0) + r.bytes)
+      bumpFrom(prevDst, String(r.serverId), r.bytes, client)
     } else {
-      dstAcc.set(peer, {
+      const acc: DstAcc = {
         bytes: r.bytes,
         proto: r.proto,
         dstPort: r.dstPort,
         srcPort: r.srcPort,
-        fromBytes: new Map([[svcFromId, r.bytes]]),
-      })
+        fromBytes: new Map(),
+      }
+      bumpFrom(acc, String(r.serverId), r.bytes, client)
+      dstAcc.set(peer, acc)
     }
   }
 
   const svcTotals = new Map<string, { label: string; category: string; bytes: number }>()
-  const svcEdges = new Map<string, { fromId: string; toId: string; bytes: number; bytesFwd: number; bytesRev: number }>()
+  const svcEdges = new Map<string, {
+    fromId: string
+    toId: string
+    bytes: number
+    bytesFwd: number
+    bytesRev: number
+    clients: Map<string, string>
+  }>()
+
+  function anchorEnId(exporterId: string): string | null {
+    const n = Number(exporterId)
+    if (enIds.has(n)) return exporterId
+    const mapped = jhToEn.get(n)
+    if (mapped != null) return String(mapped)
+    return null
+  }
 
   for (const [dst, acc] of dstAcc) {
     const ripe = lookupRipeCached(dst)
@@ -306,19 +343,23 @@ function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number): Flo
     const prevSvc = svcTotals.get(toId)
     if (prevSvc) prevSvc.bytes += acc.bytes
     else svcTotals.set(toId, { label: classified.service, category: classified.category, bytes: acc.bytes })
-    for (const [fromId, bytes] of acc.fromBytes) {
+    for (const [exporterId, from] of acc.fromBytes) {
+      const fromId = anchorEnId(exporterId)
+      if (!fromId) continue
       const edgeKey = `${fromId}|${toId}`
       const prevEdge = svcEdges.get(edgeKey)
       if (prevEdge) {
-        prevEdge.bytes += bytes
-        prevEdge.bytesFwd += bytes
+        prevEdge.bytes += from.bytes
+        prevEdge.bytesFwd += from.bytes
+        for (const [id, name] of from.clients) prevEdge.clients.set(id, name)
       } else {
         svcEdges.set(edgeKey, {
           fromId,
           toId,
-          bytes,
-          bytesFwd: bytes,
+          bytes: from.bytes,
+          bytesFwd: from.bytes,
           bytesRev: 0,
+          clients: new Map(from.clients),
         })
       }
     }
@@ -342,14 +383,20 @@ function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number): Flo
   const keepSvc = new Set(services.map((s) => s.id))
   const serviceEdges: FlowMapServiceEdge[] = [...svcEdges.values()]
     .filter((e) => keepSvc.has(e.toId))
-    .map((e) => ({
-      fromId: e.fromId,
-      toId: e.toId,
-      bytes: e.bytes,
-      bps: (e.bytes * 8) / windowSec,
-      bpsFwd: (e.bytesFwd * 8) / windowSec,
-      bpsRev: (e.bytesRev * 8) / windowSec,
-    }))
+    .map((e) => {
+      const clients = [...e.clients.entries()].map(([id, name]) => ({ id, name }))
+      const first = clients[0]
+      return {
+        fromId: e.fromId,
+        toId: e.toId,
+        bytes: e.bytes,
+        bps: (e.bytes * 8) / windowSec,
+        bpsFwd: (e.bytesFwd * 8) / windowSec,
+        bpsRev: (e.bytesRev * 8) / windowSec,
+        ...(first ? { clientId: first.id, clientName: first.name } : {}),
+        ...(clients.length ? { clients } : {}),
+      }
+    })
     .sort((a, b) => b.bytes - a.bytes)
 
   const listener = getFlowListenerState()