func (rep *reporter) addConnection(r *report.Report, c *procspy.Connection) { var ( scopedLocal = report.MakeAddressNodeID(rep.hostID, c.LocalAddress.String()) scopedRemote = report.MakeAddressNodeID(rep.hostID, c.RemoteAddress.String()) key = report.MakeAdjacencyID(scopedLocal) edgeKey = report.MakeEdgeID(scopedLocal, scopedRemote) ) r.Address.Adjacency[key] = r.Address.Adjacency[key].Add(scopedRemote) if _, ok := r.Address.NodeMetadatas[scopedLocal]; !ok { r.Address.NodeMetadatas[scopedLocal] = report.NodeMetadata{ "name": rep.hostName, "addr": c.LocalAddress.String(), } } // Count the TCP connection. edgeMeta := r.Address.EdgeMetadatas[edgeKey] edgeMeta.WithConnCountTCP = true edgeMeta.MaxConnCountTCP++ r.Address.EdgeMetadatas[edgeKey] = edgeMeta if c.Proc.PID > 0 { var ( scopedLocal = report.MakeEndpointNodeID(rep.hostID, c.LocalAddress.String(), strconv.Itoa(int(c.LocalPort))) scopedRemote = report.MakeEndpointNodeID(rep.hostID, c.RemoteAddress.String(), strconv.Itoa(int(c.RemotePort))) key = report.MakeAdjacencyID(scopedLocal) edgeKey = report.MakeEdgeID(scopedLocal, scopedRemote) ) r.Endpoint.Adjacency[key] = r.Endpoint.Adjacency[key].Add(scopedRemote) if _, ok := r.Endpoint.NodeMetadatas[scopedLocal]; !ok { // First hit establishes NodeMetadata for scoped local address + port md := report.NodeMetadata{ "addr": c.LocalAddress.String(), "port": strconv.Itoa(int(c.LocalPort)), "pid": fmt.Sprintf("%d", c.Proc.PID), } r.Endpoint.NodeMetadatas[scopedLocal] = md } // Count the TCP connection. edgeMeta := r.Endpoint.EdgeMetadatas[edgeKey] edgeMeta.WithConnCountTCP = true edgeMeta.MaxConnCountTCP++ r.Endpoint.EdgeMetadatas[edgeKey] = edgeMeta } }
func TestSpyWithProcesses(t *testing.T) { procspy.SetFixtures(fixConnectionsWithProcesses) const ( nodeID = "nikon" // TODO rename to hostID nodeName = "fishermans-friend" // TODO rename to hostNmae ) reporter := endpoint.NewReporter(nodeID, nodeName, false) r, _ := reporter.Report() // buf, _ := json.MarshalIndent(r, "", " ") ; t.Logf("\n%s\n", buf) var ( scopedLocal = report.MakeEndpointNodeID(nodeID, fixLocalAddress.String(), strconv.Itoa(int(fixLocalPort))) scopedRemote = report.MakeEndpointNodeID(nodeID, fixRemoteAddress.String(), strconv.Itoa(int(fixRemotePort))) localKey = report.MakeAdjacencyID(scopedLocal) ) if want, have := 1, len(r.Endpoint.Adjacency[localKey]); want != have { t.Fatalf("want %d, have %d", want, have) } if want, have := scopedRemote, r.Endpoint.Adjacency[localKey][0]; want != have { t.Fatalf("want %q, have %q", want, have) } for key, want := range map[string]string{ "pid": strconv.FormatUint(uint64(fixProcessPID), 10), } { if have := r.Endpoint.NodeMetadatas[scopedLocal].Metadata[key]; want != have { t.Errorf("Process.NodeMetadatas[%q][%q]: want %q, have %q", scopedLocal, key, want, have) } } }
func (r *Reporter) addConnection(rpt *report.Report, c *procspy.Connection) { var ( scopedLocal = report.MakeAddressNodeID(r.hostID, c.LocalAddress.String()) scopedRemote = report.MakeAddressNodeID(r.hostID, c.RemoteAddress.String()) key = report.MakeAdjacencyID(scopedLocal) edgeKey = report.MakeEdgeID(scopedLocal, scopedRemote) ) rpt.Address.Adjacency[key] = rpt.Address.Adjacency[key].Add(scopedRemote) if _, ok := rpt.Address.NodeMetadatas[scopedLocal]; !ok { rpt.Address.NodeMetadatas[scopedLocal] = report.NewNodeMetadata(map[string]string{ docker.Name: r.hostName, docker.Addr: c.LocalAddress.String(), }) } countTCPConnection(rpt.Address.EdgeMetadatas, edgeKey) if c.Proc.PID > 0 { var ( scopedLocal = report.MakeEndpointNodeID(r.hostID, c.LocalAddress.String(), strconv.Itoa(int(c.LocalPort))) scopedRemote = report.MakeEndpointNodeID(r.hostID, c.RemoteAddress.String(), strconv.Itoa(int(c.RemotePort))) key = report.MakeAdjacencyID(scopedLocal) edgeKey = report.MakeEdgeID(scopedLocal, scopedRemote) ) rpt.Endpoint.Adjacency[key] = rpt.Endpoint.Adjacency[key].Add(scopedRemote) if _, ok := rpt.Endpoint.NodeMetadatas[scopedLocal]; !ok { // First hit establishes NodeMetadata for scoped local address + port md := report.NewNodeMetadata(map[string]string{ "addr": c.LocalAddress.String(), "port": strconv.Itoa(int(c.LocalPort)), "pid": fmt.Sprintf("%d", c.Proc.PID), }) rpt.Endpoint.NodeMetadatas[scopedLocal] = md } countTCPConnection(rpt.Endpoint.EdgeMetadatas, edgeKey) } }
func (r *Reporter) addConnection(rpt *report.Report, c *procspy.Connection) { var ( localAddressNodeID = report.MakeAddressNodeID(r.hostID, c.LocalAddress.String()) remoteAddressNodeID = report.MakeAddressNodeID(r.hostID, c.RemoteAddress.String()) adjecencyID = report.MakeAdjacencyID(localAddressNodeID) edgeID = report.MakeEdgeID(localAddressNodeID, remoteAddressNodeID) ) rpt.Address.Adjacency[adjecencyID] = rpt.Address.Adjacency[adjecencyID].Add(remoteAddressNodeID) if _, ok := rpt.Address.NodeMetadatas[localAddressNodeID]; !ok { rpt.Address.NodeMetadatas[localAddressNodeID] = report.MakeNodeMetadataWith(map[string]string{ "name": r.hostName, Addr: c.LocalAddress.String(), }) } countTCPConnection(rpt.Address.EdgeMetadatas, edgeID) if c.Proc.PID > 0 { var ( localEndpointNodeID = report.MakeEndpointNodeID(r.hostID, c.LocalAddress.String(), strconv.Itoa(int(c.LocalPort))) remoteEndpointNodeID = report.MakeEndpointNodeID(r.hostID, c.RemoteAddress.String(), strconv.Itoa(int(c.RemotePort))) adjecencyID = report.MakeAdjacencyID(localEndpointNodeID) edgeID = report.MakeEdgeID(localEndpointNodeID, remoteEndpointNodeID) ) rpt.Endpoint.Adjacency[adjecencyID] = rpt.Endpoint.Adjacency[adjecencyID].Add(remoteEndpointNodeID) if _, ok := rpt.Endpoint.NodeMetadatas[localEndpointNodeID]; !ok { // First hit establishes NodeMetadata for scoped local address + port md := report.MakeNodeMetadataWith(map[string]string{ Addr: c.LocalAddress.String(), Port: strconv.Itoa(int(c.LocalPort)), process.PID: fmt.Sprint(c.Proc.PID), }) rpt.Endpoint.NodeMetadatas[localEndpointNodeID] = md } countTCPConnection(rpt.Endpoint.EdgeMetadatas, edgeID) } }
func TestAdjacencyID(t *testing.T) { for _, bad := range []string{ client54001EndpointNodeID, client54002EndpointNodeID, unknown1EndpointNodeID, unknown2EndpointNodeID, unknown3EndpointNodeID, clientAddressNodeID, serverAddressNodeID, unknownAddressNodeID, clientHostNodeID, serverHostNodeID, ";", "", } { if srcNodeID, ok := report.ParseAdjacencyID(bad); ok { t.Errorf("%q: expected failure, but got (%q)", bad, srcNodeID) } } for input, want := range map[string]struct{ srcNodeID string }{ report.MakeAdjacencyID(report.MakeEndpointNodeID("a", "b", "c")): {report.MakeEndpointNodeID("a", "b", "c")}, report.MakeAdjacencyID(report.MakeAddressNodeID("a", "b")): {report.MakeAddressNodeID("a", "b")}, report.MakeAdjacencyID(report.MakeProcessNodeID("a", "b")): {report.MakeProcessNodeID("a", "b")}, report.MakeAdjacencyID(report.MakeHostNodeID("a")): {report.MakeHostNodeID("a")}, ">host.com;1.2.3.4": {"host.com;1.2.3.4"}, ">a;b;c": {"a;b;c"}, ">a;b": {"a;b"}, ">a;": {"a;"}, ">;b": {";b"}, ">;": {";"}, } { srcNodeID, ok := report.ParseAdjacencyID(input) if !ok { t.Errorf("%q: not OK", input) continue } if want, have := want.srcNodeID, srcNodeID; want != have { t.Errorf("%q: want %q, have %q", input, want, have) } } }
func connectionDetailsRows(topology report.Topology, originID string) []Row { rows := []Row{} labeler := func(nodeID string) (string, bool) { if _, addr, port, ok := report.ParseEndpointNodeID(nodeID); ok { return fmt.Sprintf("%s:%s", addr, port), true } if _, addr, ok := report.ParseAddressNodeID(nodeID); ok { return addr, true } return "", false } local, ok := labeler(originID) if !ok { return rows } // Firstly, collection outgoing connections from this node. originAdjID := report.MakeAdjacencyID(originID) for _, serverNodeID := range topology.Adjacency[originAdjID] { remote, ok := labeler(serverNodeID) if !ok { continue } rows = append(rows, Row{ Key: local, ValueMajor: remote, Expandable: true, }) } // Next, scan the topology for incoming connections to this node. for clientAdjID, serverNodeIDs := range topology.Adjacency { if clientAdjID == originAdjID { continue } if !serverNodeIDs.Contains(originID) { continue } clientNodeID, ok := report.ParseAdjacencyID(clientAdjID) if !ok { continue } remote, ok := labeler(clientNodeID) if !ok { continue } rows = append(rows, Row{ Key: remote, ValueMajor: local, Expandable: true, }) } return rows }
func connectionDetailsRows(endpointTopology report.Topology, originID string, nmd report.NodeMetadata) []Row { rows := []Row{} local := fmt.Sprintf("%s:%s", nmd.Metadata[endpoint.Addr], nmd.Metadata[endpoint.Port]) adjacencies := endpointTopology.Adjacency[report.MakeAdjacencyID(originID)] sort.Strings(adjacencies) for _, adj := range adjacencies { if _, address, port, ok := report.ParseEndpointNodeID(adj); ok { rows = append(rows, Row{ Key: local, ValueMajor: fmt.Sprintf("%s:%s", address, port), }) } } return rows }
func TestSpyNoProcesses(t *testing.T) { procspy.SetFixtures(fixConnections) const ( nodeID = "heinz-tomato-ketchup" // TODO rename to hostID nodeName = "frenchs-since-1904" // TODO rename to hostNmae ) reporter := endpoint.NewReporter(nodeID, nodeName, false) r, _ := reporter.Report() //buf, _ := json.MarshalIndent(r, "", " ") //t.Logf("\n%s\n", buf) // No process nodes, please if want, have := 0, len(r.Endpoint.Adjacency); want != have { t.Fatalf("want %d, have %d", want, have) } var ( scopedLocal = report.MakeAddressNodeID(nodeID, fixLocalAddress.String()) scopedRemote = report.MakeAddressNodeID(nodeID, fixRemoteAddress.String()) localKey = report.MakeAdjacencyID(scopedLocal) ) if want, have := 1, len(r.Address.Adjacency[localKey]); want != have { t.Fatalf("want %d, have %d", want, have) } if want, have := scopedRemote, r.Address.Adjacency[localKey][0]; want != have { t.Fatalf("want %q, have %q", want, have) } if want, have := nodeName, r.Address.NodeMetadatas[scopedLocal].Metadata[docker.Name]; want != have { t.Fatalf("want %q, have %q", want, have) } }
ClientContainerImageID = "imageid123" ServerContainerImageID = "imageid456" ClientContainerImageNodeID = report.MakeContainerNodeID(ClientHostID, ClientContainerImageID) ServerContainerImageNodeID = report.MakeContainerNodeID(ServerHostID, ServerContainerImageID) ClientAddressNodeID = report.MakeAddressNodeID(ClientHostID, "10.10.10.20") ServerAddressNodeID = report.MakeAddressNodeID(ServerHostID, "192.168.1.1") UnknownAddress1NodeID = report.MakeAddressNodeID(ServerHostID, "10.10.10.10") UnknownAddress2NodeID = report.MakeAddressNodeID(ServerHostID, "10.10.10.11") RandomAddressNodeID = report.MakeAddressNodeID(ServerHostID, "51.52.53.54") // this should become an internet node Report = report.Report{ Endpoint: report.Topology{ Adjacency: report.Adjacency{ report.MakeAdjacencyID(Client54001NodeID): report.MakeIDList(Server80NodeID), report.MakeAdjacencyID(Client54002NodeID): report.MakeIDList(Server80NodeID), report.MakeAdjacencyID(Server80NodeID): report.MakeIDList( Client54001NodeID, Client54002NodeID, UnknownClient1NodeID, UnknownClient2NodeID, UnknownClient3NodeID, RandomClientNodeID), }, NodeMetadatas: report.NodeMetadatas{ // NodeMetadata is arbitrary. We're free to put only precisely what we // care to test into the fixture. Just be sure to include the bits // that the mapping funcs extract :) Client54001NodeID: report.NodeMetadata{ "addr": ClientIP, "port": ClientPort54001, "pid": ClientPID, report.HostNodeID: ClientHostNodeID, },
func TestMerge(t *testing.T) { var ( hostID = "xyz" src = newMockSource([]byte{}, nil) on = time.Millisecond off = time.Millisecond rpt = report.MakeReport() p = sniff.Packet{ SrcIP: "1.0.0.0", SrcPort: "1000", DstIP: "2.0.0.0", DstPort: "2000", Network: 512, Transport: 256, } _, ipnet, _ = net.ParseCIDR(p.SrcIP + "/24") // ;) localNets = report.Networks([]*net.IPNet{ipnet}) ) sniff.New(hostID, localNets, src, on, off).Merge(p, rpt) var ( srcEndpointNodeID = report.MakeEndpointNodeID(hostID, p.SrcIP, p.SrcPort) dstEndpointNodeID = report.MakeEndpointNodeID(hostID, p.DstIP, p.DstPort) ) if want, have := (report.Topology{ Adjacency: report.Adjacency{ report.MakeAdjacencyID(srcEndpointNodeID): report.MakeIDList( dstEndpointNodeID, ), }, EdgeMetadatas: report.EdgeMetadatas{ report.MakeEdgeID(srcEndpointNodeID, dstEndpointNodeID): report.EdgeMetadata{ EgressPacketCount: newu64(1), EgressByteCount: newu64(256), }, }, NodeMetadatas: report.NodeMetadatas{ srcEndpointNodeID: report.MakeNodeMetadata(), }, }), rpt.Endpoint; !reflect.DeepEqual(want, have) { t.Errorf("%s", test.Diff(want, have)) } var ( srcAddressNodeID = report.MakeAddressNodeID(hostID, p.SrcIP) dstAddressNodeID = report.MakeAddressNodeID(hostID, p.DstIP) ) if want, have := (report.Topology{ Adjacency: report.Adjacency{ report.MakeAdjacencyID(srcAddressNodeID): report.MakeIDList( dstAddressNodeID, ), }, EdgeMetadatas: report.EdgeMetadatas{ report.MakeEdgeID(srcAddressNodeID, dstAddressNodeID): report.EdgeMetadata{ EgressPacketCount: newu64(1), EgressByteCount: newu64(512), }, }, NodeMetadatas: report.NodeMetadatas{ srcAddressNodeID: report.MakeNodeMetadata(), }, }), rpt.Address; !reflect.DeepEqual(want, have) { t.Errorf("%s", test.Diff(want, have)) } }
func demoReport(nodeCount int) report.Report { r := report.MakeReport() // Make up some plausible IPv4 numbers. hosts := []string{} ip := [4]int{192, 168, 1, 1} for range make([]struct{}, nodeCount) { hosts = append(hosts, fmt.Sprintf("%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3])) ip[3]++ if ip[3] > 200 { ip[2]++ ip[3] = 1 } } hosts = append(hosts, []string{"1.2.3.4", "2.3.4.5"}...) // Some non-local ones, too. _, localNet, err := net.ParseCIDR("192.168.0.0/16") if err != nil { panic(err) } type conn struct { srcProc, dstProc string dstPort int } procPool := []conn{ {srcProc: "curl", dstPort: 80, dstProc: "apache"}, {srcProc: "wget", dstPort: 80, dstProc: "apache"}, {srcProc: "curl", dstPort: 80, dstProc: "nginx"}, {srcProc: "curl", dstPort: 8080, dstProc: "app1"}, {srcProc: "nginx", dstPort: 8080, dstProc: "app1"}, {srcProc: "nginx", dstPort: 8080, dstProc: "app2"}, {srcProc: "nginx", dstPort: 8080, dstProc: "app3"}, } connectionCount := nodeCount * 2 for i := 0; i < connectionCount; i++ { var ( c = procPool[rand.Intn(len(procPool))] src = hosts[rand.Intn(len(hosts))] dst = hosts[rand.Intn(len(hosts))] srcPort = rand.Intn(50000) + 10000 srcPortID = report.MakeEndpointNodeID("", src, strconv.Itoa(srcPort)) dstPortID = report.MakeEndpointNodeID("", dst, strconv.Itoa(c.dstPort)) srcID = report.MakeAdjacencyID(srcPortID) dstID = report.MakeAdjacencyID(dstPortID) srcAddressID = report.MakeAddressNodeID("", src) dstAddressID = report.MakeAddressNodeID("", dst) nodeSrcAddressID = report.MakeAdjacencyID(srcAddressID) nodeDstAddressID = report.MakeAdjacencyID(dstAddressID) ) // Endpoint topology if _, ok := r.Endpoint.NodeMetadatas[srcPortID]; !ok { r.Endpoint.NodeMetadatas[srcPortID] = report.MakeNodeMetadataWith(map[string]string{ process.PID: "4000", "name": c.srcProc, "domain": "node-" + src, }) } r.Endpoint.Adjacency[srcID] = r.Endpoint.Adjacency[srcID].Add(dstPortID) if _, ok := r.Endpoint.NodeMetadatas[dstPortID]; !ok { r.Endpoint.NodeMetadatas[dstPortID] = report.MakeNodeMetadataWith(map[string]string{ process.PID: "4000", "name": c.dstProc, "domain": "node-" + dst, }) } r.Endpoint.Adjacency[dstID] = r.Endpoint.Adjacency[dstID].Add(srcPortID) var ( edgeKeyEgress = report.MakeEdgeID(srcPortID, dstPortID) edgeKeyIngress = report.MakeEdgeID(dstPortID, srcPortID) ) r.Endpoint.EdgeMetadatas[edgeKeyEgress] = report.EdgeMetadata{ MaxConnCountTCP: newu64(uint64(rand.Intn(100) + 10)), } r.Endpoint.EdgeMetadatas[edgeKeyIngress] = report.EdgeMetadata{ MaxConnCountTCP: newu64(uint64(rand.Intn(100) + 10)), } // Address topology if _, ok := r.Address.NodeMetadatas[srcAddressID]; !ok { r.Address.NodeMetadatas[srcAddressID] = report.MakeNodeMetadataWith(map[string]string{ docker.Name: src, }) } r.Address.Adjacency[nodeSrcAddressID] = r.Address.Adjacency[nodeSrcAddressID].Add(dstAddressID) if _, ok := r.Address.NodeMetadatas[dstAddressID]; !ok { r.Address.NodeMetadatas[dstAddressID] = report.MakeNodeMetadataWith(map[string]string{ docker.Name: dst, }) } r.Address.Adjacency[nodeDstAddressID] = r.Address.Adjacency[nodeDstAddressID].Add(srcAddressID) // Host data r.Host.NodeMetadatas["hostX"] = report.MakeNodeMetadataWith(map[string]string{ "ts": time.Now().UTC().Format(time.RFC3339Nano), "host_name": "host-x", "local_networks": localNet.String(), "os": "linux", }) } return r }
func (r *Reporter) addConnection(rpt *report.Report, localAddr, remoteAddr string, localPort, remotePort uint16, proc *procspy.Proc) { localIsClient := int(localPort) > int(remotePort) // Update address topology { var ( localAddressNodeID = report.MakeAddressNodeID(r.hostID, localAddr) remoteAddressNodeID = report.MakeAddressNodeID(r.hostID, remoteAddr) adjacencyID = "" edgeID = "" ) if localIsClient { adjacencyID = report.MakeAdjacencyID(localAddressNodeID) rpt.Address.Adjacency[adjacencyID] = rpt.Address.Adjacency[adjacencyID].Add(remoteAddressNodeID) edgeID = report.MakeEdgeID(localAddressNodeID, remoteAddressNodeID) } else { adjacencyID = report.MakeAdjacencyID(remoteAddressNodeID) rpt.Address.Adjacency[adjacencyID] = rpt.Address.Adjacency[adjacencyID].Add(localAddressNodeID) edgeID = report.MakeEdgeID(remoteAddressNodeID, localAddressNodeID) } countTCPConnection(rpt.Address.EdgeMetadatas, edgeID) if _, ok := rpt.Address.NodeMetadatas[localAddressNodeID]; !ok { rpt.Address.NodeMetadatas[localAddressNodeID] = report.MakeNodeMetadataWith(map[string]string{ "name": r.hostName, Addr: localAddr, }) } } // Update endpoint topology if r.includeProcesses { var ( localEndpointNodeID = report.MakeEndpointNodeID(r.hostID, localAddr, strconv.Itoa(int(localPort))) remoteEndpointNodeID = report.MakeEndpointNodeID(r.hostID, remoteAddr, strconv.Itoa(int(remotePort))) adjacencyID = "" edgeID = "" ) if localIsClient { adjacencyID = report.MakeAdjacencyID(localEndpointNodeID) rpt.Endpoint.Adjacency[adjacencyID] = rpt.Endpoint.Adjacency[adjacencyID].Add(remoteEndpointNodeID) edgeID = report.MakeEdgeID(localEndpointNodeID, remoteEndpointNodeID) } else { adjacencyID = report.MakeAdjacencyID(remoteEndpointNodeID) rpt.Endpoint.Adjacency[adjacencyID] = rpt.Endpoint.Adjacency[adjacencyID].Add(localEndpointNodeID) edgeID = report.MakeEdgeID(remoteEndpointNodeID, localEndpointNodeID) } countTCPConnection(rpt.Endpoint.EdgeMetadatas, edgeID) md, ok := rpt.Endpoint.NodeMetadatas[localEndpointNodeID] updated := !ok if !ok { md = report.MakeNodeMetadataWith(map[string]string{ Addr: localAddr, Port: strconv.Itoa(int(localPort)), }) } if proc != nil && proc.PID > 0 { pid := strconv.FormatUint(uint64(proc.PID), 10) updated = updated || md.Metadata[process.PID] != pid md.Metadata[process.PID] = pid } if updated { rpt.Endpoint.NodeMetadatas[localEndpointNodeID] = md } } }
ServerContainerImageID = "imageid456" ClientContainerImageNodeID = report.MakeContainerNodeID(ClientHostID, ClientContainerImageID) ServerContainerImageNodeID = report.MakeContainerNodeID(ServerHostID, ServerContainerImageID) ClientContainerImageName = "image/client" ServerContainerImageName = "image/server" ClientAddressNodeID = report.MakeAddressNodeID(ClientHostID, "10.10.10.20") ServerAddressNodeID = report.MakeAddressNodeID(ServerHostID, "192.168.1.1") UnknownAddress1NodeID = report.MakeAddressNodeID(ServerHostID, "10.10.10.10") UnknownAddress2NodeID = report.MakeAddressNodeID(ServerHostID, "10.10.10.11") RandomAddressNodeID = report.MakeAddressNodeID(ServerHostID, "51.52.53.54") // this should become an internet node Report = report.Report{ Endpoint: report.Topology{ Adjacency: report.Adjacency{ report.MakeAdjacencyID(Client54001NodeID): report.MakeIDList(Server80NodeID), report.MakeAdjacencyID(Client54002NodeID): report.MakeIDList(Server80NodeID), report.MakeAdjacencyID(UnknownClient1NodeID): report.MakeIDList(Server80NodeID), report.MakeAdjacencyID(UnknownClient2NodeID): report.MakeIDList(Server80NodeID), report.MakeAdjacencyID(UnknownClient3NodeID): report.MakeIDList(Server80NodeID), report.MakeAdjacencyID(RandomClientNodeID): report.MakeIDList(Server80NodeID), report.MakeAdjacencyID(NonContainerNodeID): report.MakeIDList(GoogleEndpointNodeID), }, NodeMetadatas: report.NodeMetadatas{ // NodeMetadata is arbitrary. We're free to put only precisely what we // care to test into the fixture. Just be sure to include the bits // that the mapping funcs extract :) Client54001NodeID: report.MakeNodeMetadataWith(map[string]string{ endpoint.Addr: ClientIP, endpoint.Port: ClientPort54001, process.PID: Client1PID,