From 1edeb8d190b2a630bd7b944e72c24a38107028e5 Mon Sep 17 00:00:00 2001 From: Paul Bellamy Date: Tue, 19 Apr 2016 16:48:03 +0100 Subject: [PATCH] Removing report.Node.WithID (#1315) * removing usage of report.Node.WithID * report.Topology.AddNode can use the node's ID field --- app/collector_test.go | 6 +- experimental/demoprobe/main.go | 14 +- experimental/genreport/generate.go | 14 +- experimental/sniff/sniffer.go | 4 +- experimental/sniff/sniffer_internal_test.go | 2 +- experimental/sniff/sniffer_test.go | 8 +- probe/docker/container.go | 2 +- probe/docker/container_test.go | 13 +- probe/docker/env_test.go | 2 +- probe/docker/labels_test.go | 2 +- probe/docker/registry_test.go | 2 +- probe/docker/reporter.go | 11 +- probe/docker/tagger.go | 3 +- probe/docker/tagger_test.go | 4 +- probe/endpoint/nat.go | 3 +- probe/endpoint/nat_internal_test.go | 9 +- probe/endpoint/reporter.go | 34 ++-- probe/host/reporter.go | 2 +- probe/host/tagger.go | 4 +- probe/host/tagger_test.go | 4 +- probe/kubernetes/pod.go | 2 +- probe/kubernetes/reporter.go | 9 +- probe/kubernetes/service.go | 2 +- probe/overlay/weave.go | 6 +- probe/overlay/weave_test.go | 2 +- probe/probe_internal_test.go | 10 +- probe/process/reporter.go | 4 +- probe/topology_tagger.go | 4 +- render/detailed/docker_labels_test.go | 6 +- render/detailed/metadata_test.go | 6 +- render/detailed/metrics_test.go | 2 +- render/expected/expected.go | 2 +- render/filters_test.go | 36 ++-- render/mapping_test.go | 6 +- render/memoise_test.go | 2 +- render/render_test.go | 28 +-- render/short_lived_connections_test.go | 30 ++-- render/theinternet_test.go | 6 +- report/node.go | 14 +- report/node_set_test.go | 102 +++++------ report/node_test.go | 34 ++-- report/report_test.go | 9 +- report/topology.go | 6 +- report/topology_test.go | 2 +- test/fixture/report_fixture.go | 187 +++++++++++--------- 45 files changed, 349 insertions(+), 311 deletions(-) diff --git a/app/collector_test.go b/app/collector_test.go index e21d39650..52566ea43 100644 --- a/app/collector_test.go +++ b/app/collector_test.go @@ -19,10 +19,10 @@ func TestCollector(t *testing.T) { c := app.NewCollector(window) r1 := report.MakeReport() - r1.Endpoint.AddNode("foo", report.MakeNode()) + r1.Endpoint.AddNode(report.MakeNode("foo")) r2 := report.MakeReport() - r2.Endpoint.AddNode("bar", report.MakeNode()) + r2.Endpoint.AddNode(report.MakeNode("foo")) have, err := c.Report(ctx) if err != nil { @@ -74,7 +74,7 @@ func TestCollectorExpire(t *testing.T) { // Now check an added report is returned r1 := report.MakeReport() - r1.Endpoint.AddNode("foo", report.MakeNode()) + r1.Endpoint.AddNode(report.MakeNode("foo")) c.Add(ctx, r1) have, err = c.Report(ctx) if err != nil { diff --git a/experimental/demoprobe/main.go b/experimental/demoprobe/main.go index 822a42135..264c36435 100644 --- a/experimental/demoprobe/main.go +++ b/experimental/demoprobe/main.go @@ -87,24 +87,28 @@ func demoReport(nodeCount int) report.Report { ) // Endpoint topology - r.Endpoint = r.Endpoint.AddNode(srcPortID, report.MakeNode().WithLatests(map[string]string{ + r.Endpoint = r.Endpoint.AddNode(report.MakeNodeWith(srcPortID, map[string]string{ process.PID: "4000", "name": c.srcProc, "domain": "node-" + src, - }).WithEdge(dstPortID, report.EdgeMetadata{})) - r.Endpoint = r.Endpoint.AddNode(dstPortID, report.MakeNode().WithLatests(map[string]string{ + }). + WithEdge(dstPortID, report.EdgeMetadata{})) + + r.Endpoint = r.Endpoint.AddNode(report.MakeNodeWith(dstPortID, map[string]string{ process.PID: "4000", "name": c.dstProc, "domain": "node-" + dst, - }).WithEdge(srcPortID, report.EdgeMetadata{})) + }). + WithEdge(srcPortID, report.EdgeMetadata{})) // Host data - r.Host = r.Host.AddNode("hostX", report.MakeNodeWith(map[string]string{ + r.Host = r.Host.AddNode(report.MakeNodeWith("hostX", map[string]string{ "ts": time.Now().UTC().Format(time.RFC3339Nano), "host_name": "host-x", "local_networks": localNet.String(), "os": "linux", })) + } return r diff --git a/experimental/genreport/generate.go b/experimental/genreport/generate.go index 6a5bc9401..dc48c1d19 100644 --- a/experimental/genreport/generate.go +++ b/experimental/genreport/generate.go @@ -62,24 +62,28 @@ func DemoReport(nodeCount int) report.Report { ) // Endpoint topology - r.Endpoint = r.Endpoint.AddNode(srcPortID, report.MakeNode().WithLatests(map[string]string{ + r.Endpoint = r.Endpoint.AddNode(report.MakeNodeWith(srcPortID, map[string]string{ "pid": "4000", "name": c.srcProc, "domain": "node-" + src, - }).WithEdge(dstPortID, report.EdgeMetadata{})) - r.Endpoint = r.Endpoint.AddNode(dstPortID, report.MakeNode().WithLatests(map[string]string{ + }). + WithEdge(dstPortID, report.EdgeMetadata{})) + + r.Endpoint = r.Endpoint.AddNode(report.MakeNodeWith(dstPortID, map[string]string{ "pid": "4000", "name": c.dstProc, "domain": "node-" + dst, - }).WithEdge(srcPortID, report.EdgeMetadata{})) + }). + WithEdge(srcPortID, report.EdgeMetadata{})) // Host data - r.Host = r.Host.AddNode("hostX", report.MakeNodeWith(map[string]string{ + r.Host = r.Host.AddNode(report.MakeNodeWith("hostX", map[string]string{ "ts": time.Now().UTC().Format(time.RFC3339Nano), "host_name": "host-x", "local_networks": localNet.String(), "os": "linux", })) + } return r diff --git a/experimental/sniff/sniffer.go b/experimental/sniff/sniffer.go index 4c6446a8a..8846ffd74 100644 --- a/experimental/sniff/sniffer.go +++ b/experimental/sniff/sniffer.go @@ -292,8 +292,8 @@ func (s *Sniffer) Merge(p Packet, rpt *report.Report) { } addAdjacency := func(t report.Topology, srcNodeID, dstNodeID string) report.Topology { - result := t.AddNode(srcNodeID, report.MakeNode().WithAdjacent(dstNodeID)) - result = result.AddNode(dstNodeID, report.MakeNode()) + result := t.AddNode(report.MakeNode(srcNodeID).WithAdjacent(dstNodeID)) + result = result.AddNode(report.MakeNode(dstNodeID)) return result } diff --git a/experimental/sniff/sniffer_internal_test.go b/experimental/sniff/sniffer_internal_test.go index 89e9841e9..ce2dcbc0d 100644 --- a/experimental/sniff/sniffer_internal_test.go +++ b/experimental/sniff/sniffer_internal_test.go @@ -20,7 +20,7 @@ func TestInterpolateCounts(t *testing.T) { r := report.MakeReport() r.Sampling.Count = samplingCount r.Sampling.Total = samplingTotal - r.Endpoint.AddNode(srcNodeID, report.MakeNode().WithEdge(dstNodeID, report.EdgeMetadata{ + r.Endpoint.AddNode(report.MakeNode(srcNodeID).WithEdge(dstNodeID, report.EdgeMetadata{ EgressPacketCount: newu64(packetCount), IngressPacketCount: newu64(packetCount), EgressByteCount: newu64(byteCount), diff --git a/experimental/sniff/sniffer_test.go b/experimental/sniff/sniffer_test.go index 0dcbe706d..b7948962b 100644 --- a/experimental/sniff/sniffer_test.go +++ b/experimental/sniff/sniffer_test.go @@ -66,11 +66,11 @@ func TestMerge(t *testing.T) { ) if want, have := (report.Topology{ Nodes: report.Nodes{ - srcEndpointNodeID: report.MakeNode().WithEdge(dstEndpointNodeID, report.EdgeMetadata{ + srcEndpointNodeID: report.MakeNode(srcEndpointNodeID).WithEdge(dstEndpointNodeID, report.EdgeMetadata{ EgressPacketCount: newu64(1), EgressByteCount: newu64(256), }), - dstEndpointNodeID: report.MakeNode(), + dstEndpointNodeID: report.MakeNode(dstEndpointNodeID), }, }), rpt.Endpoint; !reflect.DeepEqual(want, have) { t.Errorf("%s", test.Diff(want, have)) @@ -82,11 +82,11 @@ func TestMerge(t *testing.T) { ) if want, have := (report.Topology{ Nodes: report.Nodes{ - srcAddressNodeID: report.MakeNode().WithEdge(dstAddressNodeID, report.EdgeMetadata{ + srcAddressNodeID: report.MakeNode(srcAddressNodeID).WithEdge(dstAddressNodeID, report.EdgeMetadata{ EgressPacketCount: newu64(1), EgressByteCount: newu64(512), }), - dstAddressNodeID: report.MakeNode(), + dstAddressNodeID: report.MakeNode(dstAddressNodeID), }, }), rpt.Address; !reflect.DeepEqual(want, have) { t.Errorf("%s", test.Diff(want, have)) diff --git a/probe/docker/container.go b/probe/docker/container.go index 86bf81aed..46e6849db 100644 --- a/probe/docker/container.go +++ b/probe/docker/container.go @@ -337,7 +337,7 @@ func (c *container) GetNode(hostID string, localAddrs []net.IP) report.Node { ipsWithScopes = append(ipsWithScopes, report.MakeScopedAddressNodeID(hostID, ip)) } - result := report.MakeNodeWith(map[string]string{ + result := report.MakeNodeWith(report.MakeContainerNodeID(c.ID()), map[string]string{ ContainerID: c.ID(), ContainerName: strings.TrimPrefix(c.container.Name, "/"), ContainerCreated: c.container.Created.Format(time.RFC822), diff --git a/probe/docker/container_test.go b/probe/docker/container_test.go index 51665a0a5..ec4d427ed 100644 --- a/probe/docker/container_test.go +++ b/probe/docker/container_test.go @@ -74,7 +74,7 @@ func TestContainer(t *testing.T) { // Now see if we go them uptime := (now.Sub(startTime) / time.Second) * time.Second - want := report.MakeNode().WithLatests(map[string]string{ + want := report.MakeNodeWith("ping;", map[string]string{ "docker_container_command": " ", "docker_container_created": "01 Jan 01 00:00 UTC", "docker_container_id": "ping", @@ -85,11 +85,12 @@ func TestContainer(t *testing.T) { "docker_container_state": "running", "docker_container_state_human": "Up 6 years", "docker_container_uptime": uptime.String(), - }).WithSets(report.EmptySets. - Add("docker_container_ports", report.MakeStringSet("1.2.3.4:80->80/tcp", "81/tcp")). - Add("docker_container_ips", report.MakeStringSet("1.2.3.4")). - Add("docker_container_ips_with_scopes", report.MakeStringSet("scope;1.2.3.4")), - ).WithControls( + }). + WithSets(report.EmptySets. + Add("docker_container_ports", report.MakeStringSet("1.2.3.4:80->80/tcp", "81/tcp")). + Add("docker_container_ips", report.MakeStringSet("1.2.3.4")). + Add("docker_container_ips_with_scopes", report.MakeStringSet("scope;1.2.3.4")), + ).WithControls( docker.RestartContainer, docker.StopContainer, docker.PauseContainer, docker.AttachContainer, docker.ExecContainer, ).WithMetrics(report.Metrics{ diff --git a/probe/docker/env_test.go b/probe/docker/env_test.go index 5897f256a..64c68dad6 100644 --- a/probe/docker/env_test.go +++ b/probe/docker/env_test.go @@ -15,7 +15,7 @@ func TestEnv(t *testing.T) { "FOO1=\"foo=bar\"", "FOO2", } - nmd := report.MakeNode() + nmd := report.MakeNode("foo") nmd = docker.AddEnv(nmd, given) have := docker.ExtractEnv(nmd) diff --git a/probe/docker/labels_test.go b/probe/docker/labels_test.go index 199dd2bba..6db8fdfc0 100644 --- a/probe/docker/labels_test.go +++ b/probe/docker/labels_test.go @@ -14,7 +14,7 @@ func TestLabels(t *testing.T) { "foo1": "bar1", "foo2": "bar2", } - nmd := report.MakeNode() + nmd := report.MakeNode("foo1") nmd = docker.AddLabels(nmd, want) have := docker.ExtractLabels(nmd) diff --git a/probe/docker/registry_test.go b/probe/docker/registry_test.go index fefb412d8..0bfa35f11 100644 --- a/probe/docker/registry_test.go +++ b/probe/docker/registry_test.go @@ -53,7 +53,7 @@ func (c *mockContainer) StartGatheringStats() error { func (c *mockContainer) StopGatheringStats() {} func (c *mockContainer) GetNode(_ string, _ []net.IP) report.Node { - return report.MakeNodeWith(map[string]string{ + return report.MakeNodeWith(report.MakeContainerNodeID(c.c.ID), map[string]string{ docker.ContainerID: c.c.ID, docker.ContainerName: c.c.Name, docker.ImageID: c.c.Image, diff --git a/probe/docker/reporter.go b/probe/docker/reporter.go index 872e0f5e2..facbb6673 100644 --- a/probe/docker/reporter.go +++ b/probe/docker/reporter.go @@ -76,7 +76,7 @@ func (r *Reporter) ContainerUpdated(c Container) { // Publish a 'short cut' report container just this container rpt := report.MakeReport() rpt.Shortcut = true - rpt.Container.AddNode(report.MakeContainerNodeID(c.ID()), c.GetNode(r.hostID, localAddrs)) + rpt.Container.AddNode(c.GetNode(r.hostID, localAddrs)) r.probe.Publish(rpt) } @@ -136,8 +136,7 @@ func (r *Reporter) containerTopology(localAddrs []net.IP) report.Topology { metadata := map[string]string{report.ControlProbeID: r.probeID} r.registry.WalkContainers(func(c Container) { - nodeID := report.MakeContainerNodeID(c.ID()) - result.AddNode(nodeID, c.GetNode(r.hostID, localAddrs).WithLatests(metadata)) + result.AddNode(c.GetNode(r.hostID, localAddrs).WithLatests(metadata)) }) return result @@ -148,7 +147,8 @@ func (r *Reporter) containerImageTopology() report.Topology { r.registry.WalkImages(func(image *docker_client.APIImages) { imageID := trimImageID(image.ID) - node := report.MakeNodeWith(map[string]string{ + nodeID := report.MakeContainerImageNodeID(imageID) + node := report.MakeNodeWith(nodeID, map[string]string{ ImageID: imageID, }) node = AddLabels(node, image.Labels) @@ -157,8 +157,7 @@ func (r *Reporter) containerImageTopology() report.Topology { node = node.WithLatests(map[string]string{ImageName: image.RepoTags[0]}) } - nodeID := report.MakeContainerImageNodeID(imageID) - result.AddNode(nodeID, node) + result.AddNode(node) }) return result diff --git a/probe/docker/tagger.go b/probe/docker/tagger.go index d238a0195..4dbb66d9d 100644 --- a/probe/docker/tagger.go +++ b/probe/docker/tagger.go @@ -82,11 +82,12 @@ func (t *Tagger) tag(tree process.Tree, topology *report.Topology) { continue } - topology.AddNode(nodeID, report.MakeNodeWith(map[string]string{ + topology.AddNode(report.MakeNodeWith(nodeID, map[string]string{ ContainerID: c.ID(), }).WithParents(report.EmptySets. Add(report.Container, report.MakeStringSet(report.MakeContainerNodeID(c.ID()))). Add(report.ContainerImage, report.MakeStringSet(report.MakeContainerImageNodeID(c.Image()))), )) + } } diff --git a/probe/docker/tagger_test.go b/probe/docker/tagger_test.go index b414234b5..068d65200 100644 --- a/probe/docker/tagger_test.go +++ b/probe/docker/tagger_test.go @@ -44,8 +44,8 @@ func TestTagger(t *testing.T) { ) input := report.MakeReport() - input.Process.AddNode(pid1NodeID, report.MakeNodeWith(map[string]string{process.PID: "2"})) - input.Process.AddNode(pid2NodeID, report.MakeNodeWith(map[string]string{process.PID: "3"})) + input.Process.AddNode(report.MakeNodeWith(pid1NodeID, map[string]string{process.PID: "2"})) + input.Process.AddNode(report.MakeNodeWith(pid2NodeID, map[string]string{process.PID: "3"})) have, err := docker.NewTagger(mockRegistryInstance, nil).Tag(input) if err != nil { diff --git a/probe/endpoint/nat.go b/probe/endpoint/nat.go index 5f4f30eff..b779b21cd 100644 --- a/probe/endpoint/nat.go +++ b/probe/endpoint/nat.go @@ -61,10 +61,11 @@ func (n natMapper) applyNAT(rpt report.Report, scope string) { return } - rpt.Endpoint.AddNode(copyEndpointID, node.WithLatests(map[string]string{ + rpt.Endpoint.AddNode(node.WithID(copyEndpointID).WithLatests(map[string]string{ Addr: mapping.rewrittenIP, Port: copyEndpointPort, "copy_of": realEndpointID, })) + }) } diff --git a/probe/endpoint/nat_internal_test.go b/probe/endpoint/nat_internal_test.go index 57994049c..db4c0f578 100644 --- a/probe/endpoint/nat_internal_test.go +++ b/probe/endpoint/nat_internal_test.go @@ -44,14 +44,15 @@ func TestNat(t *testing.T) { have := report.MakeReport() originalID := report.MakeEndpointNodeID("host1", "10.0.47.1", "80") - have.Endpoint.AddNode(originalID, report.MakeNodeWith(map[string]string{ + have.Endpoint.AddNode(report.MakeNodeWith(originalID, map[string]string{ Addr: "10.0.47.1", Port: "80", "foo": "bar", })) want := have.Copy() - want.Endpoint.AddNode(report.MakeEndpointNodeID("host1", "1.2.3.4", "80"), report.MakeNodeWith(map[string]string{ + wantID := report.MakeEndpointNodeID("host1", "1.2.3.4", "80") + want.Endpoint.AddNode(report.MakeNodeWith(wantID, map[string]string{ Addr: "1.2.3.4", Port: "80", "copy_of": originalID, @@ -76,14 +77,14 @@ func TestNat(t *testing.T) { have := report.MakeReport() originalID := report.MakeEndpointNodeID("host2", "10.0.47.2", "22222") - have.Endpoint.AddNode(originalID, report.MakeNodeWith(map[string]string{ + have.Endpoint.AddNode(report.MakeNodeWith(originalID, map[string]string{ Addr: "10.0.47.2", Port: "22222", "foo": "baz", })) want := have.Copy() - want.Endpoint.AddNode(report.MakeEndpointNodeID("host2", "2.3.4.5", "22223"), report.MakeNodeWith(map[string]string{ + want.Endpoint.AddNode(report.MakeNodeWith(report.MakeEndpointNodeID("host2", "2.3.4.5", "22223"), map[string]string{ Addr: "2.3.4.5", Port: "22223", "copy_of": originalID, diff --git a/probe/endpoint/reporter.go b/probe/endpoint/reporter.go index b326d87c1..c34ec1c21 100644 --- a/probe/endpoint/reporter.go +++ b/probe/endpoint/reporter.go @@ -107,9 +107,9 @@ func (r *Reporter) Report() (report.Report, error) { // Consult the flowWalker for short-live connections { - extraNodeInfo := report.MakeNode().WithLatests(map[string]string{ + extraNodeInfo := map[string]string{ Conntracked: "true", - }) + } r.flowWalker.walkFlows(func(f flow) { tuple := fourTuple{ f.Original.Layer3.SrcIP, @@ -118,7 +118,7 @@ func (r *Reporter) Report() (report.Report, error) { uint16(f.Original.Layer4.DstPort), } seenTuples[tuple.key()] = tuple - r.addConnection(&rpt, tuple, &extraNodeInfo, &extraNodeInfo) + r.addConnection(&rpt, tuple, extraNodeInfo, extraNodeInfo) }) } @@ -127,9 +127,6 @@ func (r *Reporter) Report() (report.Report, error) { if err != nil { return rpt, err } - extraNodeInfo := report.MakeNode().WithLatests(map[string]string{ - Procspied: "true", - }) for conn := conns.Next(); conn != nil; conn = conns.Next() { var ( tuple = fourTuple{ @@ -138,13 +135,12 @@ func (r *Reporter) Report() (report.Report, error) { conn.LocalPort, conn.RemotePort, } - toNodeInfo, fromNodeInfo = extraNodeInfo.Copy(), extraNodeInfo.Copy() + toNodeInfo = map[string]string{Procspied: "true"} + fromNodeInfo = map[string]string{Procspied: "true"} ) if conn.Proc.PID > 0 { - fromNodeInfo = fromNodeInfo.WithLatests(map[string]string{ - process.PID: strconv.FormatUint(uint64(conn.Proc.PID), 10), - report.HostNodeID: hostNodeID, - }) + fromNodeInfo[process.PID] = strconv.FormatUint(uint64(conn.Proc.PID), 10) + fromNodeInfo[report.HostNodeID] = hostNodeID } // If we've already seen this connection, we should know the direction @@ -156,7 +152,7 @@ func (r *Reporter) Report() (report.Report, error) { tuple.reverse() toNodeInfo, fromNodeInfo = fromNodeInfo, toNodeInfo } - r.addConnection(&rpt, tuple, &fromNodeInfo, &toNodeInfo) + r.addConnection(&rpt, tuple, fromNodeInfo, toNodeInfo) } } @@ -164,7 +160,7 @@ func (r *Reporter) Report() (report.Report, error) { return rpt, nil } -func (r *Reporter) addConnection(rpt *report.Report, t fourTuple, extraFromNode, extraToNode *report.Node) { +func (r *Reporter) addConnection(rpt *report.Report, t fourTuple, extraFromNode, extraToNode map[string]string) { // Update endpoint topology if !r.includeProcesses { return @@ -173,11 +169,11 @@ func (r *Reporter) addConnection(rpt *report.Report, t fourTuple, extraFromNode, fromEndpointNodeID = report.MakeEndpointNodeID(r.hostID, t.fromAddr, strconv.Itoa(int(t.fromPort))) toEndpointNodeID = report.MakeEndpointNodeID(r.hostID, t.toAddr, strconv.Itoa(int(t.toPort))) - fromNode = report.MakeNodeWith(map[string]string{ + fromNode = report.MakeNodeWith(fromEndpointNodeID, map[string]string{ Addr: t.fromAddr, Port: strconv.Itoa(int(t.fromPort)), }).WithEdge(toEndpointNodeID, report.EdgeMetadata{}) - toNode = report.MakeNodeWith(map[string]string{ + toNode = report.MakeNodeWith(toEndpointNodeID, map[string]string{ Addr: t.toAddr, Port: strconv.Itoa(int(t.toPort)), }) @@ -190,13 +186,13 @@ func (r *Reporter) addConnection(rpt *report.Report, t fourTuple, extraFromNode, } if extraFromNode != nil { - fromNode = fromNode.Merge(*extraFromNode) + fromNode = fromNode.WithLatests(extraFromNode) } if extraToNode != nil { - toNode = toNode.Merge(*extraToNode) + toNode = toNode.WithLatests(extraToNode) } - rpt.Endpoint = rpt.Endpoint.AddNode(fromEndpointNodeID, fromNode) - rpt.Endpoint = rpt.Endpoint.AddNode(toEndpointNodeID, toNode) + rpt.Endpoint = rpt.Endpoint.AddNode(fromNode) + rpt.Endpoint = rpt.Endpoint.AddNode(toNode) } func newu64(i uint64) *uint64 { diff --git a/probe/host/reporter.go b/probe/host/reporter.go index 47413dfe4..d1a2074b8 100644 --- a/probe/host/reporter.go +++ b/probe/host/reporter.go @@ -126,7 +126,7 @@ func (r *Reporter) Report() (report.Report, error) { metrics[MemoryUsage] = report.MakeMetric().Add(now, memoryUsage).WithMax(max) metadata := map[string]string{report.ControlProbeID: r.probeID} - rep.Host.AddNode(report.MakeHostNodeID(r.hostID), report.MakeNodeWith(map[string]string{ + rep.Host.AddNode(report.MakeNodeWith(report.MakeHostNodeID(r.hostID), map[string]string{ Timestamp: mtime.Now().UTC().Format(time.RFC3339Nano), HostName: r.hostName, OS: runtime.GOOS, diff --git a/probe/host/tagger.go b/probe/host/tagger.go index de47bd3b3..dbdeefc8a 100644 --- a/probe/host/tagger.go +++ b/probe/host/tagger.go @@ -32,8 +32,8 @@ func (t Tagger) Tag(r report.Report) (report.Report, error) { // Explicitly don't tag Endpoints and Addresses - These topologies include pseudo nodes, // and as such do their own host tagging for _, topology := range []report.Topology{r.Process, r.Container, r.ContainerImage, r.Host, r.Overlay} { - for id, node := range topology.Nodes { - topology.AddNode(id, node.WithLatests(metadata).WithParents(parents)) + for _, node := range topology.Nodes { + topology.AddNode(node.WithLatests(metadata).WithParents(parents)) } } return r, nil diff --git a/probe/host/tagger_test.go b/probe/host/tagger_test.go index bc35b31e2..6001815e4 100644 --- a/probe/host/tagger_test.go +++ b/probe/host/tagger_test.go @@ -11,11 +11,11 @@ func TestTagger(t *testing.T) { var ( hostID = "foo" endpointNodeID = report.MakeEndpointNodeID(hostID, "1.2.3.4", "56789") // hostID ignored - node = report.MakeNodeWith(map[string]string{"foo": "bar"}) + node = report.MakeNodeWith(endpointNodeID, map[string]string{"foo": "bar"}) ) r := report.MakeReport() - r.Process.AddNode(endpointNodeID, node) + r.Process.AddNode(node) rpt, _ := host.NewTagger(hostID).Tag(r) have := rpt.Process.Nodes[endpointNodeID].Copy() diff --git a/probe/kubernetes/pod.go b/probe/kubernetes/pod.go index 6d3cf8719..81a98f041 100644 --- a/probe/kubernetes/pod.go +++ b/probe/kubernetes/pod.go @@ -79,7 +79,7 @@ func (p *pod) State() string { } func (p *pod) GetNode() report.Node { - n := report.MakeNodeWith(map[string]string{ + n := report.MakeNodeWith(report.MakePodNodeID(p.Namespace(), p.Name()), map[string]string{ PodID: p.ID(), PodName: p.Name(), Namespace: p.Namespace(), diff --git a/probe/kubernetes/reporter.go b/probe/kubernetes/reporter.go index 3ec474ef1..c195e2421 100644 --- a/probe/kubernetes/reporter.go +++ b/probe/kubernetes/reporter.go @@ -62,8 +62,7 @@ func (r *Reporter) serviceTopology() (report.Topology, []Service, error) { services = []Service{} ) err := r.client.WalkServices(func(s Service) error { - nodeID := report.MakeServiceNodeID(s.Namespace(), s.Name()) - result = result.AddNode(nodeID, s.GetNode()) + result = result.AddNode(s.GetNode()) services = append(services, s) return nil }) @@ -86,15 +85,15 @@ func (r *Reporter) podTopology(services []Service) (report.Topology, report.Topo } } nodeID := report.MakePodNodeID(p.Namespace(), p.Name()) - pods = pods.AddNode(nodeID, p.GetNode()) + pods = pods.AddNode(p.GetNode()) for _, containerID := range p.ContainerIDs() { - container := report.MakeNodeWith(map[string]string{ + container := report.MakeNodeWith(report.MakeContainerNodeID(containerID), map[string]string{ PodID: p.ID(), Namespace: p.Namespace(), docker.ContainerID: containerID, }).WithParents(report.EmptySets.Add(report.Pod, report.MakeStringSet(nodeID))) - containers.AddNode(report.MakeContainerNodeID(containerID), container) + containers.AddNode(container) } return nil }) diff --git a/probe/kubernetes/service.go b/probe/kubernetes/service.go index c1e345e2f..c1a73798b 100644 --- a/probe/kubernetes/service.go +++ b/probe/kubernetes/service.go @@ -54,7 +54,7 @@ func (s *service) Selector() labels.Selector { } func (s *service) GetNode() report.Node { - return report.MakeNodeWith(map[string]string{ + return report.MakeNodeWith(report.MakeServiceNodeID(s.Namespace(), s.Name()), map[string]string{ ServiceID: s.ID(), ServiceName: s.Name(), ServiceCreated: s.ObjectMeta.CreationTimestamp.Format(time.RFC822), diff --git a/probe/overlay/weave.go b/probe/overlay/weave.go index 0ca7689dd..3f27e85bd 100644 --- a/probe/overlay/weave.go +++ b/probe/overlay/weave.go @@ -174,15 +174,15 @@ func (w *Weave) Report() (report.Report, error) { WeaveDNSHostname: {ID: WeaveDNSHostname, Label: "Weave DNS Name", From: report.FromLatest, Priority: 18}, }) for _, peer := range w.statusCache.Router.Peers { - r.Overlay.AddNode(report.MakeOverlayNodeID(peer.Name), report.MakeNodeWith(map[string]string{ + r.Overlay.AddNode(report.MakeNodeWith(report.MakeOverlayNodeID(peer.Name), map[string]string{ WeavePeerName: peer.Name, WeavePeerNickName: peer.NickName, })) + } if w.statusCache.IPAM.DefaultSubnet != "" { r.Overlay.AddNode( - report.MakeOverlayNodeID(w.statusCache.Router.Name), - report.MakeNode().WithSets( + report.MakeNode(report.MakeOverlayNodeID(w.statusCache.Router.Name)).WithSets( report.MakeSets().Add(host.LocalNetworks, report.MakeStringSet(w.statusCache.IPAM.DefaultSubnet)), ), ) diff --git a/probe/overlay/weave_test.go b/probe/overlay/weave_test.go index edd3ead96..fc7161c5b 100644 --- a/probe/overlay/weave_test.go +++ b/probe/overlay/weave_test.go @@ -55,7 +55,7 @@ func TestWeaveTaggerOverlayTopology(t *testing.T) { // Container nodes should be tagged with their overlay info nodeID := report.MakeContainerNodeID(weave.MockContainerID) have, err := w.Tag(report.Report{ - Container: report.MakeTopology().AddNode(nodeID, report.MakeNodeWith(map[string]string{ + Container: report.MakeTopology().AddNode(report.MakeNodeWith(nodeID, map[string]string{ docker.ContainerID: weave.MockContainerID, })), }) diff --git a/probe/probe_internal_test.go b/probe/probe_internal_test.go index d19a1bdb5..ac1d8c7f4 100644 --- a/probe/probe_internal_test.go +++ b/probe/probe_internal_test.go @@ -16,14 +16,14 @@ import ( func TestApply(t *testing.T) { var ( endpointNodeID = "c" - endpointNode = report.MakeNodeWith(map[string]string{"5": "6"}) + endpointNode = report.MakeNodeWith(endpointNodeID, map[string]string{"5": "6"}) ) p := New("", 0, 0, nil) p.AddTagger(NewTopologyTagger()) r := report.MakeReport() - r.Endpoint.AddNode(endpointNodeID, endpointNode) + r.Endpoint.AddNode(endpointNode) r = p.tag(r) for _, tuple := range []struct { @@ -31,7 +31,7 @@ func TestApply(t *testing.T) { from report.Topology via string }{ - {endpointNode.Merge(report.MakeNode().WithID("c").WithTopology(report.Endpoint)), r.Endpoint, endpointNodeID}, + {endpointNode.Merge(report.MakeNode("c").WithTopology(report.Endpoint)), r.Endpoint, endpointNodeID}, } { if want, have := tuple.want, tuple.from.Nodes[tuple.via]; !reflect.DeepEqual(want, have) { t.Errorf("want %+v, have %+v", want, have) @@ -78,9 +78,9 @@ func TestProbe(t *testing.T) { defer mtime.NowReset() want := report.MakeReport() - node := report.MakeNodeWith(map[string]string{"b": "c"}) + node := report.MakeNodeWith("a", map[string]string{"b": "c"}) node.Metrics = nil // omitempty - want.Endpoint.AddNode("a", node) + want.Endpoint.AddNode(node) want.Probes[probeID] = report.Probe{ ID: probeID, LastSeen: now, diff --git a/probe/process/reporter.go b/probe/process/reporter.go index f86da068f..9087fb150 100644 --- a/probe/process/reporter.go +++ b/probe/process/reporter.go @@ -81,7 +81,7 @@ func (r *Reporter) processTopology() (report.Topology, error) { err = r.walker.Walk(func(p, prev Process) { pidstr := strconv.Itoa(p.PID) nodeID := report.MakeProcessNodeID(r.scope, pidstr) - node := report.MakeNode() + node := report.MakeNode(nodeID) for _, tuple := range []struct{ key, value string }{ {PID, pidstr}, {Name, p.Name}, @@ -105,7 +105,7 @@ func (r *Reporter) processTopology() (report.Topology, error) { node = node.WithMetric(MemoryUsage, report.MakeMetric().Add(now, float64(p.RSSBytes)).WithMax(float64(p.RSSBytesLimit))) node = node.WithMetric(OpenFilesCount, report.MakeMetric().Add(now, float64(p.OpenFilesCount)).WithMax(float64(p.OpenFilesLimit))) - t.AddNode(nodeID, node) + t.AddNode(node) }) return t, err diff --git a/probe/topology_tagger.go b/probe/topology_tagger.go index 44cda37cc..354913387 100644 --- a/probe/topology_tagger.go +++ b/probe/topology_tagger.go @@ -26,8 +26,8 @@ func (topologyTagger) Tag(r report.Report) (report.Report, error) { report.Host: &(r.Host), report.Overlay: &(r.Overlay), } { - for id, node := range t.Nodes { - t.AddNode(id, node.WithID(id).WithTopology(name)) + for _, node := range t.Nodes { + t.AddNode(node.WithTopology(name)) } } return r, nil diff --git a/render/detailed/docker_labels_test.go b/render/detailed/docker_labels_test.go index 5c94d2cdc..8b8049f08 100644 --- a/render/detailed/docker_labels_test.go +++ b/render/detailed/docker_labels_test.go @@ -19,7 +19,7 @@ func TestNodeDockerLabels(t *testing.T) { }{ { name: "container", - node: report.MakeNodeWith(map[string]string{ + node: report.MakeNodeWith(fixture.ClientContainerNodeID, map[string]string{ docker.ContainerID: fixture.ClientContainerID, docker.LabelPrefix + "label1": "label1value", docker.ContainerState: docker.StateRunning, @@ -36,9 +36,9 @@ func TestNodeDockerLabels(t *testing.T) { }, { name: "unknown topology", - node: report.MakeNodeWith(map[string]string{ + node: report.MakeNodeWith(fixture.ClientContainerNodeID, map[string]string{ docker.ContainerID: fixture.ClientContainerID, - }).WithTopology("foobar").WithID(fixture.ClientContainerNodeID), + }).WithTopology("foobar"), want: nil, }, } diff --git a/render/detailed/metadata_test.go b/render/detailed/metadata_test.go index d70a746e2..21830cdd0 100644 --- a/render/detailed/metadata_test.go +++ b/render/detailed/metadata_test.go @@ -19,7 +19,7 @@ func TestNodeMetadata(t *testing.T) { }{ { name: "container", - node: report.MakeNodeWith(map[string]string{ + node: report.MakeNodeWith(fixture.ClientContainerNodeID, map[string]string{ docker.ContainerID: fixture.ClientContainerID, docker.LabelPrefix + "label1": "label1value", docker.ContainerStateHuman: docker.StateRunning, @@ -34,9 +34,9 @@ func TestNodeMetadata(t *testing.T) { }, { name: "unknown topology", - node: report.MakeNodeWith(map[string]string{ + node: report.MakeNodeWith(fixture.ClientContainerNodeID, map[string]string{ docker.ContainerID: fixture.ClientContainerID, - }).WithTopology("foobar").WithID(fixture.ClientContainerNodeID), + }).WithTopology("foobar"), want: nil, }, } diff --git a/render/detailed/metrics_test.go b/render/detailed/metrics_test.go index 75b00a88a..c233ec4ee 100644 --- a/render/detailed/metrics_test.go +++ b/render/detailed/metrics_test.go @@ -102,7 +102,7 @@ func TestNodeMetrics(t *testing.T) { }, { name: "unknown topology", - node: report.MakeNode().WithTopology("foobar").WithID(fixture.ClientContainerNodeID), + node: report.MakeNode(fixture.ClientContainerNodeID).WithTopology("foobar"), want: nil, }, } diff --git a/render/expected/expected.go b/render/expected/expected.go index 07c934592..76be26811 100644 --- a/render/expected/expected.go +++ b/render/expected/expected.go @@ -20,7 +20,7 @@ var ( // Helper to make a report.node with some common options node = func(topology string) func(id string, adjacent ...string) report.Node { return func(id string, adjacent ...string) report.Node { - n := report.MakeNode().WithID(id).WithTopology(topology) + n := report.MakeNode(id).WithTopology(topology) for _, a := range adjacent { n = n.WithAdjacent(a) } diff --git a/render/filters_test.go b/render/filters_test.go index e67e5fe9a..1e36a6224 100644 --- a/render/filters_test.go +++ b/render/filters_test.go @@ -12,9 +12,9 @@ import ( func TestFilterRender(t *testing.T) { renderer := render.FilterUnconnected( mockRenderer{Nodes: report.Nodes{ - "foo": report.MakeNode().WithID("foo").WithAdjacent("bar"), - "bar": report.MakeNode().WithID("bar").WithAdjacent("foo"), - "baz": report.MakeNode().WithID("baz"), + "foo": report.MakeNode("foo").WithAdjacent("bar"), + "bar": report.MakeNode("bar").WithAdjacent("foo"), + "baz": report.MakeNode("baz"), }}) have := report.MakeIDList() @@ -34,9 +34,9 @@ func TestFilterRender2(t *testing.T) { return node.ID != "bar" }, Renderer: mockRenderer{Nodes: report.Nodes{ - "foo": report.MakeNode().WithID("foo").WithAdjacent("bar"), - "bar": report.MakeNode().WithID("bar").WithAdjacent("foo"), - "baz": report.MakeNode().WithID("baz"), + "foo": report.MakeNode("foo").WithAdjacent("bar"), + "bar": report.MakeNode("bar").WithAdjacent("foo"), + "baz": report.MakeNode("baz"), }}, } @@ -51,9 +51,9 @@ func TestFilterUnconnectedPseudoNodes(t *testing.T) { // are also removed. { nodes := report.Nodes{ - "foo": report.MakeNode().WithID("foo").WithAdjacent("bar"), - "bar": report.MakeNode().WithID("bar").WithAdjacent("baz"), - "baz": report.MakeNode().WithID("baz").WithTopology(render.Pseudo), + "foo": report.MakeNode("foo").WithAdjacent("bar"), + "bar": report.MakeNode("bar").WithAdjacent("baz"), + "baz": report.MakeNode("baz").WithTopology(render.Pseudo), } renderer := render.Filter{ FilterFunc: func(node report.Node) bool { @@ -73,9 +73,9 @@ func TestFilterUnconnectedPseudoNodes(t *testing.T) { return node.ID != "bar" }, Renderer: mockRenderer{Nodes: report.Nodes{ - "foo": report.MakeNode().WithID("foo").WithAdjacent("bar"), - "bar": report.MakeNode().WithID("bar").WithAdjacent("baz"), - "baz": report.MakeNode().WithID("baz").WithTopology(render.Pseudo), + "foo": report.MakeNode("foo").WithAdjacent("bar"), + "bar": report.MakeNode("bar").WithAdjacent("baz"), + "baz": report.MakeNode("baz").WithTopology(render.Pseudo), }}, } have := renderer.Render(report.MakeReport()) @@ -89,9 +89,9 @@ func TestFilterUnconnectedPseudoNodes(t *testing.T) { return node.ID != "bar" }, Renderer: mockRenderer{Nodes: report.Nodes{ - "foo": report.MakeNode().WithID("foo"), - "bar": report.MakeNode().WithID("bar").WithAdjacent("foo"), - "baz": report.MakeNode().WithID("baz").WithTopology(render.Pseudo).WithAdjacent("bar"), + "foo": report.MakeNode("foo"), + "bar": report.MakeNode("bar").WithAdjacent("foo"), + "baz": report.MakeNode("baz").WithTopology(render.Pseudo).WithAdjacent("bar"), }}, } have := renderer.Render(report.MakeReport()) @@ -105,7 +105,7 @@ func TestFilterUnconnectedSelf(t *testing.T) { // Test nodes that are only connected to themselves are filtered. { nodes := report.Nodes{ - "foo": report.MakeNode().WithID("foo").WithAdjacent("foo"), + "foo": report.MakeNode("foo").WithAdjacent("foo"), } renderer := render.FilterUnconnected(mockRenderer{Nodes: nodes}) have := renderer.Render(report.MakeReport()) @@ -119,8 +119,8 @@ func TestFilterPseudo(t *testing.T) { // Test pseudonodes are removed { nodes := report.Nodes{ - "foo": report.MakeNode().WithID("foo"), - "bar": report.MakeNode().WithID("bar").WithTopology(render.Pseudo), + "foo": report.MakeNode("foo"), + "bar": report.MakeNode("bar").WithTopology(render.Pseudo), } renderer := render.FilterPseudo(mockRenderer{Nodes: nodes}) have := renderer.Render(report.MakeReport()) diff --git a/render/mapping_test.go b/render/mapping_test.go index 93382cdbd..42d3f45b5 100644 --- a/render/mapping_test.go +++ b/render/mapping_test.go @@ -13,9 +13,9 @@ import ( func TestMapProcess2Container(t *testing.T) { for _, input := range []testcase{ - {"empty", report.MakeNode(), true}, - {"basic process", report.MakeNodeWith(map[string]string{process.PID: "201", docker.ContainerID: "a1b2c3"}), true}, - {"uncontained", report.MakeNodeWith(map[string]string{process.PID: "201", report.HostNodeID: report.MakeHostNodeID("foo")}), true}, + {"empty", report.MakeNode("empty"), true}, + {"basic process", report.MakeNodeWith("basic", map[string]string{process.PID: "201", docker.ContainerID: "a1b2c3"}), true}, + {"uncontained", report.MakeNodeWith("uncontained", map[string]string{process.PID: "201", report.HostNodeID: report.MakeHostNodeID("foo")}), true}, } { testMap(t, render.MapProcess2Container, input) } diff --git a/render/memoise_test.go b/render/memoise_test.go index d5f230f26..e6eac2682 100644 --- a/render/memoise_test.go +++ b/render/memoise_test.go @@ -18,7 +18,7 @@ func TestMemoise(t *testing.T) { calls := 0 r := renderFunc(func(rpt report.Report) report.Nodes { calls++ - return report.Nodes{rpt.ID: report.MakeNode().WithID(rpt.ID)} + return report.Nodes{rpt.ID: report.MakeNode(rpt.ID)} }) m := render.Memoise(r) rpt1 := report.MakeReport() diff --git a/render/render_test.go b/render/render_test.go index b05973ecc..f802d74e2 100644 --- a/render/render_test.go +++ b/render/render_test.go @@ -18,13 +18,13 @@ func (m mockRenderer) Stats(rpt report.Report) render.Stats { return render.Sta func TestReduceRender(t *testing.T) { renderer := render.Reduce([]render.Renderer{ - mockRenderer{Nodes: report.Nodes{"foo": report.MakeNode().WithID("foo")}}, - mockRenderer{Nodes: report.Nodes{"bar": report.MakeNode().WithID("bar")}}, + mockRenderer{Nodes: report.Nodes{"foo": report.MakeNode("foo")}}, + mockRenderer{Nodes: report.Nodes{"bar": report.MakeNode("bar")}}, }) want := report.Nodes{ - "foo": report.MakeNode().WithID("foo"), - "bar": report.MakeNode().WithID("bar"), + "foo": report.MakeNode("foo"), + "bar": report.MakeNode("bar"), } have := renderer.Render(report.MakeReport()) if !reflect.DeepEqual(want, have) { @@ -39,7 +39,7 @@ func TestMapRender1(t *testing.T) { return report.Nodes{} }, Renderer: mockRenderer{Nodes: report.Nodes{ - "foo": report.MakeNode().WithID("foo"), + "foo": report.MakeNode("foo"), }}, } want := report.Nodes{} @@ -54,16 +54,16 @@ func TestMapRender2(t *testing.T) { mapper := render.Map{ MapFunc: func(nodes report.Node, _ report.Networks) report.Nodes { return report.Nodes{ - "bar": report.MakeNode().WithID("bar"), + "bar": report.MakeNode("bar"), } }, Renderer: mockRenderer{Nodes: report.Nodes{ - "foo": report.MakeNode().WithID("foo"), - "baz": report.MakeNode().WithID("baz"), + "foo": report.MakeNode("foo"), + "baz": report.MakeNode("baz"), }}, } want := report.Nodes{ - "bar": report.MakeNode().WithID("bar"), + "bar": report.MakeNode("bar"), } have := mapper.Render(report.MakeReport()) if !reflect.DeepEqual(want, have) { @@ -76,16 +76,16 @@ func TestMapRender3(t *testing.T) { mapper := render.Map{ MapFunc: func(nodes report.Node, _ report.Networks) report.Nodes { id := "_" + nodes.ID - return report.Nodes{id: report.MakeNode().WithID(id)} + return report.Nodes{id: report.MakeNode(id)} }, Renderer: mockRenderer{Nodes: report.Nodes{ - "foo": report.MakeNode().WithID("foo").WithAdjacent("baz"), - "baz": report.MakeNode().WithID("baz").WithAdjacent("foo"), + "foo": report.MakeNode("foo").WithAdjacent("baz"), + "baz": report.MakeNode("baz").WithAdjacent("foo"), }}, } want := report.Nodes{ - "_foo": report.MakeNode().WithID("_foo").WithAdjacent("_baz"), - "_baz": report.MakeNode().WithID("_baz").WithAdjacent("_foo"), + "_foo": report.MakeNode("_foo").WithAdjacent("_baz"), + "_baz": report.MakeNode("_baz").WithAdjacent("_foo"), } have := mapper.Render(report.MakeReport()) if !reflect.DeepEqual(want, have) { diff --git a/render/short_lived_connections_test.go b/render/short_lived_connections_test.go index 47b42a6e8..99f1b60d0 100644 --- a/render/short_lived_connections_test.go +++ b/render/short_lived_connections_test.go @@ -31,38 +31,42 @@ var ( rpt = report.Report{ Endpoint: report.Topology{ Nodes: report.Nodes{ - randomEndpointNodeID: report.MakeNode().WithLatests(map[string]string{ + randomEndpointNodeID: report.MakeNodeWith(randomEndpointNodeID, map[string]string{ endpoint.Addr: randomIP, endpoint.Port: randomPort, endpoint.Conntracked: "true", - }).WithAdjacent(serverEndpointNodeID).WithID(randomEndpointNodeID).WithTopology(report.Endpoint), + }). + WithAdjacent(serverEndpointNodeID).WithTopology(report.Endpoint), - serverEndpointNodeID: report.MakeNode().WithLatests(map[string]string{ + serverEndpointNodeID: report.MakeNodeWith(serverEndpointNodeID, map[string]string{ endpoint.Addr: serverIP, endpoint.Port: serverPort, endpoint.Conntracked: "true", - }).WithID(serverEndpointNodeID).WithTopology(report.Endpoint), + }). + WithTopology(report.Endpoint), }, }, Container: report.Topology{ Nodes: report.Nodes{ - containerNodeID: report.MakeNode().WithLatests(map[string]string{ + containerNodeID: report.MakeNodeWith(containerNodeID, map[string]string{ docker.ContainerID: containerID, docker.ContainerName: containerName, report.HostNodeID: serverHostNodeID, - }).WithSets(report.EmptySets. - Add(docker.ContainerIPs, report.MakeStringSet(containerIP)). - Add(docker.ContainerPorts, report.MakeStringSet(fmt.Sprintf("%s:%s->%s/tcp", serverIP, serverPort, serverPort))), - ).WithID(containerNodeID).WithTopology(report.Container), + }). + WithSets(report.EmptySets. + Add(docker.ContainerIPs, report.MakeStringSet(containerIP)). + Add(docker.ContainerPorts, report.MakeStringSet(fmt.Sprintf("%s:%s->%s/tcp", serverIP, serverPort, serverPort))), + ).WithTopology(report.Container), }, }, Host: report.Topology{ Nodes: report.Nodes{ - serverHostNodeID: report.MakeNodeWith(map[string]string{ + serverHostNodeID: report.MakeNodeWith(serverHostNodeID, map[string]string{ report.HostNodeID: serverHostNodeID, - }).WithSets(report.EmptySets. - Add(host.LocalNetworks, report.MakeStringSet("192.168.0.0/16")), - ).WithID(serverHostNodeID).WithTopology(report.Host), + }). + WithSets(report.EmptySets. + Add(host.LocalNetworks, report.MakeStringSet("192.168.0.0/16")), + ).WithTopology(report.Host), }, }, } diff --git a/render/theinternet_test.go b/render/theinternet_test.go index 298832cd9..36c8147b6 100644 --- a/render/theinternet_test.go +++ b/render/theinternet_test.go @@ -15,8 +15,8 @@ func TestReportLocalNetworks(t *testing.T) { r := report.MakeReport().Merge(report.Report{ Host: report.Topology{ Nodes: report.Nodes{ - "nonets": report.MakeNode(), - "foo": report.MakeNode().WithSets(report.EmptySets. + "nonets": report.MakeNode("nonets"), + "foo": report.MakeNode("foo").WithSets(report.EmptySets. Add(host.LocalNetworks, report.MakeStringSet( "10.0.0.1/8", "192.168.1.1/24", "10.0.0.1/8", "badnet/33")), ), @@ -24,7 +24,7 @@ func TestReportLocalNetworks(t *testing.T) { }, Overlay: report.Topology{ Nodes: report.Nodes{ - "router": report.MakeNode().WithSets(report.EmptySets. + "router": report.MakeNode("router").WithSets(report.EmptySets. Add(host.LocalNetworks, report.MakeStringSet("10.32.0.1/12")), ), }, diff --git a/report/node.go b/report/node.go index bf731f63f..868deb34f 100644 --- a/report/node.go +++ b/report/node.go @@ -24,8 +24,9 @@ type Node struct { } // MakeNode creates a new Node with no initial metadata. -func MakeNode() Node { +func MakeNode(id string) Node { return Node{ + ID: id, Counters: EmptyCounters, Sets: EmptySets, Adjacency: EmptyIDList, @@ -38,8 +39,8 @@ func MakeNode() Node { } // MakeNodeWith creates a new Node with the supplied map. -func MakeNodeWith(m map[string]string) Node { - return MakeNode().WithLatests(m) +func MakeNodeWith(id string, m map[string]string) Node { + return MakeNode(id).WithLatests(m) } // WithID returns a fresh copy of n, with ID changed. @@ -176,8 +177,7 @@ func (n Node) WithChild(child Node) Node { // Copy returns a value copy of the Node. func (n Node) Copy() Node { - cp := MakeNode() - cp.ID = n.ID + cp := MakeNode(n.ID) cp.Topology = n.Topology cp.Counters = n.Counters.Copy() cp.Sets = n.Sets.Copy() @@ -223,8 +223,8 @@ func (n Node) Prune() Node { n.Children.ForEach(func(child Node) { prunedChildren = prunedChildren.Add(child.Prune()) }) - return MakeNode(). - WithID(n.ID). + return MakeNode( + n.ID). WithTopology(n.Topology). WithAdjacent(n.Adjacency.Copy()...). WithChildren(prunedChildren) diff --git a/report/node_set_test.go b/report/node_set_test.go index c8746a68f..45f56d455 100644 --- a/report/node_set_test.go +++ b/report/node_set_test.go @@ -35,7 +35,7 @@ func TestMakeNodeSet(t *testing.T) { } { var inputs []report.Node for _, id := range testcase.inputs { - inputs = append(inputs, report.MakeNode().WithID(id)) + inputs = append(inputs, report.MakeNode(id)) } set := report.MakeNodeSet(inputs...) var have []string @@ -49,7 +49,7 @@ func TestMakeNodeSet(t *testing.T) { func BenchmarkMakeNodeSet(b *testing.B) { nodes := []report.Node{} for i := 1000; i >= 0; i-- { - nodes = append(nodes, report.MakeNode().WithID(fmt.Sprint(i)).WithLatests(map[string]string{ + nodes = append(nodes, report.MakeNodeWith(fmt.Sprint(i), map[string]string{ "a": "1", "b": "2", })) @@ -79,57 +79,57 @@ func TestNodeSetAdd(t *testing.T) { want: report.EmptyNodeSet, }, { - input: report.MakeNodeSet(report.MakeNode().WithID("a")), + input: report.MakeNodeSet(report.MakeNode("a")), nodes: []report.Node{}, - want: report.MakeNodeSet(report.MakeNode().WithID("a")), + want: report.MakeNodeSet(report.MakeNode("a")), }, { input: report.EmptyNodeSet, - nodes: []report.Node{report.MakeNode().WithID("a")}, - want: report.MakeNodeSet(report.MakeNode().WithID("a")), + nodes: []report.Node{report.MakeNode("a")}, + want: report.MakeNodeSet(report.MakeNode("a")), }, { - input: report.MakeNodeSet(report.MakeNode().WithID("a")), - nodes: []report.Node{report.MakeNode().WithID("a")}, - want: report.MakeNodeSet(report.MakeNode().WithID("a")), + input: report.MakeNodeSet(report.MakeNode("a")), + nodes: []report.Node{report.MakeNode("a")}, + want: report.MakeNodeSet(report.MakeNode("a")), }, { - input: report.MakeNodeSet(report.MakeNode().WithID("b")), + input: report.MakeNodeSet(report.MakeNode("b")), nodes: []report.Node{ - report.MakeNode().WithID("a"), - report.MakeNode().WithID("b"), + report.MakeNode("a"), + report.MakeNode("b"), }, want: report.MakeNodeSet( - report.MakeNode().WithID("a"), - report.MakeNode().WithID("b"), + report.MakeNode("a"), + report.MakeNode("b"), ), }, { - input: report.MakeNodeSet(report.MakeNode().WithID("a")), + input: report.MakeNodeSet(report.MakeNode("a")), nodes: []report.Node{ - report.MakeNode().WithID("c"), - report.MakeNode().WithID("b"), + report.MakeNode("c"), + report.MakeNode("b"), }, want: report.MakeNodeSet( - report.MakeNode().WithID("a"), - report.MakeNode().WithID("b"), - report.MakeNode().WithID("c"), + report.MakeNode("a"), + report.MakeNode("b"), + report.MakeNode("c"), ), }, { input: report.MakeNodeSet( - report.MakeNode().WithID("a"), - report.MakeNode().WithID("c"), + report.MakeNode("a"), + report.MakeNode("c"), ), nodes: []report.Node{ - report.MakeNode().WithID("b"), - report.MakeNode().WithID("b"), - report.MakeNode().WithID("b"), + report.MakeNode("b"), + report.MakeNode("b"), + report.MakeNode("b"), }, want: report.MakeNodeSet( - report.MakeNode().WithID("a"), - report.MakeNode().WithID("b"), - report.MakeNode().WithID("c"), + report.MakeNode("a"), + report.MakeNode("b"), + report.MakeNode("c"), ), }, } { @@ -147,14 +147,14 @@ func BenchmarkNodeSetAdd(b *testing.B) { n := report.EmptyNodeSet for i := 0; i < 600; i++ { n = n.Add( - report.MakeNode().WithID(fmt.Sprint(i)).WithLatests(map[string]string{ + report.MakeNodeWith(fmt.Sprint(i), map[string]string{ "a": "1", "b": "2", }), ) } - node := report.MakeNode().WithID("401.5").WithLatests(map[string]string{ + node := report.MakeNodeWith("401.5", map[string]string{ "a": "1", "b": "2", }) @@ -176,39 +176,39 @@ func TestNodeSetMerge(t *testing.T) { {input: report.NodeSet{}, other: report.NodeSet{}, want: report.NodeSet{}}, {input: report.EmptyNodeSet, other: report.EmptyNodeSet, want: report.EmptyNodeSet}, { - input: report.MakeNodeSet(report.MakeNode().WithID("a")), + input: report.MakeNodeSet(report.MakeNode("a")), other: report.EmptyNodeSet, - want: report.MakeNodeSet(report.MakeNode().WithID("a")), + want: report.MakeNodeSet(report.MakeNode("a")), }, { input: report.EmptyNodeSet, - other: report.MakeNodeSet(report.MakeNode().WithID("a")), - want: report.MakeNodeSet(report.MakeNode().WithID("a")), + other: report.MakeNodeSet(report.MakeNode("a")), + want: report.MakeNodeSet(report.MakeNode("a")), }, { - input: report.MakeNodeSet(report.MakeNode().WithID("a")), - other: report.MakeNodeSet(report.MakeNode().WithID("b")), - want: report.MakeNodeSet(report.MakeNode().WithID("a"), report.MakeNode().WithID("b")), + input: report.MakeNodeSet(report.MakeNode("a")), + other: report.MakeNodeSet(report.MakeNode("b")), + want: report.MakeNodeSet(report.MakeNode("a"), report.MakeNode("b")), }, { - input: report.MakeNodeSet(report.MakeNode().WithID("b")), - other: report.MakeNodeSet(report.MakeNode().WithID("a")), - want: report.MakeNodeSet(report.MakeNode().WithID("a"), report.MakeNode().WithID("b")), + input: report.MakeNodeSet(report.MakeNode("b")), + other: report.MakeNodeSet(report.MakeNode("a")), + want: report.MakeNodeSet(report.MakeNode("a"), report.MakeNode("b")), }, { - input: report.MakeNodeSet(report.MakeNode().WithID("a")), - other: report.MakeNodeSet(report.MakeNode().WithID("a")), - want: report.MakeNodeSet(report.MakeNode().WithID("a")), + input: report.MakeNodeSet(report.MakeNode("a")), + other: report.MakeNodeSet(report.MakeNode("a")), + want: report.MakeNodeSet(report.MakeNode("a")), }, { - input: report.MakeNodeSet(report.MakeNode().WithID("a"), report.MakeNode().WithID("c")), - other: report.MakeNodeSet(report.MakeNode().WithID("a"), report.MakeNode().WithID("b")), - want: report.MakeNodeSet(report.MakeNode().WithID("a"), report.MakeNode().WithID("b"), report.MakeNode().WithID("c")), + input: report.MakeNodeSet(report.MakeNode("a"), report.MakeNode("c")), + other: report.MakeNodeSet(report.MakeNode("a"), report.MakeNode("b")), + want: report.MakeNodeSet(report.MakeNode("a"), report.MakeNode("b"), report.MakeNode("c")), }, { - input: report.MakeNodeSet(report.MakeNode().WithID("b")), - other: report.MakeNodeSet(report.MakeNode().WithID("a")), - want: report.MakeNodeSet(report.MakeNode().WithID("a"), report.MakeNode().WithID("b")), + input: report.MakeNodeSet(report.MakeNode("b")), + other: report.MakeNodeSet(report.MakeNode("a")), + want: report.MakeNodeSet(report.MakeNode("a"), report.MakeNode("b")), }, } { originalLen := testcase.input.Size() @@ -225,7 +225,7 @@ func BenchmarkNodeSetMerge(b *testing.B) { n, other := report.NodeSet{}, report.NodeSet{} for i := 0; i < 600; i++ { n = n.Add( - report.MakeNode().WithID(fmt.Sprint(i)).WithLatests(map[string]string{ + report.MakeNodeWith(fmt.Sprint(i), map[string]string{ "a": "1", "b": "2", }), @@ -234,7 +234,7 @@ func BenchmarkNodeSetMerge(b *testing.B) { for i := 400; i < 1000; i++ { other = other.Add( - report.MakeNode().WithID(fmt.Sprint(i)).WithLatests(map[string]string{ + report.MakeNodeWith(fmt.Sprint(i), map[string]string{ "c": "1", "d": "2", }), diff --git a/report/node_test.go b/report/node_test.go index 70586aa41..85add56cd 100644 --- a/report/node_test.go +++ b/report/node_test.go @@ -26,14 +26,14 @@ func TestMergeNodes(t *testing.T) { "Empty a": { a: report.Nodes{}, b: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", }), }, want: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", @@ -42,7 +42,7 @@ func TestMergeNodes(t *testing.T) { }, "Empty b": { a: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", @@ -50,7 +50,7 @@ func TestMergeNodes(t *testing.T) { }, b: report.Nodes{}, want: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", @@ -59,26 +59,26 @@ func TestMergeNodes(t *testing.T) { }, "Simple merge": { a: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", }), }, b: report.Nodes{ - ":192.168.1.2:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.2:12345": report.MakeNodeWith(":192.168.1.2:12345", map[string]string{ PID: "42", Name: "curl", Domain: "node-a.local", }), }, want: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", }), - ":192.168.1.2:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.2:12345": report.MakeNodeWith(":192.168.1.2:12345", map[string]string{ PID: "42", Name: "curl", Domain: "node-a.local", @@ -87,20 +87,20 @@ func TestMergeNodes(t *testing.T) { }, "Merge conflict with rank difference": { a: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", }), }, b: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ // <-- same ID + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ // <-- same ID Name: "curl", Domain: "node-a.local", }).WithLatest(PID, time.Now().Add(-1*time.Minute), "0"), }, want: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", @@ -109,20 +109,20 @@ func TestMergeNodes(t *testing.T) { }, "Merge conflict with no rank difference": { a: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", }), }, b: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ // <-- same ID + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ // <-- same ID Name: "curl", Domain: "node-a.local", }).WithLatest(PID, time.Now().Add(-1*time.Minute), "0"), }, want: report.Nodes{ - ":192.168.1.1:12345": report.MakeNodeWith(map[string]string{ + ":192.168.1.1:12345": report.MakeNodeWith(":192.168.1.1:12345", map[string]string{ PID: "23128", Name: "curl", Domain: "node-a.local", @@ -131,21 +131,21 @@ func TestMergeNodes(t *testing.T) { }, "Counters": { a: report.Nodes{ - "1": report.MakeNode().WithCounters(map[string]int{ + "1": report.MakeNode("1").WithCounters(map[string]int{ "a": 13, "b": 57, "c": 89, }), }, b: report.Nodes{ - "1": report.MakeNode().WithCounters(map[string]int{ + "1": report.MakeNode("1").WithCounters(map[string]int{ "a": 78, "b": 3, "d": 47, }), }, want: report.Nodes{ - "1": report.MakeNode().WithCounters(map[string]int{ + "1": report.MakeNode("1").WithCounters(map[string]int{ "a": 91, "b": 60, "c": 89, diff --git a/report/report_test.go b/report/report_test.go index 7becea8ce..6db2c3184 100644 --- a/report/report_test.go +++ b/report/report_test.go @@ -40,15 +40,16 @@ func TestReportTopology(t *testing.T) { func TestNode(t *testing.T) { { - node := report.MakeNode().WithLatests(map[string]string{ + node := report.MakeNodeWith("foo", map[string]string{ "foo": "bar", }) + if v, _ := node.Latest.Lookup("foo"); v != "bar" { t.Errorf("want foo, have %s", v) } } { - node := report.MakeNode().WithCounters( + node := report.MakeNode("foo").WithCounters( map[string]int{"foo": 1}, ) if value, _ := node.Counters.Lookup("foo"); value != 1 { @@ -56,13 +57,13 @@ func TestNode(t *testing.T) { } } { - node := report.MakeNode().WithAdjacent("foo") + node := report.MakeNode("foo").WithAdjacent("foo") if node.Adjacency[0] != "foo" { t.Errorf("want foo, have %v", node.Adjacency) } } { - node := report.MakeNode().WithEdge("foo", report.EdgeMetadata{ + node := report.MakeNode("foo").WithEdge("foo", report.EdgeMetadata{ EgressPacketCount: newu64(13), }) if node.Adjacency[0] != "foo" { diff --git a/report/topology.go b/report/topology.go index efbb52667..542573423 100644 --- a/report/topology.go +++ b/report/topology.go @@ -51,11 +51,11 @@ func (t Topology) WithMetricTemplates(other MetricTemplates) Topology { // The same topology is returned to enable chaining. // This method is different from all the other similar methods // in that it mutates the Topology, to solve issues of GC pressure. -func (t Topology) AddNode(nodeID string, node Node) Topology { - if existing, ok := t.Nodes[nodeID]; ok { +func (t Topology) AddNode(node Node) Topology { + if existing, ok := t.Nodes[node.ID]; ok { node = node.Merge(existing) } - t.Nodes[nodeID] = node + t.Nodes[node.ID] = node return t } diff --git a/report/topology_test.go b/report/topology_test.go index 0606c315f..dccb6a40f 100644 --- a/report/topology_test.go +++ b/report/topology_test.go @@ -92,7 +92,7 @@ func TestNodeOrdering(t *testing.T) { ids := [][2]string{{}, {"a", "0"}, {"a", "1"}, {"b", "0"}, {"b", "1"}, {"c", "3"}} nodes := []report.Node{} for _, id := range ids { - nodes = append(nodes, report.MakeNode().WithTopology(id[0]).WithID(id[1])) + nodes = append(nodes, report.MakeNode(id[1]).WithTopology(id[0])) } for i, node := range nodes { diff --git a/test/fixture/report_fixture.go b/test/fixture/report_fixture.go index 8fa074dfd..5a9a9e33f 100644 --- a/test/fixture/report_fixture.go +++ b/test/fixture/report_fixture.go @@ -117,7 +117,7 @@ var ( // Node 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.MakeNode().WithID(Client54001NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ + Client54001NodeID: report.MakeNode(Client54001NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ endpoint.Addr: ClientIP, endpoint.Port: ClientPort54001, process.PID: Client1PID, @@ -128,7 +128,7 @@ var ( EgressByteCount: newu64(100), }), - Client54002NodeID: report.MakeNode().WithID(Client54002NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ + Client54002NodeID: report.MakeNode(Client54002NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ endpoint.Addr: ClientIP, endpoint.Port: ClientPort54002, process.PID: Client2PID, @@ -139,7 +139,7 @@ var ( EgressByteCount: newu64(200), }), - Server80NodeID: report.MakeNode().WithID(Server80NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ + Server80NodeID: report.MakeNode(Server80NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ endpoint.Addr: ServerIP, endpoint.Port: ServerPort, process.PID: ServerPID, @@ -147,7 +147,7 @@ var ( endpoint.Procspied: True, }), - NonContainerNodeID: report.MakeNode().WithID(NonContainerNodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ + NonContainerNodeID: report.MakeNode(NonContainerNodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ endpoint.Addr: ServerIP, endpoint.Port: NonContainerClientPort, process.PID: NonContainerPID, @@ -156,7 +156,7 @@ var ( }).WithAdjacent(GoogleEndpointNodeID), // Probe pseudo nodes - UnknownClient1NodeID: report.MakeNode().WithID(UnknownClient1NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ + UnknownClient1NodeID: report.MakeNode(UnknownClient1NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ endpoint.Addr: UnknownClient1IP, endpoint.Port: UnknownClient1Port, endpoint.Procspied: True, @@ -165,7 +165,7 @@ var ( EgressByteCount: newu64(300), }), - UnknownClient2NodeID: report.MakeNode().WithID(UnknownClient2NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ + UnknownClient2NodeID: report.MakeNode(UnknownClient2NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ endpoint.Addr: UnknownClient2IP, endpoint.Port: UnknownClient2Port, endpoint.Procspied: True, @@ -174,7 +174,7 @@ var ( EgressByteCount: newu64(400), }), - UnknownClient3NodeID: report.MakeNode().WithID(UnknownClient3NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ + UnknownClient3NodeID: report.MakeNode(UnknownClient3NodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ endpoint.Addr: UnknownClient3IP, endpoint.Port: UnknownClient3Port, endpoint.Procspied: True, @@ -183,7 +183,7 @@ var ( EgressByteCount: newu64(500), }), - RandomClientNodeID: report.MakeNode().WithID(RandomClientNodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ + RandomClientNodeID: report.MakeNode(RandomClientNodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ endpoint.Addr: RandomClientIP, endpoint.Port: RandomClientPort, endpoint.Procspied: True, @@ -192,7 +192,7 @@ var ( EgressByteCount: newu64(600), }), - GoogleEndpointNodeID: report.MakeNode().WithID(GoogleEndpointNodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ + GoogleEndpointNodeID: report.MakeNode(GoogleEndpointNodeID).WithTopology(report.Endpoint).WithLatests(map[string]string{ endpoint.Addr: GoogleIP, endpoint.Port: GooglePort, endpoint.Procspied: True, @@ -201,12 +201,13 @@ var ( }, Process: report.Topology{ Nodes: report.Nodes{ - ClientProcess1NodeID: report.MakeNodeWith(map[string]string{ + ClientProcess1NodeID: report.MakeNodeWith(ClientProcess1NodeID, map[string]string{ process.PID: Client1PID, process.Name: Client1Name, docker.ContainerID: ClientContainerID, report.HostNodeID: ClientHostNodeID, - }).WithID(ClientProcess1NodeID).WithTopology(report.Process).WithParents(report.EmptySets. + }). + WithTopology(report.Process).WithParents(report.EmptySets. Add("host", report.MakeStringSet(ClientHostNodeID)). Add("container", report.MakeStringSet(ClientContainerNodeID)). Add("container_image", report.MakeStringSet(ClientContainerImageNodeID)), @@ -214,31 +215,34 @@ var ( process.CPUUsage: ClientProcess1CPUMetric, process.MemoryUsage: ClientProcess1MemoryMetric, }), - ClientProcess2NodeID: report.MakeNodeWith(map[string]string{ + ClientProcess2NodeID: report.MakeNodeWith(ClientProcess2NodeID, map[string]string{ process.PID: Client2PID, process.Name: Client2Name, docker.ContainerID: ClientContainerID, report.HostNodeID: ClientHostNodeID, - }).WithID(ClientProcess2NodeID).WithTopology(report.Process).WithParents(report.EmptySets. + }). + WithTopology(report.Process).WithParents(report.EmptySets. Add("host", report.MakeStringSet(ClientHostNodeID)). Add("container", report.MakeStringSet(ClientContainerNodeID)). Add("container_image", report.MakeStringSet(ClientContainerImageNodeID)), ), - ServerProcessNodeID: report.MakeNodeWith(map[string]string{ + ServerProcessNodeID: report.MakeNodeWith(ServerProcessNodeID, map[string]string{ process.PID: ServerPID, process.Name: ServerName, docker.ContainerID: ServerContainerID, report.HostNodeID: ServerHostNodeID, - }).WithID(ServerProcessNodeID).WithTopology(report.Process).WithParents(report.EmptySets. + }). + WithTopology(report.Process).WithParents(report.EmptySets. Add("host", report.MakeStringSet(ServerHostNodeID)). Add("container", report.MakeStringSet(ServerContainerNodeID)). Add("container_image", report.MakeStringSet(ServerContainerImageNodeID)), ), - NonContainerProcessNodeID: report.MakeNodeWith(map[string]string{ + NonContainerProcessNodeID: report.MakeNodeWith(NonContainerProcessNodeID, map[string]string{ process.PID: NonContainerPID, process.Name: NonContainerName, report.HostNodeID: ServerHostNodeID, - }).WithID(NonContainerProcessNodeID).WithTopology(report.Process).WithParents(report.EmptySets. + }). + WithTopology(report.Process).WithParents(report.EmptySets. Add("host", report.MakeStringSet(ServerHostNodeID)), ), }, @@ -247,17 +251,20 @@ var ( }, Container: report.Topology{ Nodes: report.Nodes{ - ClientContainerNodeID: report.MakeNodeWith(map[string]string{ - docker.ContainerID: ClientContainerID, - docker.ContainerName: ClientContainerName, - docker.ImageID: ClientContainerImageID, - report.HostNodeID: ClientHostNodeID, - docker.LabelPrefix + "io.kubernetes.pod.name": ClientPodID, - kubernetes.PodID: ClientPodID, - kubernetes.Namespace: KubernetesNamespace, - docker.ContainerState: docker.StateRunning, - docker.ContainerStateHuman: docker.StateRunning, - }).WithID(ClientContainerNodeID).WithTopology(report.Container).WithParents(report.EmptySets. + ClientContainerNodeID: report.MakeNodeWith( + + ClientContainerNodeID, map[string]string{ + docker.ContainerID: ClientContainerID, + docker.ContainerName: ClientContainerName, + docker.ImageID: ClientContainerImageID, + report.HostNodeID: ClientHostNodeID, + docker.LabelPrefix + "io.kubernetes.pod.name": ClientPodID, + kubernetes.PodID: ClientPodID, + kubernetes.Namespace: KubernetesNamespace, + docker.ContainerState: docker.StateRunning, + docker.ContainerStateHuman: docker.StateRunning, + }). + WithTopology(report.Container).WithParents(report.EmptySets. Add("host", report.MakeStringSet(ClientHostNodeID)). Add("container_image", report.MakeStringSet(ClientContainerImageNodeID)). Add("pod", report.MakeStringSet(ClientPodID)), @@ -265,20 +272,23 @@ var ( docker.CPUTotalUsage: ClientContainerCPUMetric, docker.MemoryUsage: ClientContainerMemoryMetric, }), - ServerContainerNodeID: report.MakeNodeWith(map[string]string{ - docker.ContainerID: ServerContainerID, - docker.ContainerName: "task-name-5-server-aceb93e2f2b797caba01", - docker.ContainerState: docker.StateRunning, - docker.ContainerStateHuman: docker.StateRunning, - docker.ImageID: ServerContainerImageID, - report.HostNodeID: ServerHostNodeID, - docker.LabelPrefix + detailed.AmazonECSContainerNameLabel: "server", - docker.LabelPrefix + "foo1": "bar1", - docker.LabelPrefix + "foo2": "bar2", - docker.LabelPrefix + "io.kubernetes.pod.name": ServerPodID, - kubernetes.PodID: ServerPodID, - kubernetes.Namespace: KubernetesNamespace, - }).WithID(ServerContainerNodeID).WithTopology(report.Container).WithParents(report.EmptySets. + ServerContainerNodeID: report.MakeNodeWith( + + ServerContainerNodeID, map[string]string{ + docker.ContainerID: ServerContainerID, + docker.ContainerName: "task-name-5-server-aceb93e2f2b797caba01", + docker.ContainerState: docker.StateRunning, + docker.ContainerStateHuman: docker.StateRunning, + docker.ImageID: ServerContainerImageID, + report.HostNodeID: ServerHostNodeID, + docker.LabelPrefix + detailed.AmazonECSContainerNameLabel: "server", + docker.LabelPrefix + "foo1": "bar1", + docker.LabelPrefix + "foo2": "bar2", + docker.LabelPrefix + "io.kubernetes.pod.name": ServerPodID, + kubernetes.PodID: ServerPodID, + kubernetes.Namespace: KubernetesNamespace, + }). + WithTopology(report.Container).WithParents(report.EmptySets. Add("host", report.MakeStringSet(ServerHostNodeID)). Add("container_image", report.MakeStringSet(ServerContainerImageNodeID)). Add("pod", report.MakeStringSet(ServerPodID)), @@ -292,43 +302,51 @@ var ( }, ContainerImage: report.Topology{ Nodes: report.Nodes{ - ClientContainerImageNodeID: report.MakeNodeWith(map[string]string{ + ClientContainerImageNodeID: report.MakeNodeWith(ClientContainerImageNodeID, map[string]string{ docker.ImageID: ClientContainerImageID, docker.ImageName: ClientContainerImageName, report.HostNodeID: ClientHostNodeID, - }).WithParents(report.EmptySets. - Add("host", report.MakeStringSet(ClientHostNodeID)), - ).WithID(ClientContainerImageNodeID).WithTopology(report.ContainerImage), - ServerContainerImageNodeID: report.MakeNodeWith(map[string]string{ + }). + WithParents(report.EmptySets. + Add("host", report.MakeStringSet(ClientHostNodeID)), + ).WithTopology(report.ContainerImage), + ServerContainerImageNodeID: report.MakeNodeWith(ServerContainerImageNodeID, map[string]string{ docker.ImageID: ServerContainerImageID, docker.ImageName: ServerContainerImageName, report.HostNodeID: ServerHostNodeID, docker.LabelPrefix + "foo1": "bar1", docker.LabelPrefix + "foo2": "bar2", - }).WithParents(report.EmptySets. - Add("host", report.MakeStringSet(ServerHostNodeID)), - ).WithID(ServerContainerImageNodeID).WithTopology(report.ContainerImage), + }). + WithParents(report.EmptySets. + Add("host", report.MakeStringSet(ServerHostNodeID)), + ).WithTopology(report.ContainerImage), }, MetadataTemplates: docker.ContainerImageMetadataTemplates, }, Host: report.Topology{ Nodes: report.Nodes{ - ClientHostNodeID: report.MakeNodeWith(map[string]string{ - "host_name": ClientHostName, - "os": "Linux", - report.HostNodeID: ClientHostNodeID, - }).WithID(ClientHostNodeID).WithTopology(report.Host).WithSets(report.EmptySets. + ClientHostNodeID: report.MakeNodeWith( + + ClientHostNodeID, map[string]string{ + "host_name": ClientHostName, + "os": "Linux", + report.HostNodeID: ClientHostNodeID, + }). + WithTopology(report.Host).WithSets(report.EmptySets. Add(host.LocalNetworks, report.MakeStringSet("10.10.10.0/24")), ).WithMetrics(report.Metrics{ host.CPUUsage: ClientHostCPUMetric, host.MemoryUsage: ClientHostMemoryMetric, host.Load1: ClientHostLoad1Metric, }), - ServerHostNodeID: report.MakeNodeWith(map[string]string{ - "host_name": ServerHostName, - "os": "Linux", - report.HostNodeID: ServerHostNodeID, - }).WithID(ServerHostNodeID).WithTopology(report.Host).WithSets(report.EmptySets. + ServerHostNodeID: report.MakeNodeWith( + + ServerHostNodeID, map[string]string{ + "host_name": ServerHostName, + "os": "Linux", + report.HostNodeID: ServerHostNodeID, + }). + WithTopology(report.Host).WithSets(report.EmptySets. Add(host.LocalNetworks, report.MakeStringSet("10.10.10.0/24")), ).WithMetrics(report.Metrics{ host.CPUUsage: ServerHostCPUMetric, @@ -341,24 +359,30 @@ var ( }, Pod: report.Topology{ Nodes: report.Nodes{ - ClientPodNodeID: report.MakeNodeWith(map[string]string{ - kubernetes.PodID: ClientPodID, - kubernetes.PodName: "pong-a", - kubernetes.Namespace: KubernetesNamespace, - kubernetes.PodContainerIDs: ClientContainerID, - kubernetes.ServiceIDs: ServiceID, - }).WithID(ClientPodNodeID).WithTopology(report.Pod).WithParents(report.EmptySets. + ClientPodNodeID: report.MakeNodeWith( + + ClientPodNodeID, map[string]string{ + kubernetes.PodID: ClientPodID, + kubernetes.PodName: "pong-a", + kubernetes.Namespace: KubernetesNamespace, + kubernetes.PodContainerIDs: ClientContainerID, + kubernetes.ServiceIDs: ServiceID, + }). + WithTopology(report.Pod).WithParents(report.EmptySets. Add("host", report.MakeStringSet(ClientHostNodeID)). Add("service", report.MakeStringSet(ServiceID)), ), - ServerPodNodeID: report.MakeNodeWith(map[string]string{ - kubernetes.PodID: ServerPodID, - kubernetes.PodName: "pong-b", - kubernetes.Namespace: KubernetesNamespace, - kubernetes.PodState: "running", - kubernetes.PodContainerIDs: ServerContainerID, - kubernetes.ServiceIDs: ServiceID, - }).WithID(ServerPodNodeID).WithTopology(report.Pod).WithParents(report.EmptySets. + ServerPodNodeID: report.MakeNodeWith( + + ServerPodNodeID, map[string]string{ + kubernetes.PodID: ServerPodID, + kubernetes.PodName: "pong-b", + kubernetes.Namespace: KubernetesNamespace, + kubernetes.PodState: "running", + kubernetes.PodContainerIDs: ServerContainerID, + kubernetes.ServiceIDs: ServiceID, + }). + WithTopology(report.Pod).WithParents(report.EmptySets. Add("host", report.MakeStringSet(ServerHostNodeID)). Add("service", report.MakeStringSet(ServiceID)), ), @@ -367,11 +391,14 @@ var ( }, Service: report.Topology{ Nodes: report.Nodes{ - ServiceNodeID: report.MakeNodeWith(map[string]string{ - kubernetes.ServiceID: ServiceID, - kubernetes.ServiceName: "pongservice", - kubernetes.Namespace: "ping", - }).WithID(ServiceNodeID).WithTopology(report.Service), + ServiceNodeID: report.MakeNodeWith( + + ServiceNodeID, map[string]string{ + kubernetes.ServiceID: ServiceID, + kubernetes.ServiceName: "pongservice", + kubernetes.Namespace: "ping", + }). + WithTopology(report.Service), }, }, Sampling: report.Sampling{