Rename NodeMetadata -> Node

render/detailed_node.go

@@ -87,9 +87,9 @@ func MakeDetailedNode(r report.Report, n RenderableNode) DetailedNode {
 	for _, id := range n.Origins {
 		if table, ok := OriginTable(r, id, multiHost, multiContainer); ok {
 			tables = append(tables, table)
-		} else if _, ok := r.Endpoint.NodeMetadatas[id]; ok {
+		} else if _, ok := r.Endpoint.Nodes[id]; ok {
 			connections = append(connections, connectionDetailsRows(r.Endpoint, id)...)
-		} else if _, ok := r.Address.NodeMetadatas[id]; ok {
+		} else if _, ok := r.Address.Nodes[id]; ok {
 			connections = append(connections, connectionDetailsRows(r.Address, id)...)
 		}
 	}
@@ -117,7 +117,7 @@ func getRenderingContext(r report.Report, n RenderableNode) (multiContainer, mul
 	)
 	for _, id := range n.Origins {
 		for _, topology := range r.Topologies() {
-			if nmd, ok := topology.NodeMetadatas[id]; ok {
+			if nmd, ok := topology.Nodes[id]; ok {
 				originHosts[report.ExtractHostID(nmd)] = struct{}{}
 				if id, ok := nmd.Metadata[docker.ContainerID]; ok {
 					originContainers[id] = struct{}{}
@@ -188,16 +188,16 @@ func connectionsTable(connections []Row, r report.Report, n RenderableNode) (Tab
 // OriginTable produces a table (to be consumed directly by the UI) based on
 // an origin ID, which is (optimistically) a node ID in one of our topologies.
 func OriginTable(r report.Report, originID string, addHostTags bool, addContainerTags bool) (Table, bool) {
-	if nmd, ok := r.Process.NodeMetadatas[originID]; ok {
+	if nmd, ok := r.Process.Nodes[originID]; ok {
 		return processOriginTable(nmd, addHostTags, addContainerTags)
 	}
-	if nmd, ok := r.Container.NodeMetadatas[originID]; ok {
+	if nmd, ok := r.Container.Nodes[originID]; ok {
 		return containerOriginTable(nmd, addHostTags)
 	}
-	if nmd, ok := r.ContainerImage.NodeMetadatas[originID]; ok {
+	if nmd, ok := r.ContainerImage.Nodes[originID]; ok {
 		return containerImageOriginTable(nmd)
 	}
-	if nmd, ok := r.Host.NodeMetadatas[originID]; ok {
+	if nmd, ok := r.Host.Nodes[originID]; ok {
 		return hostOriginTable(nmd)
 	}
 	return Table{}, false
@@ -219,7 +219,7 @@ func connectionDetailsRows(topology report.Topology, originID string) []Row {
 		return rows
 	}
 	// Firstly, collection outgoing connections from this node.
-	for _, serverNodeID := range topology.NodeMetadatas[originID].Adjacency {
+	for _, serverNodeID := range topology.Nodes[originID].Adjacency {
 		remote, ok := labeler(serverNodeID)
 		if !ok {
 			continue
@@ -231,11 +231,11 @@ func connectionDetailsRows(topology report.Topology, originID string) []Row {
 		})
 	}
 	// Next, scan the topology for incoming connections to this node.
-	for clientNodeID, clientNodeMetadata := range topology.NodeMetadatas {
+	for clientNodeID, clientNode := range topology.Nodes {
 		if clientNodeID == originID {
 			continue
 		}
-		serverNodeIDs := clientNodeMetadata.Adjacency
+		serverNodeIDs := clientNode.Adjacency
 		if !serverNodeIDs.Contains(originID) {
 			continue
 		}
@@ -252,7 +252,7 @@ func connectionDetailsRows(topology report.Topology, originID string) []Row {
 	return rows
 }
 
-func processOriginTable(nmd report.NodeMetadata, addHostTag bool, addContainerTag bool) (Table, bool) {
+func processOriginTable(nmd report.Node, addHostTag bool, addContainerTag bool) (Table, bool) {
 	rows := []Row{}
 	for _, tuple := range []struct{ key, human string }{
 		{process.PPID, "Parent PID"},
@@ -291,7 +291,7 @@ func processOriginTable(nmd report.NodeMetadata, addHostTag bool, addContainerTa
 	}, len(rows) > 0 || commFound || pidFound
 }
 
-func containerOriginTable(nmd report.NodeMetadata, addHostTag bool) (Table, bool) {
+func containerOriginTable(nmd report.Node, addHostTag bool) (Table, bool) {
 	rows := []Row{}
 	for _, tuple := range []struct{ key, human string }{
 		{docker.ContainerID, "ID"},
@@ -339,7 +339,7 @@ func containerOriginTable(nmd report.NodeMetadata, addHostTag bool) (Table, bool
 	}, len(rows) > 0 || nameFound
 }
 
-func containerImageOriginTable(nmd report.NodeMetadata) (Table, bool) {
+func containerImageOriginTable(nmd report.Node) (Table, bool) {
 	rows := []Row{}
 	for _, tuple := range []struct{ key, human string }{
 		{docker.ImageID, "Image ID"},
@@ -365,7 +365,7 @@ func containerImageOriginTable(nmd report.NodeMetadata) (Table, bool) {
 	}, len(rows) > 0 || nameFound
 }
 
-func getDockerLabelRows(nmd report.NodeMetadata) []Row {
+func getDockerLabelRows(nmd report.Node) []Row {
 	rows := []Row{}
 	// Add labels in alphabetical order
 	labels := docker.ExtractLabels(nmd)
@@ -380,7 +380,7 @@ func getDockerLabelRows(nmd report.NodeMetadata) []Row {
 	return rows
 }
 
-func hostOriginTable(nmd report.NodeMetadata) (Table, bool) {
+func hostOriginTable(nmd report.Node) (Table, bool) {
 	rows := []Row{}
 	for _, tuple := range []struct{ key, human string }{
 		{host.Load, "Load"},

render/expected/expected.go

@@ -10,14 +10,14 @@ import (
 
 // Sterilize cleans up RenderableNodes test fixtures
 func Sterilize(r render.RenderableNodes) render.RenderableNodes {
-	// RenderableNodes contain NodeMetadatas, but generally we
+	// RenderableNodes contain Nodes, but generally we
 	// only care about the Adjacency field - the rest is internal
 	// state not sent to the client.  So in the tests we ignore
 	// this state.
 	for id, n := range r {
-		n.NodeMetadata.Metadata = report.Metadata{}
-		n.NodeMetadata.Counters = report.Counters{}
-		n.NodeMetadata.Edges = report.EdgeMetadatas{}
+		n.Node.Metadata = report.Metadata{}
+		n.Node.Counters = report.Counters{}
+		n.Node.Edges = report.EdgeMetadatas{}
 		r[id] = n
 	}
 	return r
@@ -30,10 +30,10 @@ var (
 	unknownPseudoNode2ID = render.MakePseudoNodeID("10.10.10.11", test.ServerIP, "80")
 	unknownPseudoNode1   = func(adjacency report.IDList) render.RenderableNode {
 		return render.RenderableNode{
-			ID:           unknownPseudoNode1ID,
-			LabelMajor:   "10.10.10.10",
-			Pseudo:       true,
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacency(adjacency),
+			ID:         unknownPseudoNode1ID,
+			LabelMajor: "10.10.10.10",
+			Pseudo:     true,
+			Node:       report.MakeNode().WithAdjacency(adjacency),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(70),
 				EgressByteCount:   newu64(700),
@@ -46,10 +46,10 @@ var (
 	}
 	unknownPseudoNode2 = func(adjacency report.IDList) render.RenderableNode {
 		return render.RenderableNode{
-			ID:           unknownPseudoNode2ID,
-			LabelMajor:   "10.10.10.11",
-			Pseudo:       true,
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacency(adjacency),
+			ID:         unknownPseudoNode2ID,
+			LabelMajor: "10.10.10.11",
+			Pseudo:     true,
+			Node:       report.MakeNode().WithAdjacency(adjacency),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(50),
 				EgressByteCount:   newu64(500),
@@ -61,10 +61,10 @@ var (
 	}
 	theInternetNode = func(adjacency report.IDList) render.RenderableNode {
 		return render.RenderableNode{
-			ID:           render.TheInternetID,
-			LabelMajor:   render.TheInternetMajor,
-			Pseudo:       true,
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacency(adjacency),
+			ID:         render.TheInternetID,
+			LabelMajor: render.TheInternetMajor,
+			Pseudo:     true,
+			Node:       report.MakeNode().WithAdjacency(adjacency),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(60),
 				EgressByteCount:   newu64(600),
@@ -92,7 +92,7 @@ var (
 				test.ClientProcess1NodeID,
 				test.ClientHostNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(ServerProcessID),
+			Node: report.MakeNode().WithAdjacent(ServerProcessID),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(10),
 				EgressByteCount:   newu64(100),
@@ -109,7 +109,7 @@ var (
 				test.ClientProcess2NodeID,
 				test.ClientHostNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(ServerProcessID),
+			Node: report.MakeNode().WithAdjacent(ServerProcessID),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(20),
 				EgressByteCount:   newu64(200),
@@ -126,7 +126,7 @@ var (
 				test.ServerProcessNodeID,
 				test.ServerHostNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata(),
+			Node: report.MakeNode(),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(210),
 				EgressByteCount:   newu64(2100),
@@ -143,7 +143,7 @@ var (
 				test.ServerHostNodeID,
 				test.NonContainerNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(render.TheInternetID),
+			Node:         report.MakeNode().WithAdjacent(render.TheInternetID),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
 		unknownPseudoNode1ID: unknownPseudoNode1(report.MakeIDList(ServerProcessID)),
@@ -165,7 +165,7 @@ var (
 				test.ClientProcess2NodeID,
 				test.ClientHostNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent("apache"),
+			Node: report.MakeNode().WithAdjacent("apache"),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(30),
 				EgressByteCount:   newu64(300),
@@ -182,7 +182,7 @@ var (
 				test.ServerProcessNodeID,
 				test.ServerHostNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata(),
+			Node: report.MakeNode(),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(210),
 				EgressByteCount:   newu64(2100),
@@ -199,7 +199,7 @@ var (
 				test.ServerHostNodeID,
 				test.NonContainerNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(render.TheInternetID),
+			Node:         report.MakeNode().WithAdjacent(render.TheInternetID),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
 		unknownPseudoNode1ID: unknownPseudoNode1(report.MakeIDList("apache")),
@@ -223,7 +223,7 @@ var (
 				test.ClientProcess2NodeID,
 				test.ClientHostNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(test.ServerContainerID),
+			Node: report.MakeNode().WithAdjacent(test.ServerContainerID),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(30),
 				EgressByteCount:   newu64(300),
@@ -242,7 +242,7 @@ var (
 				test.ServerProcessNodeID,
 				test.ServerHostNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata(),
+			Node: report.MakeNode(),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(210),
 				EgressByteCount:   newu64(2100),
@@ -259,7 +259,7 @@ var (
 				test.ServerHostNodeID,
 				test.NonContainerNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(render.TheInternetID),
+			Node:         report.MakeNode().WithAdjacent(render.TheInternetID),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
 		render.TheInternetID: theInternetNode(report.MakeIDList(test.ServerContainerID)),
@@ -281,7 +281,7 @@ var (
 				test.ClientProcess2NodeID,
 				test.ClientHostNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(test.ServerContainerImageName),
+			Node: report.MakeNode().WithAdjacent(test.ServerContainerImageName),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(30),
 				EgressByteCount:   newu64(300),
@@ -299,7 +299,7 @@ var (
 				test.Server80NodeID,
 				test.ServerProcessNodeID,
 				test.ServerHostNodeID),
-			NodeMetadata: report.MakeNodeMetadata(),
+			Node: report.MakeNode(),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(210),
 				EgressByteCount:   newu64(2100),
@@ -316,7 +316,7 @@ var (
 				test.NonContainerProcessNodeID,
 				test.ServerHostNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(render.TheInternetID),
+			Node:         report.MakeNode().WithAdjacent(render.TheInternetID),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
 		render.TheInternetID: theInternetNode(report.MakeIDList(test.ServerContainerImageName)),
@@ -338,7 +338,7 @@ var (
 				test.ServerHostNodeID,
 				test.ServerAddressNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata(),
+			Node: report.MakeNode(),
 			EdgeMetadata: report.EdgeMetadata{
 				MaxConnCountTCP: newu64(3),
 			},
@@ -353,7 +353,7 @@ var (
 				test.ClientHostNodeID,
 				test.ClientAddressNodeID,
 			),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(ServerHostRenderedID),
+			Node: report.MakeNode().WithAdjacent(ServerHostRenderedID),
 			EdgeMetadata: report.EdgeMetadata{
 				MaxConnCountTCP: newu64(3),
 			},
@@ -362,7 +362,7 @@ var (
 			ID:           pseudoHostID1,
 			LabelMajor:   test.UnknownClient1IP,
 			Pseudo:       true,
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(ServerHostRenderedID),
+			Node:         report.MakeNode().WithAdjacent(ServerHostRenderedID),
 			EdgeMetadata: report.EdgeMetadata{},
 			Origins:      report.MakeIDList(test.UnknownAddress1NodeID, test.UnknownAddress2NodeID),
 		},
@@ -370,7 +370,7 @@ var (
 			ID:           pseudoHostID2,
 			LabelMajor:   test.UnknownClient3IP,
 			Pseudo:       true,
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(ServerHostRenderedID),
+			Node:         report.MakeNode().WithAdjacent(ServerHostRenderedID),
 			EdgeMetadata: report.EdgeMetadata{},
 			Origins:      report.MakeIDList(test.UnknownAddress3NodeID),
 		},
@@ -378,7 +378,7 @@ var (
 			ID:           render.TheInternetID,
 			LabelMajor:   render.TheInternetMajor,
 			Pseudo:       true,
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent(ServerHostRenderedID),
+			Node:         report.MakeNode().WithAdjacent(ServerHostRenderedID),
 			EdgeMetadata: report.EdgeMetadata{},
 			Origins:      report.MakeIDList(test.RandomAddressNodeID),
 		},

render/mapping.go

@@ -74,9 +74,9 @@ func MapEndpointIdentity(m RenderableNode, local report.Networks) RenderableNode
 	}
 
 	var (
-		id    = MakeEndpointID(report.ExtractHostID(m.NodeMetadata), addr, port)
+		id    = MakeEndpointID(report.ExtractHostID(m.Node), addr, port)
 		major = fmt.Sprintf("%s:%s", addr, port)
-		minor = report.ExtractHostID(m.NodeMetadata)
+		minor = report.ExtractHostID(m.Node)
 		rank  = major
 	)
 
@@ -97,9 +97,9 @@ func MapProcessIdentity(m RenderableNode, _ report.Networks) RenderableNodes {
 	}
 
 	var (
-		id    = MakeProcessID(report.ExtractHostID(m.NodeMetadata), pid)
+		id    = MakeProcessID(report.ExtractHostID(m.Node), pid)
 		major = m.Metadata["comm"]
-		minor = fmt.Sprintf("%s (%s)", report.ExtractHostID(m.NodeMetadata), pid)
+		minor = fmt.Sprintf("%s (%s)", report.ExtractHostID(m.Node), pid)
 		rank  = m.Metadata["comm"]
 	)
 
@@ -117,7 +117,7 @@ func MapContainerIdentity(m RenderableNode, _ report.Networks) RenderableNodes {
 
 	var (
 		major = m.Metadata[docker.ContainerName]
-		minor = report.ExtractHostID(m.NodeMetadata)
+		minor = report.ExtractHostID(m.Node)
 		rank  = m.Metadata[docker.ImageID]
 	)
 
@@ -174,9 +174,9 @@ func MapAddressIdentity(m RenderableNode, local report.Networks) RenderableNodes
 	}
 
 	var (
-		id    = MakeAddressID(report.ExtractHostID(m.NodeMetadata), addr)
+		id    = MakeAddressID(report.ExtractHostID(m.Node), addr)
 		major = addr
-		minor = report.ExtractHostID(m.NodeMetadata)
+		minor = report.ExtractHostID(m.Node)
 		rank  = major
 	)
 
@@ -188,7 +188,7 @@ func MapAddressIdentity(m RenderableNode, local report.Networks) RenderableNodes
 // present.
 func MapHostIdentity(m RenderableNode, _ report.Networks) RenderableNodes {
 	var (
-		id                 = MakeHostID(report.ExtractHostID(m.NodeMetadata))
+		id                 = MakeHostID(report.ExtractHostID(m.Node))
 		hostname           = m.Metadata[host.HostName]
 		parts              = strings.SplitN(hostname, ".", 2)
 		major, minor, rank = "", "", ""
@@ -233,7 +233,7 @@ func MapContainer2IP(m RenderableNode, _ report.Networks) RenderableNodes {
 	}
 	for _, addr := range strings.Fields(addrs) {
 		n := NewRenderableNodeWith(addr, "", "", "", m)
-		n.NodeMetadata.Counters[containersKey] = 1
+		n.Node.Counters[containersKey] = 1
 		result[addr] = n
 	}
 	return result
@@ -245,7 +245,7 @@ func MapContainer2IP(m RenderableNode, _ report.Networks) RenderableNodes {
 func MapIP2Container(n RenderableNode, _ report.Networks) RenderableNodes {
 	// If an IP is shared between multiple containers, we can't
 	// reliably attribute an connection based on its IP
-	if n.NodeMetadata.Counters[containersKey] > 1 {
+	if n.Node.Counters[containersKey] > 1 {
 		return RenderableNodes{}
 	}
 
@@ -257,7 +257,7 @@ func MapIP2Container(n RenderableNode, _ report.Networks) RenderableNodes {
 	// If this node is not a container, exclude it.
 	// This excludes all the nodes we've dragged in from endpoint
 	// that we failed to join to a container.
-	id, ok := n.NodeMetadata.Metadata[docker.ContainerID]
+	id, ok := n.Node.Metadata[docker.ContainerID]
 	if !ok {
 		return RenderableNodes{}
 	}
@@ -281,12 +281,12 @@ func MapEndpoint2Process(n RenderableNode, _ report.Networks) RenderableNodes {
 		return RenderableNodes{n.ID: n}
 	}
 
-	pid, ok := n.NodeMetadata.Metadata[process.PID]
+	pid, ok := n.Node.Metadata[process.PID]
 	if !ok {
 		return RenderableNodes{}
 	}
 
-	id := MakeProcessID(report.ExtractHostID(n.NodeMetadata), pid)
+	id := MakeProcessID(report.ExtractHostID(n.Node), pid)
 	return RenderableNodes{id: NewDerivedNode(id, n)}
 }
 
@@ -316,9 +316,9 @@ func MapProcess2Container(n RenderableNode, _ report.Networks) RenderableNodes {
 	// into an per-host "Uncontained" node.  If for whatever reason
 	// this node doesn't have a host id in their nodemetadata, it'll
 	// all get grouped into a single uncontained node.
-	id, ok := n.NodeMetadata.Metadata[docker.ContainerID]
+	id, ok := n.Node.Metadata[docker.ContainerID]
 	if !ok {
-		hostID := report.ExtractHostID(n.NodeMetadata)
+		hostID := report.ExtractHostID(n.Node)
 		id = MakePseudoNodeID(UncontainedID, hostID)
 		node := newDerivedPseudoNode(id, UncontainedMajor, n)
 		node.LabelMinor = hostID
@@ -339,7 +339,7 @@ func MapProcess2Name(n RenderableNode, _ report.Networks) RenderableNodes {
 		return RenderableNodes{n.ID: n}
 	}
 
-	name, ok := n.NodeMetadata.Metadata["comm"]
+	name, ok := n.Node.Metadata["comm"]
 	if !ok {
 		return RenderableNodes{}
 	}
@@ -347,7 +347,7 @@ func MapProcess2Name(n RenderableNode, _ report.Networks) RenderableNodes {
 	node := NewDerivedNode(name, n)
 	node.LabelMajor = name
 	node.Rank = name
-	node.NodeMetadata.Counters[processesKey] = 1
+	node.Node.Counters[processesKey] = 1
 	return RenderableNodes{name: node}
 }
 
@@ -359,7 +359,7 @@ func MapCountProcessName(n RenderableNode, _ report.Networks) RenderableNodes {
 		return RenderableNodes{n.ID: n}
 	}
 
-	processes := n.NodeMetadata.Counters[processesKey]
+	processes := n.Node.Counters[processesKey]
 	if processes == 1 {
 		n.LabelMinor = "1 process"
 	} else {
@@ -387,14 +387,14 @@ func MapContainer2ContainerImage(n RenderableNode, _ report.Networks) Renderable
 
 	// Otherwise, if some some reason the container doesn't have a image_id
 	// (maybe slightly out of sync reports), just drop it
-	id, ok := n.NodeMetadata.Metadata[docker.ImageID]
+	id, ok := n.Node.Metadata[docker.ImageID]
 	if !ok {
 		return RenderableNodes{}
 	}
 
 	// Add container-<id> key to NMD, which will later be counted to produce the minor label
 	result := NewDerivedNode(id, n)
-	result.NodeMetadata.Counters[containersKey] = 1
+	result.Node.Counters[containersKey] = 1
 	return RenderableNodes{id: result}
 }
 
@@ -409,7 +409,7 @@ func MapContainerImage2Name(n RenderableNode, _ report.Networks) RenderableNodes
 		return RenderableNodes{n.ID: n}
 	}
 
-	name, ok := n.NodeMetadata.Metadata[docker.ImageName]
+	name, ok := n.Node.Metadata[docker.ImageName]
 	if !ok {
 		return RenderableNodes{}
 	}
@@ -422,7 +422,7 @@ func MapContainerImage2Name(n RenderableNode, _ report.Networks) RenderableNodes
 	node := NewDerivedNode(name, n)
 	node.LabelMajor = name
 	node.Rank = name
-	node.NodeMetadata = n.NodeMetadata.Copy() // Propagate NMD for container counting.
+	node.Node = n.Node.Copy() // Propagate NMD for container counting.
 	return RenderableNodes{name: node}
 }
 
@@ -434,7 +434,7 @@ func MapCountContainers(n RenderableNode, _ report.Networks) RenderableNodes {
 		return RenderableNodes{n.ID: n}
 	}
 
-	containers := n.NodeMetadata.Counters[containersKey]
+	containers := n.Node.Counters[containersKey]
 	if containers == 1 {
 		n.LabelMinor = "1 container"
 	} else {
@@ -451,7 +451,7 @@ func MapAddress2Host(n RenderableNode, _ report.Networks) RenderableNodes {
 		return RenderableNodes{n.ID: n}
 	}
 
-	id := MakeHostID(report.ExtractHostID(n.NodeMetadata))
+	id := MakeHostID(report.ExtractHostID(n.Node))
 	return RenderableNodes{id: NewDerivedNode(id, n)}
 }
 

render/mapping_test.go

@@ -11,18 +11,18 @@ import (
 	"github.com/weaveworks/scope/report"
 )
 
-func nrn(nmd report.NodeMetadata) render.RenderableNode {
-	return render.NewRenderableNode("").WithNodeMetadata(nmd)
+func nrn(nmd report.Node) render.RenderableNode {
+	return render.NewRenderableNode("").WithNode(nmd)
 }
 
 func TestMapEndpointIdentity(t *testing.T) {
 	for _, input := range []testcase{
-		{nrn(report.MakeNodeMetadata()), false},
-		{nrn(report.MakeNodeMetadataWith(map[string]string{endpoint.Addr: "1.2.3.4"})), false},
-		{nrn(report.MakeNodeMetadataWith(map[string]string{endpoint.Port: "1234"})), false},
-		{nrn(report.MakeNodeMetadataWith(map[string]string{endpoint.Addr: "1.2.3.4", endpoint.Port: "1234"})), true},
-		{nrn(report.MakeNodeMetadataWith(map[string]string{endpoint.Addr: "1.2.3.4", endpoint.Port: "40000"})), true},
-		{nrn(report.MakeNodeMetadataWith(map[string]string{report.HostNodeID: report.MakeHostNodeID("foo"), endpoint.Addr: "10.0.0.1", endpoint.Port: "20001"})), true},
+		{nrn(report.MakeNode()), false},
+		{nrn(report.MakeNodeWith(map[string]string{endpoint.Addr: "1.2.3.4"})), false},
+		{nrn(report.MakeNodeWith(map[string]string{endpoint.Port: "1234"})), false},
+		{nrn(report.MakeNodeWith(map[string]string{endpoint.Addr: "1.2.3.4", endpoint.Port: "1234"})), true},
+		{nrn(report.MakeNodeWith(map[string]string{endpoint.Addr: "1.2.3.4", endpoint.Port: "40000"})), true},
+		{nrn(report.MakeNodeWith(map[string]string{report.HostNodeID: report.MakeHostNodeID("foo"), endpoint.Addr: "10.0.0.1", endpoint.Port: "20001"})), true},
 	} {
 		testMap(t, render.MapEndpointIdentity, input)
 	}
@@ -30,8 +30,8 @@ func TestMapEndpointIdentity(t *testing.T) {
 
 func TestMapProcessIdentity(t *testing.T) {
 	for _, input := range []testcase{
-		{nrn(report.MakeNodeMetadata()), false},
-		{nrn(report.MakeNodeMetadataWith(map[string]string{process.PID: "201"})), true},
+		{nrn(report.MakeNode()), false},
+		{nrn(report.MakeNodeWith(map[string]string{process.PID: "201"})), true},
 	} {
 		testMap(t, render.MapProcessIdentity, input)
 	}
@@ -39,8 +39,8 @@ func TestMapProcessIdentity(t *testing.T) {
 
 func TestMapContainerIdentity(t *testing.T) {
 	for _, input := range []testcase{
-		{nrn(report.MakeNodeMetadata()), false},
-		{nrn(report.MakeNodeMetadataWith(map[string]string{docker.ContainerID: "a1b2c3"})), true},
+		{nrn(report.MakeNode()), false},
+		{nrn(report.MakeNodeWith(map[string]string{docker.ContainerID: "a1b2c3"})), true},
 	} {
 		testMap(t, render.MapContainerIdentity, input)
 	}
@@ -48,8 +48,8 @@ func TestMapContainerIdentity(t *testing.T) {
 
 func TestMapContainerImageIdentity(t *testing.T) {
 	for _, input := range []testcase{
-		{nrn(report.MakeNodeMetadata()), false},
-		{nrn(report.MakeNodeMetadataWith(map[string]string{docker.ImageID: "a1b2c3"})), true},
+		{nrn(report.MakeNode()), false},
+		{nrn(report.MakeNodeWith(map[string]string{docker.ImageID: "a1b2c3"})), true},
 	} {
 		testMap(t, render.MapContainerImageIdentity, input)
 	}
@@ -57,8 +57,8 @@ func TestMapContainerImageIdentity(t *testing.T) {
 
 func TestMapAddressIdentity(t *testing.T) {
 	for _, input := range []testcase{
-		{nrn(report.MakeNodeMetadata()), false},
-		{nrn(report.MakeNodeMetadataWith(map[string]string{endpoint.Addr: "192.168.1.1"})), true},
+		{nrn(report.MakeNode()), false},
+		{nrn(report.MakeNodeWith(map[string]string{endpoint.Addr: "192.168.1.1"})), true},
 	} {
 		testMap(t, render.MapAddressIdentity, input)
 	}
@@ -66,7 +66,7 @@ func TestMapAddressIdentity(t *testing.T) {
 
 func TestMapHostIdentity(t *testing.T) {
 	for _, input := range []testcase{
-		{nrn(report.MakeNodeMetadata()), true}, // TODO it's questionable if this is actually correct
+		{nrn(report.MakeNode()), true}, // TODO it's questionable if this is actually correct
 	} {
 		testMap(t, render.MapHostIdentity, input)
 	}

render/render.go

@@ -135,7 +135,7 @@ func (c CustomRenderer) Render(rpt report.Report) RenderableNodes {
 	return c.RenderFunc(c.Renderer.Render(rpt))
 }
 
-// IsConnected is the key added to NodeMetadata by ColorConnected
+// IsConnected is the key added to Node.Metadata by ColorConnected
 // to indicate a node has an edge pointing to it or from it
 const IsConnected = "is_connected"
 
@@ -143,7 +143,7 @@ const IsConnected = "is_connected"
 func OnlyConnected(input RenderableNodes) RenderableNodes {
 	output := RenderableNodes{}
 	for id, node := range ColorConnected(input) {
-		if _, ok := node.NodeMetadata.Metadata[IsConnected]; ok {
+		if _, ok := node.Node.Metadata[IsConnected]; ok {
 			output[id] = node
 		}
 	}
@@ -178,7 +178,7 @@ func ColorConnected(input RenderableNodes) RenderableNodes {
 
 	for id := range connected {
 		node := input[id]
-		node.NodeMetadata.Metadata[IsConnected] = "true"
+		node.Node.Metadata[IsConnected] = "true"
 		input[id] = node
 	}
 	return input

render/render_test.go

@@ -98,13 +98,13 @@ func TestMapRender3(t *testing.T) {
 			return render.RenderableNodes{id: render.NewRenderableNode(id)}
 		},
 		Renderer: mockRenderer{RenderableNodes: render.RenderableNodes{
-			"foo": render.NewRenderableNode("foo").WithNodeMetadata(report.MakeNodeMetadata().WithAdjacent("baz")),
-			"baz": render.NewRenderableNode("baz").WithNodeMetadata(report.MakeNodeMetadata().WithAdjacent("foo")),
+			"foo": render.NewRenderableNode("foo").WithNode(report.MakeNode().WithAdjacent("baz")),
+			"baz": render.NewRenderableNode("baz").WithNode(report.MakeNode().WithAdjacent("foo")),
 		}},
 	}
 	want := render.RenderableNodes{
-		"_foo": render.NewRenderableNode("_foo").WithNodeMetadata(report.MakeNodeMetadata().WithAdjacent("_baz")),
-		"_baz": render.NewRenderableNode("_baz").WithNodeMetadata(report.MakeNodeMetadata().WithAdjacent("_foo")),
+		"_foo": render.NewRenderableNode("_foo").WithNode(report.MakeNode().WithAdjacent("_baz")),
+		"_baz": render.NewRenderableNode("_baz").WithNode(report.MakeNode().WithAdjacent("_foo")),
 	}
 	have := mapper.Render(report.MakeReport())
 	if !reflect.DeepEqual(want, have) {
@@ -115,15 +115,15 @@ func TestMapRender3(t *testing.T) {
 func TestMapEdge(t *testing.T) {
 	selector := render.TopologySelector(func(_ report.Report) render.RenderableNodes {
 		return render.MakeRenderableNodes(report.Topology{
-			NodeMetadatas: report.NodeMetadatas{
-				"foo": report.MakeNodeMetadata().WithMetadata(map[string]string{
+			Nodes: report.Nodes{
+				"foo": report.MakeNode().WithMetadata(map[string]string{
 					"id": "foo",
 				}).WithEdge("bar", report.EdgeMetadata{
 					EgressPacketCount: newu64(1),
 					EgressByteCount:   newu64(2),
 				}),
 
-				"bar": report.MakeNodeMetadata().WithMetadata(map[string]string{
+				"bar": report.MakeNode().WithMetadata(map[string]string{
 					"id": "bar",
 				}).WithEdge("foo", report.EdgeMetadata{
 					EgressPacketCount: newu64(3),
@@ -144,18 +144,18 @@ func TestMapEdge(t *testing.T) {
 	have := expected.Sterilize(mapper.Render(report.MakeReport()))
 	want := expected.Sterilize(render.RenderableNodes{
 		"_foo": {
-			ID:           "_foo",
-			Origins:      report.MakeIDList("foo"),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent("_bar"),
+			ID:      "_foo",
+			Origins: report.MakeIDList("foo"),
+			Node:    report.MakeNode().WithAdjacent("_bar"),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(4),
 				EgressByteCount:   newu64(6),
 			},
 		},
 		"_bar": {
-			ID:           "_bar",
-			Origins:      report.MakeIDList("bar"),
-			NodeMetadata: report.MakeNodeMetadata().WithAdjacent("_foo"),
+			ID:      "_bar",
+			Origins: report.MakeIDList("bar"),
+			Node:    report.MakeNode().WithAdjacent("_foo"),
 			EdgeMetadata: report.EdgeMetadata{
 				EgressPacketCount: newu64(4),
 				EgressByteCount:   newu64(6),
@@ -177,13 +177,13 @@ func TestMapEdge(t *testing.T) {
 func TestFilterRender(t *testing.T) {
 	renderer := render.FilterUnconnected(
 		mockRenderer{RenderableNodes: render.RenderableNodes{
-			"foo": {ID: "foo", NodeMetadata: report.MakeNodeMetadata().WithAdjacent("bar")},
-			"bar": {ID: "bar", NodeMetadata: report.MakeNodeMetadata().WithAdjacent("foo")},
-			"baz": {ID: "baz", NodeMetadata: report.MakeNodeMetadata()},
+			"foo": {ID: "foo", Node: report.MakeNode().WithAdjacent("bar")},
+			"bar": {ID: "bar", Node: report.MakeNode().WithAdjacent("foo")},
+			"baz": {ID: "baz", Node: report.MakeNode()},
 		}})
 	want := render.RenderableNodes{
-		"foo": {ID: "foo", NodeMetadata: report.MakeNodeMetadata().WithAdjacent("bar")},
-		"bar": {ID: "bar", NodeMetadata: report.MakeNodeMetadata().WithAdjacent("foo")},
+		"foo": {ID: "foo", Node: report.MakeNode().WithAdjacent("bar")},
+		"bar": {ID: "bar", Node: report.MakeNode().WithAdjacent("foo")},
 	}
 	have := expected.Sterilize(renderer.Render(report.MakeReport()))
 	if !reflect.DeepEqual(want, have) {

render/renderable_node.go

@@ -16,7 +16,7 @@ type RenderableNode struct {
 	Origins    report.IDList `json:"origins,omitempty"`     // Core node IDs that contributed information
 
 	report.EdgeMetadata `json:"metadata"` // Numeric sums
-	report.NodeMetadata
+	report.Node
 }
 
 // NewRenderableNode makes a new RenderableNode
@@ -29,7 +29,7 @@ func NewRenderableNode(id string) RenderableNode {
 		Pseudo:       false,
 		Origins:      report.MakeIDList(),
 		EdgeMetadata: report.EdgeMetadata{},
-		NodeMetadata: report.MakeNodeMetadata(),
+		Node:         report.MakeNode(),
 	}
 }
 
@@ -43,7 +43,7 @@ func NewRenderableNodeWith(id, major, minor, rank string, rn RenderableNode) Ren
 		Pseudo:       false,
 		Origins:      rn.Origins.Copy(),
 		EdgeMetadata: rn.EdgeMetadata.Copy(),
-		NodeMetadata: rn.NodeMetadata.Copy(),
+		Node:         rn.Node.Copy(),
 	}
 }
 
@@ -57,7 +57,7 @@ func NewDerivedNode(id string, node RenderableNode) RenderableNode {
 		Pseudo:       node.Pseudo,
 		Origins:      node.Origins.Copy(),
 		EdgeMetadata: node.EdgeMetadata.Copy(),
-		NodeMetadata: node.NodeMetadata.Copy(),
+		Node:         node.Node.Copy(),
 	}
 }
 
@@ -70,14 +70,14 @@ func newDerivedPseudoNode(id, major string, node RenderableNode) RenderableNode
 		Pseudo:       true,
 		Origins:      node.Origins.Copy(),
 		EdgeMetadata: node.EdgeMetadata.Copy(),
-		NodeMetadata: node.NodeMetadata.Copy(),
+		Node:         node.Node.Copy(),
 	}
 }
 
-// WithNodeMetadata creates a new RenderableNode based on rn, with n
-func (rn RenderableNode) WithNodeMetadata(n report.NodeMetadata) RenderableNode {
+// WithNode creates a new RenderableNode based on rn, with n
+func (rn RenderableNode) WithNode(n report.Node) RenderableNode {
 	result := rn.Copy()
-	result.NodeMetadata = result.NodeMetadata.Merge(n)
+	result.Node = result.Node.Merge(n)
 	return result
 }
 
@@ -103,7 +103,7 @@ func (rn RenderableNode) Merge(other RenderableNode) RenderableNode {
 
 	result.Origins = rn.Origins.Merge(other.Origins)
 	result.EdgeMetadata = rn.EdgeMetadata.Merge(other.EdgeMetadata)
-	result.NodeMetadata = rn.NodeMetadata.Merge(other.NodeMetadata)
+	result.Node = rn.Node.Merge(other.Node)
 
 	return result
 }
@@ -118,7 +118,7 @@ func (rn RenderableNode) Copy() RenderableNode {
 		Pseudo:       rn.Pseudo,
 		Origins:      rn.Origins.Copy(),
 		EdgeMetadata: rn.EdgeMetadata.Copy(),
-		NodeMetadata: rn.NodeMetadata.Copy(),
+		Node:         rn.Node.Copy(),
 	}
 }
 

render/renderable_node_test.go

@@ -32,22 +32,22 @@ func TestMergeRenderableNodes(t *testing.T) {
 
 func TestMergeRenderableNode(t *testing.T) {
 	node1 := render.RenderableNode{
-		ID:           "foo",
-		LabelMajor:   "",
-		LabelMinor:   "minor",
-		Rank:         "",
-		Pseudo:       false,
-		NodeMetadata: report.MakeNodeMetadata().WithAdjacent("a1"),
-		Origins:      report.MakeIDList("o1"),
+		ID:         "foo",
+		LabelMajor: "",
+		LabelMinor: "minor",
+		Rank:       "",
+		Pseudo:     false,
+		Node:       report.MakeNode().WithAdjacent("a1"),
+		Origins:    report.MakeIDList("o1"),
 	}
 	node2 := render.RenderableNode{
-		ID:           "foo",
-		LabelMajor:   "major",
-		LabelMinor:   "",
-		Rank:         "rank",
-		Pseudo:       false,
-		NodeMetadata: report.MakeNodeMetadata().WithAdjacent("a2"),
-		Origins:      report.MakeIDList("o2"),
+		ID:         "foo",
+		LabelMajor: "major",
+		LabelMinor: "",
+		Rank:       "rank",
+		Pseudo:     false,
+		Node:       report.MakeNode().WithAdjacent("a2"),
+		Origins:    report.MakeIDList("o2"),
 	}
 	want := render.RenderableNode{
 		ID:           "foo",
@@ -55,7 +55,7 @@ func TestMergeRenderableNode(t *testing.T) {
 		LabelMinor:   "minor",
 		Rank:         "rank",
 		Pseudo:       false,
-		NodeMetadata: report.MakeNodeMetadata().WithAdjacency(report.MakeIDList("a1", "a2")),
+		Node:         report.MakeNode().WithAdjacency(report.MakeIDList("a1", "a2")),
 		Origins:      report.MakeIDList("o1", "o2"),
 		EdgeMetadata: report.EdgeMetadata{},
 	}

render/selectors.go

@@ -32,8 +32,8 @@ func (t TopologySelector) EdgeMetadata(rpt report.Report, srcID, dstID string) r
 // MakeRenderableNodes converts a topology to a set of RenderableNodes
 func MakeRenderableNodes(t report.Topology) RenderableNodes {
 	result := RenderableNodes{}
-	for id, nmd := range t.NodeMetadatas {
-		rn := NewRenderableNode(id).WithNodeMetadata(nmd)
+	for id, nmd := range t.Nodes {
+		rn := NewRenderableNode(id).WithNode(nmd)
 		rn.Origins = report.MakeIDList(id)
 		if hostNodeID, ok := nmd.Metadata[report.HostNodeID]; ok {
 			rn.Origins = rn.Origins.Add(hostNodeID)

render/theinternet.go

@@ -18,7 +18,7 @@ func LocalNetworks(r report.Report) report.Networks {
 		networks = map[string]struct{}{}
 	)
 
-	for _, md := range r.Host.NodeMetadatas {
+	for _, md := range r.Host.Nodes {
 		val, ok := md.Metadata[host.LocalNetworks]
 		if !ok {
 			continue

render/theinternet_test.go

@@ -14,9 +14,9 @@ import (
 func TestReportLocalNetworks(t *testing.T) {
 	r := report.MakeReport().Merge(report.Report{
 		Host: report.Topology{
-			NodeMetadatas: report.NodeMetadatas{
-				"nonets": report.MakeNodeMetadata(),
-				"foo": report.MakeNodeMetadataWith(map[string]string{
+			Nodes: report.Nodes{
+				"nonets": report.MakeNode(),
+				"foo": report.MakeNodeWith(map[string]string{
 					host.LocalNetworks: "10.0.0.1/8 192.168.1.1/24 10.0.0.1/8 badnet/33",
 				}),
 			},

render/topologies.go

@@ -41,11 +41,11 @@ func (r ProcessWithContainerNameRenderer) Render(rpt report.Report) RenderableNo
 	}.Render(rpt)
 
 	for id, p := range processes {
-		pid, ok := p.NodeMetadata.Metadata[process.PID]
+		pid, ok := p.Node.Metadata[process.PID]
 		if !ok {
 			continue
 		}
-		containerID, ok := p.NodeMetadata.Metadata[docker.ContainerID]
+		containerID, ok := p.Node.Metadata[docker.ContainerID]
 		if !ok {
 			continue
 		}
@@ -53,7 +53,7 @@ func (r ProcessWithContainerNameRenderer) Render(rpt report.Report) RenderableNo
 		if !ok {
 			continue
 		}
-		p.LabelMinor = fmt.Sprintf("%s (%s:%s)", report.ExtractHostID(p.NodeMetadata), container.LabelMajor, pid)
+		p.LabelMinor = fmt.Sprintf("%s (%s:%s)", report.ExtractHostID(p.Node), container.LabelMajor, pid)
 		processes[id] = p
 	}
 
@@ -86,8 +86,8 @@ var ContainerRenderer = MakeReduce(
 		// including the ProcessRenderer once.
 		Renderer: Filter{
 			f: func(n RenderableNode) bool {
-				_, inContainer := n.NodeMetadata.Metadata[docker.ContainerID]
-				_, isConnected := n.NodeMetadata.Metadata[IsConnected]
+				_, inContainer := n.Node.Metadata[docker.ContainerID]
+				_, isConnected := n.Node.Metadata[IsConnected]
 				return inContainer || isConnected
 			},
 			Renderer: CustomRenderer{

render/topology_diff_test.go

@@ -19,11 +19,11 @@ func (r ByID) Less(i, j int) bool { return r[i].ID < r[j].ID }
 
 func TestTopoDiff(t *testing.T) {
 	nodea := render.RenderableNode{
-		ID:           "nodea",
-		LabelMajor:   "Node A",
-		LabelMinor:   "'ts an a",
-		Pseudo:       false,
-		NodeMetadata: report.MakeNodeMetadata().WithAdjacent("nodeb"),
+		ID:         "nodea",
+		LabelMajor: "Node A",
+		LabelMinor: "'ts an a",
+		Pseudo:     false,
+		Node:       report.MakeNode().WithAdjacent("nodeb"),
 	}
 	nodeap := nodea
 	nodeap.Adjacency = []string{