Removing report.Node.WithID (#1315)

* removing usage of report.Node.WithID * report.Topology.AddNode can use the node's ID field
weaveworks · Apr 19, 2016 · 1edeb8d · 1edeb8d
1 parent 7a6ca39
commit 1edeb8d
Show file tree

Hide file tree

Showing 45 changed files with 349 additions and 311 deletions.
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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;<container>", 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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,