Remove address topology

probe/endpoint/reporter.go

@@ -165,62 +165,38 @@ func (r *Reporter) Report() (report.Report, error) {
 }
 
 func (r *Reporter) addConnection(rpt *report.Report, t fourTuple, extraFromNode, extraToNode *report.Node) {
-	// Update address topology
-	{
-		var (
-			fromAddressNodeID = report.MakeAddressNodeID(r.hostID, t.fromAddr)
-			toAddressNodeID   = report.MakeAddressNodeID(r.hostID, t.toAddr)
-			fromNode          = report.MakeNodeWith(map[string]string{Addr: t.fromAddr}).WithEdge(toAddressNodeID, report.EdgeMetadata{})
-			toNode            = report.MakeNodeWith(map[string]string{Addr: t.toAddr})
-		)
-
-		// In case we have a reverse resolution for the IP, we can use it for
-		// the name...
-		if toNames, err := r.reverseResolver.get(t.toAddr); err == nil {
-			toNode = toNode.WithSet("name", report.MakeStringSet(toNames...))
-		}
-
-		if extraFromNode != nil {
-			fromNode = fromNode.Merge(*extraFromNode)
-		}
-		if extraToNode != nil {
-			toNode = toNode.Merge(*extraToNode)
-		}
-		rpt.Address = rpt.Address.AddNode(fromAddressNodeID, fromNode)
-		rpt.Address = rpt.Address.AddNode(toAddressNodeID, toNode)
+	// Update endpoint topology
+	if !r.includeProcesses {
+		return
 	}
+	var (
+		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{
+			Addr: t.fromAddr,
+			Port: strconv.Itoa(int(t.fromPort)),
+		}).WithEdge(toEndpointNodeID, report.EdgeMetadata{})
+		toNode = report.MakeNodeWith(map[string]string{
+			Addr: t.toAddr,
+			Port: strconv.Itoa(int(t.toPort)),
+		})
+	)
 
-	// Update endpoint topology
-	if r.includeProcesses {
-		var (
-			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{
-				Addr: t.fromAddr,
-				Port: strconv.Itoa(int(t.fromPort)),
-			}).WithEdge(toEndpointNodeID, report.EdgeMetadata{})
-			toNode = report.MakeNodeWith(map[string]string{
-				Addr: t.toAddr,
-				Port: strconv.Itoa(int(t.toPort)),
-			})
-		)
-
-		// In case we have a reverse resolution for the IP, we can use it for
-		// the name...
-		if toNames, err := r.reverseResolver.get(t.toAddr); err == nil {
-			toNode = toNode.WithSet("name", report.MakeStringSet(toNames...))
-		}
+	// In case we have a reverse resolution for the IP, we can use it for
+	// the name...
+	if toNames, err := r.reverseResolver.get(t.toAddr); err == nil {
+		toNode = toNode.WithSet("name", report.MakeStringSet(toNames...))
+	}
 
-		if extraFromNode != nil {
-			fromNode = fromNode.Merge(*extraFromNode)
-		}
-		if extraToNode != nil {
-			toNode = toNode.Merge(*extraToNode)
-		}
-		rpt.Endpoint = rpt.Endpoint.AddNode(fromEndpointNodeID, fromNode)
-		rpt.Endpoint = rpt.Endpoint.AddNode(toEndpointNodeID, toNode)
+	if extraFromNode != nil {
+		fromNode = fromNode.Merge(*extraFromNode)
+	}
+	if extraToNode != nil {
+		toNode = toNode.Merge(*extraToNode)
 	}
+	rpt.Endpoint = rpt.Endpoint.AddNode(fromEndpointNodeID, fromNode)
+	rpt.Endpoint = rpt.Endpoint.AddNode(toEndpointNodeID, toNode)
 }
 
 func newu64(i uint64) *uint64 {

probe/topology_tagger.go

@@ -18,7 +18,6 @@ func (topologyTagger) Name() string { return "Topology" }
 func (topologyTagger) Tag(r report.Report) (report.Report, error) {
 	for name, t := range map[string]*report.Topology{
 		report.Endpoint:       &(r.Endpoint),
-		report.Address:        &(r.Address),
 		report.Process:        &(r.Process),
 		report.Container:      &(r.Container),
 		report.ContainerImage: &(r.ContainerImage),

render/expected/expected.go

@@ -415,51 +415,6 @@ var (
 		render.OutgoingInternetID: theOutgoingInternetNode,
 	}).Prune()
 
-	ClientAddressID         = render.MakeAddressID(fixture.ClientHostID, fixture.ClientIP)
-	ServerAddressID         = render.MakeAddressID(fixture.ServerHostID, fixture.ServerIP)
-	unknownPseudoAddress1ID = render.MakePseudoNodeID("10.10.10.10", fixture.ServerIP)
-	unknownPseudoAddress2ID = render.MakePseudoNodeID("10.10.10.11", fixture.ServerIP)
-
-	RenderedAddresses = (render.RenderableNodes{
-		ClientAddressID: {
-			ID:         ClientAddressID,
-			LabelMajor: fixture.ClientIP,
-			LabelMinor: fixture.ClientHostID,
-			Shape:      circle,
-			Node:       report.MakeNode().WithAdjacent(ServerAddressID),
-		},
-		ServerAddressID: {
-			ID:         ServerAddressID,
-			LabelMajor: fixture.ServerIP,
-			LabelMinor: fixture.ServerHostID,
-			Shape:      circle,
-			Node:       report.MakeNode(),
-		},
-		unknownPseudoAddress1ID: {
-			ID:         unknownPseudoAddress1ID,
-			LabelMajor: "10.10.10.10",
-			Pseudo:     true,
-			Shape:      circle,
-			Node:       report.MakeNode().WithAdjacent(ServerAddressID),
-		},
-		unknownPseudoAddress2ID: {
-			ID:         unknownPseudoAddress2ID,
-			LabelMajor: "10.10.10.11",
-			Pseudo:     true,
-			Shape:      circle,
-			Node:       report.MakeNode().WithAdjacent(ServerAddressID),
-		},
-		render.IncomingInternetID: {
-			ID:           render.IncomingInternetID,
-			LabelMajor:   render.InboundMajor,
-			LabelMinor:   render.InboundMinor,
-			Pseudo:       true,
-			Shape:        cloud,
-			Node:         report.MakeNode().WithAdjacent(ServerAddressID),
-			EdgeMetadata: report.EdgeMetadata{},
-		},
-	}).Prune()
-
 	ServerHostID  = render.MakeHostID(fixture.ServerHostID)
 	ClientHostID  = render.MakeHostID(fixture.ClientHostID)
 	pseudoHostID1 = render.MakePseudoNodeID(fixture.UnknownClient1IP, fixture.ServerIP)
@@ -479,7 +434,6 @@ var (
 				RenderedProcesses[ClientProcess2ID],
 				RenderedContainers[ClientContainerID],
 				RenderedContainerImages[ClientContainerImageID],
-				RenderedAddresses[ClientAddressID],
 			),
 			Node: report.MakeNode().WithAdjacent(ServerHostID),
 			EdgeMetadata: report.EdgeMetadata{
@@ -500,8 +454,6 @@ var (
 				RenderedContainers[ServerContainerID],
 				RenderedContainerImages[ServerContainerImageID],
 
-				RenderedAddresses[ServerAddressID],
-
 				// See #1102
 				// RemappedEndpoints[NonContainerEndpointID],
 				// RenderedEndpoints[NonContainerPseudoEndpointID],
@@ -523,7 +475,6 @@ var (
 			EdgeMetadata: report.EdgeMetadata{},
 			Children:     render.MakeRenderableNodeSet(
 			// RenderedEndpoints[unknownPseudoNode2ID],
-			// RenderedAddresses[unknownPseudoAddress1ID],
 			),
 		},
 		pseudoHostID2: {
@@ -535,7 +486,6 @@ var (
 			EdgeMetadata: report.EdgeMetadata{},
 			Children:     render.MakeRenderableNodeSet(
 			// RenderedEndpoints[unknownPseudoNode2ID],
-			// RenderedAddresses[unknownPseudoAddress2ID],
 			),
 		},
 		render.IncomingInternetID: {

render/id.go

@@ -29,11 +29,6 @@ func MakeProcessID(hostID, pid string) string {
 	return makeID("process", hostID, pid)
 }
 
-// MakeAddressID makes an address node ID for rendered nodes.
-func MakeAddressID(hostID, addr string) string {
-	return makeID("address", hostID, addr)
-}
-
 // MakeContainerID makes a container node ID for rendered nodes.
 func MakeContainerID(containerID string) string {
 	return makeID("container", containerID)

render/mapping.go

@@ -213,50 +213,6 @@ func MapServiceIdentity(m RenderableNode, _ report.Networks) RenderableNodes {
 	return RenderableNodes{id: node}
 }
 
-// MapAddressIdentity maps an address topology node to an address renderable
-// node. As it is only ever run on address topology nodes, we expect that
-// certain keys are present.
-func MapAddressIdentity(m RenderableNode, local report.Networks) RenderableNodes {
-	addr, ok := m.Latest.Lookup(endpoint.Addr)
-	if !ok {
-		return RenderableNodes{}
-	}
-
-	// Conntracked connections don't have a host id unless
-	// they were merged with a procspied connection.  Filter
-	// out those that weren't.
-	_, hasHostID := m.Latest.Lookup(report.HostNodeID)
-	_, conntracked := m.Latest.Lookup(endpoint.Conntracked)
-	if !hasHostID && conntracked {
-		return RenderableNodes{}
-	}
-
-	// Nodes without a hostid are treated as psuedo nodes
-	if !hasHostID {
-		// If the addr is not in a network local to this report, we emit an
-		// internet node
-		if ip := net.ParseIP(addr); ip != nil && !local.Contains(ip) {
-			return RenderableNodes{TheInternetID: theInternetNode(m)}
-		}
-
-		// Otherwise generate a pseudo node for every
-		outputID := MakePseudoNodeID(addr, "")
-		if len(m.Adjacency) > 0 {
-			_, dstAddr, _ := report.ParseAddressNodeID(m.Adjacency[0])
-			outputID = MakePseudoNodeID(addr, dstAddr)
-		}
-		return RenderableNodes{outputID: newDerivedPseudoNode(outputID, addr, m)}
-	}
-
-	var (
-		id    = MakeAddressID(report.ExtractHostID(m.Node), addr)
-		major = addr
-		minor = report.ExtractHostID(m.Node)
-	)
-
-	return RenderableNodes{id: NewRenderableNodeWith(id, major, minor, "", m)}
-}
-
 // MapHostIdentity maps a host topology node to a host renderable node. As it
 // is only ever run on host topology nodes, we expect that certain keys are
 // present.

render/mapping_test.go

@@ -67,15 +67,6 @@ func TestMapContainerImageIdentity(t *testing.T) {
 	}
 }
 
-func TestMapAddressIdentity(t *testing.T) {
-	for _, input := range []testcase{
-		{"empty", nrn(report.MakeNode()), false},
-		{"basic address", nrn(report.MakeNodeWith(map[string]string{endpoint.Addr: "192.168.1.1"})), true},
-	} {
-		testMap(t, render.MapAddressIdentity, input)
-	}
-}
-
 func TestMapHostIdentity(t *testing.T) {
 	for _, input := range []testcase{
 		{"empty", nrn(report.MakeNode()), true}, // TODO it's questionable if this is actually correct

render/selectors.go

@@ -60,11 +60,6 @@ var (
 		return MakeRenderableNodes(r.ContainerImage)
 	})
 
-	// SelectAddress selects the address topology.
-	SelectAddress = TopologySelector(func(r report.Report) RenderableNodes {
-		return MakeRenderableNodes(r.Address)
-	})
-
 	// SelectHost selects the address topology.
 	SelectHost = TopologySelector(func(r report.Report) RenderableNodes {
 		return MakeRenderableNodes(r.Host)

render/topologies.go

@@ -231,15 +231,8 @@ var ContainerHostnameRenderer = MakeMap(
 	),
 )
 
-// AddressRenderer is a Renderer which produces a renderable address
-// graph from the address topology.
-var AddressRenderer = MakeMap(
-	MapAddressIdentity,
-	SelectAddress,
-)
-
 // HostRenderer is a Renderer which produces a renderable host
-// graph from the host topology and address graph.
+// graph from the host topology.
 var HostRenderer = MakeReduce(
 	MakeMap(
 		MapX2Host,
@@ -252,10 +245,6 @@ var HostRenderer = MakeReduce(
 			SelectPod,
 		),
 	),
-	MakeMap(
-		MapX2Host,
-		AddressRenderer,
-	),
 	MakeMap(
 		MapHostIdentity,
 		SelectHost,

render/topologies_test.go

@@ -87,14 +87,6 @@ func TestContainerImageRenderer(t *testing.T) {
 	}
 }
 
-func TestAddressRenderer(t *testing.T) {
-	have := render.AddressRenderer.Render(fixture.Report).Prune()
-	want := expected.RenderedAddresses
-	if !reflect.DeepEqual(want, have) {
-		t.Error(test.Diff(want, have))
-	}
-}
-
 func TestHostRenderer(t *testing.T) {
 	have := render.HostRenderer.Render(fixture.Report).Prune()
 	want := expected.RenderedHosts

report/report.go

@@ -10,7 +10,6 @@ import (
 // Names of the various topologies.
 const (
 	Endpoint       = "endpoint"
-	Address        = "address"
 	Process        = "process"
 	Container      = "container"
 	Pod            = "pod"
@@ -29,11 +28,6 @@ type Report struct {
 	// be traced back to a process. Edges are present.
 	Endpoint Topology
 
-	// Address nodes are addresses (e.g. ifconfig) on each host. Certain
-	// information may be present in this topology that can't be mapped to
-	// endpoints (e.g. ICMP). Edges are present.
-	Address Topology
-
 	// Process nodes are processes on each host. Edges are not present.
 	Process Topology
 
@@ -93,7 +87,6 @@ type Report struct {
 func MakeReport() Report {
 	return Report{
 		Endpoint:       MakeTopology(),
-		Address:        MakeTopology(),
 		Process:        MakeTopology(),
 		Container:      MakeTopology(),
 		ContainerImage: MakeTopology(),
@@ -111,7 +104,6 @@ func MakeReport() Report {
 func (r Report) Copy() Report {
 	return Report{
 		Endpoint:       r.Endpoint.Copy(),
-		Address:        r.Address.Copy(),
 		Process:        r.Process.Copy(),
 		Container:      r.Container.Copy(),
 		ContainerImage: r.ContainerImage.Copy(),
@@ -130,7 +122,6 @@ func (r Report) Copy() Report {
 func (r Report) Merge(other Report) Report {
 	cp := r.Copy()
 	cp.Endpoint = r.Endpoint.Merge(other.Endpoint)
-	cp.Address = r.Address.Merge(other.Address)
 	cp.Process = r.Process.Merge(other.Process)
 	cp.Container = r.Container.Merge(other.Container)
 	cp.ContainerImage = r.ContainerImage.Merge(other.ContainerImage)
@@ -147,7 +138,6 @@ func (r Report) Merge(other Report) Report {
 func (r Report) Topologies() []Topology {
 	return []Topology{
 		r.Endpoint,
-		r.Address,
 		r.Process,
 		r.Container,
 		r.ContainerImage,