Deal with directed edges in the rest of the codebase.

2026-07-28 09:41:57 +00:00 · 2015-08-17 11:02:56 +00:00
parent 89df11bbfd
commit 60d1b503c1
7 changed files with 195 additions and 165 deletions
--- a/app/api_topology_test.go
+++ b/app/api_topology_test.go
@@ -132,7 +132,7 @@ func TestAPITopologyHosts(t *testing.T) {
 		// Let's not unit-test the specific content of the detail tables
 	}
 	{
-		body := getRawJSON(t, ts, fmt.Sprintf("/api/topology/hosts/%s/%s", expected.ServerHostRenderedID, expected.ClientHostRenderedID))
+		body := getRawJSON(t, ts, fmt.Sprintf("/api/topology/hosts/%s/%s", expected.ClientHostRenderedID, expected.ServerHostRenderedID))
 		var edge APIEdge
 		if err := json.Unmarshal(body, &edge); err != nil {
 			t.Fatalf("JSON parse error: %s", err)
--- a/render/detailed_node_test.go
+++ b/render/detailed_node_test.go
@@ -1,7 +1,7 @@
 package render_test

 import (
-	"fmt"
+	//	"fmt"
 	"reflect"
 	"testing"

@@ -121,15 +121,15 @@ func TestMakeDetailedContainerNode(t *testing.T) {
 		LabelMinor: test.ServerHostName,
 		Pseudo:     false,
 		Tables: []render.Table{
-			{
-				Title:   "Connections",
-				Numeric: true,
-				Rank:    100,
-				Rows: []render.Row{
-					{"Egress packet rate", "75", "packets/sec"},
-					{"Egress byte rate", "750", "Bps"},
-				},
-			},
+			//			{
+			//				Title:   "Connections",
+			//				Numeric: true,
+			//				Rank:    100,
+			//				Rows: []render.Row{
+			//					{"Egress packet rate", "75", "packets/sec"},
+			//					{"Egress byte rate", "750", "Bps"},
+			//				},
+			//			},
 			{
 				Title:   "Origin Container",
 				Numeric: false,
@@ -159,43 +159,43 @@ func TestMakeDetailedContainerNode(t *testing.T) {
 					{"Operating system", "Linux", ""},
 				},
 			},
-			{
-				Title:   "Connection Details",
-				Numeric: false,
-				Rows: []render.Row{
-					{"Local", "Remote", ""},
-					{
-						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
-						fmt.Sprintf("%s:%s", test.UnknownClient1IP, test.ClientPort54010),
-						"",
-					},
-					{
-						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
-						fmt.Sprintf("%s:%s", test.UnknownClient1IP, test.ClientPort54020),
-						"",
-					},
-					{
-						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
-						fmt.Sprintf("%s:%s", test.UnknownClient3IP, test.ClientPort54020),
-						"",
-					},
-					{
-						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
-						fmt.Sprintf("%s:%s", test.ClientIP, test.ClientPort54001),
-						"",
-					},
-					{
-						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
-						fmt.Sprintf("%s:%s", test.ClientIP, test.ClientPort54002),
-						"",
-					},
-					{
-						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
-						fmt.Sprintf("%s:%s", test.RandomClientIP, test.ClientPort12345),
-						"",
-					},
-				},
-			},
+			//			{
+			//				Title:   "Connection Details",
+			//				Numeric: false,
+			//				Rows: []render.Row{
+			//					{"Local", "Remote", ""},
+			//					{
+			//						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
+			//						fmt.Sprintf("%s:%s", test.UnknownClient1IP, test.ClientPort54010),
+			//						"",
+			//					},
+			//					{
+			//						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
+			//						fmt.Sprintf("%s:%s", test.UnknownClient1IP, test.ClientPort54020),
+			//						"",
+			//					},
+			//					{
+			//						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
+			//						fmt.Sprintf("%s:%s", test.UnknownClient3IP, test.ClientPort54020),
+			//						"",
+			//					},
+			//					{
+			//						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
+			//						fmt.Sprintf("%s:%s", test.ClientIP, test.ClientPort54001),
+			//						"",
+			//					},
+			//					{
+			//						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
+			//						fmt.Sprintf("%s:%s", test.ClientIP, test.ClientPort54002),
+			//						"",
+			//					},
+			//					{
+			//						fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort),
+			//						fmt.Sprintf("%s:%s", test.RandomClientIP, test.ClientPort12345),
+			//						"",
+			//					},
+			//				},
+			//			},
 		},
 	}
 	if !reflect.DeepEqual(want, have) {
--- a/render/expected/expected.go
+++ b/render/expected/expected.go
@@ -13,28 +13,45 @@ var (
 	uncontainedServerID  = render.MakePseudoNodeID(render.UncontainedID, test.ServerHostName)
 	unknownPseudoNode1ID = render.MakePseudoNodeID("10.10.10.10", test.ServerIP, "80")
 	unknownPseudoNode2ID = render.MakePseudoNodeID("10.10.10.11", test.ServerIP, "80")
-	unknownPseudoNode1   = render.RenderableNode{
-		ID:           unknownPseudoNode1ID,
-		LabelMajor:   "10.10.10.10",
-		Pseudo:       true,
-		NodeMetadata: report.MakeNodeMetadata(),
-		EdgeMetadata: report.EdgeMetadata{},
+	unknownPseudoNode1   = func(adjacency report.IDList) render.RenderableNode {
+		return render.RenderableNode{
+			ID:           unknownPseudoNode1ID,
+			LabelMajor:   "10.10.10.10",
+			Pseudo:       true,
+			NodeMetadata: report.MakeNodeMetadata(),
+			EdgeMetadata: report.EdgeMetadata{
+				EgressPacketCount: newu64(40),
+				EgressByteCount:   newu64(400),
+			},
+			Adjacency: adjacency,
+		}
 	}
-	unknownPseudoNode2 = render.RenderableNode{
-		ID:           unknownPseudoNode2ID,
-		LabelMajor:   "10.10.10.11",
-		Pseudo:       true,
-		NodeMetadata: report.MakeNodeMetadata(),
-		EdgeMetadata: report.EdgeMetadata{},
+	unknownPseudoNode2 = func(adjacency report.IDList) render.RenderableNode {
+		return render.RenderableNode{
+			ID:           unknownPseudoNode2ID,
+			LabelMajor:   "10.10.10.11",
+			Pseudo:       true,
+			NodeMetadata: report.MakeNodeMetadata(),
+			EdgeMetadata: report.EdgeMetadata{
+				EgressPacketCount: newu64(50),
+				EgressByteCount:   newu64(500),
+			},
+			Adjacency: adjacency,
+		}
 	}
-	theInternetNode = render.RenderableNode{
-		ID:           render.TheInternetID,
-		LabelMajor:   render.TheInternetMajor,
-		Pseudo:       true,
-		NodeMetadata: report.MakeNodeMetadata(),
-		EdgeMetadata: report.EdgeMetadata{},
+	theInternetNode = func(adjacency report.IDList) render.RenderableNode {
+		return render.RenderableNode{
+			ID:           render.TheInternetID,
+			LabelMajor:   render.TheInternetMajor,
+			Pseudo:       true,
+			NodeMetadata: report.MakeNodeMetadata(),
+			EdgeMetadata: report.EdgeMetadata{
+				EgressPacketCount: newu64(60),
+				EgressByteCount:   newu64(600),
+			},
+			Adjacency: adjacency,
+		}
 	}
-
 	ClientProcess1ID      = render.MakeProcessID(test.ClientHostID, test.Client1PID)
 	ClientProcess2ID      = render.MakeProcessID(test.ClientHostID, test.Client2PID)
 	ServerProcessID       = render.MakeProcessID(test.ServerHostID, test.ServerPID)
@@ -83,23 +100,14 @@ var (
 			LabelMinor: fmt.Sprintf("%s (%s)", test.ServerHostID, test.ServerPID),
 			Rank:       test.ServerComm,
 			Pseudo:     false,
-			Adjacency: report.MakeIDList(
-				ClientProcess1ID,
-				ClientProcess2ID,
-				unknownPseudoNode1ID,
-				unknownPseudoNode2ID,
-				render.TheInternetID,
-			),
+			Adjacency:  report.MakeIDList(),
 			Origins: report.MakeIDList(
 				test.Server80NodeID,
 				test.ServerProcessNodeID,
 				test.ServerHostNodeID,
 			),
 			NodeMetadata: report.MakeNodeMetadata(),
-			EdgeMetadata: report.EdgeMetadata{
-				EgressPacketCount: newu64(150),
-				EgressByteCount:   newu64(1500),
-			},
+			EdgeMetadata: report.EdgeMetadata{},
 		},
 		nonContainerProcessID: {
 			ID:         nonContainerProcessID,
@@ -115,9 +123,9 @@ var (
 			NodeMetadata: report.MakeNodeMetadata(),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
-		unknownPseudoNode1ID: unknownPseudoNode1,
-		unknownPseudoNode2ID: unknownPseudoNode2,
-		render.TheInternetID: theInternetNode,
+		unknownPseudoNode1ID: unknownPseudoNode1(report.MakeIDList(ServerProcessID)),
+		unknownPseudoNode2ID: unknownPseudoNode2(report.MakeIDList(ServerProcessID)),
+		render.TheInternetID: theInternetNode(report.MakeIDList(ServerProcessID)),
 	}

 	RenderedProcessNames = render.RenderableNodes{
@@ -147,22 +155,14 @@ var (
 			LabelMinor: "",
 			Rank:       "apache",
 			Pseudo:     false,
-			Adjacency: report.MakeIDList(
-				"curl",
-				unknownPseudoNode1ID,
-				unknownPseudoNode2ID,
-				render.TheInternetID,
-			),
+			Adjacency:  report.MakeIDList(),
 			Origins: report.MakeIDList(
 				test.Server80NodeID,
 				test.ServerProcessNodeID,
 				test.ServerHostNodeID,
 			),
 			NodeMetadata: report.MakeNodeMetadata(),
-			EdgeMetadata: report.EdgeMetadata{
-				EgressPacketCount: newu64(150),
-				EgressByteCount:   newu64(1500),
-			},
+			EdgeMetadata: report.EdgeMetadata{},
 		},
 		"bash": {
 			ID:         "bash",
@@ -177,9 +177,9 @@ var (
 			NodeMetadata: report.MakeNodeMetadata(),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
-		unknownPseudoNode1ID: unknownPseudoNode1,
-		unknownPseudoNode2ID: unknownPseudoNode2,
-		render.TheInternetID: theInternetNode,
+		unknownPseudoNode1ID: unknownPseudoNode1(report.MakeIDList("apache")),
+		unknownPseudoNode2ID: unknownPseudoNode2(report.MakeIDList("apache")),
+		render.TheInternetID: theInternetNode(report.MakeIDList("apache")),
 	}

 	RenderedContainers = render.RenderableNodes{
@@ -210,7 +210,7 @@ var (
 			LabelMinor: test.ServerHostName,
 			Rank:       test.ServerContainerImageID,
 			Pseudo:     false,
-			Adjacency:  report.MakeIDList(test.ClientContainerID, render.TheInternetID),
+			Adjacency:  report.MakeIDList(),
 			Origins: report.MakeIDList(
 				test.ServerContainerNodeID,
 				test.Server80NodeID,
@@ -218,10 +218,7 @@ var (
 				test.ServerHostNodeID,
 			),
 			NodeMetadata: report.MakeNodeMetadata(),
-			EdgeMetadata: report.EdgeMetadata{
-				EgressPacketCount: newu64(150),
-				EgressByteCount:   newu64(1500),
-			},
+			EdgeMetadata: report.EdgeMetadata{},
 		},
 		uncontainedServerID: {
 			ID:         uncontainedServerID,
@@ -236,7 +233,7 @@ var (
 			NodeMetadata: report.MakeNodeMetadata(),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
-		render.TheInternetID: theInternetNode,
+		render.TheInternetID: theInternetNode(report.MakeIDList(test.ServerContainerID)),
 	}

 	RenderedContainerImages = render.RenderableNodes{
@@ -268,7 +265,7 @@ var (
 			LabelMinor: "",
 			Rank:       test.ServerContainerImageName,
 			Pseudo:     false,
-			Adjacency:  report.MakeIDList(test.ClientContainerImageName, render.TheInternetID),
+			Adjacency:  report.MakeIDList(),
 			Origins: report.MakeIDList(
 				test.ServerContainerImageNodeID,
 				test.ServerContainerNodeID,
@@ -276,10 +273,7 @@ var (
 				test.ServerProcessNodeID,
 				test.ServerHostNodeID),
 			NodeMetadata: report.MakeNodeMetadata(),
-			EdgeMetadata: report.EdgeMetadata{
-				EgressPacketCount: newu64(150),
-				EgressByteCount:   newu64(1500),
-			},
+			EdgeMetadata: report.EdgeMetadata{},
 		},
 		uncontainedServerID: {
 			ID:         uncontainedServerID,
@@ -294,7 +288,7 @@ var (
 			NodeMetadata: report.MakeNodeMetadata(),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
-		render.TheInternetID: theInternetNode,
+		render.TheInternetID: theInternetNode(report.MakeIDList(test.ServerContainerImageName)),
 	}

 	ServerHostRenderedID = render.MakeHostID(test.ServerHostID)
@@ -309,15 +303,13 @@ var (
 			LabelMinor: "hostname.com", // after first .
 			Rank:       "hostname.com",
 			Pseudo:     false,
-			Adjacency:  report.MakeIDList(ClientHostRenderedID, render.TheInternetID, pseudoHostID1, pseudoHostID2),
+			Adjacency:  report.MakeIDList(),
 			Origins: report.MakeIDList(
 				test.ServerHostNodeID,
 				test.ServerAddressNodeID,
 			),
 			NodeMetadata: report.MakeNodeMetadata(),
-			EdgeMetadata: report.EdgeMetadata{
-				MaxConnCountTCP: newu64(3),
-			},
+			EdgeMetadata: report.EdgeMetadata{},
 		},
 		ClientHostRenderedID: {
 			ID:         ClientHostRenderedID,
@@ -339,6 +331,7 @@ var (
 			ID:           pseudoHostID1,
 			LabelMajor:   "10.10.10.10",
 			Pseudo:       true,
+			Adjacency:    report.MakeIDList(ServerHostRenderedID),
 			NodeMetadata: report.MakeNodeMetadata(),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
@@ -346,10 +339,18 @@ var (
 			ID:           pseudoHostID2,
 			LabelMajor:   "10.10.10.11",
 			Pseudo:       true,
+			Adjacency:    report.MakeIDList(ServerHostRenderedID),
+			NodeMetadata: report.MakeNodeMetadata(),
+			EdgeMetadata: report.EdgeMetadata{},
+		},
+		render.TheInternetID: {
+			ID:           render.TheInternetID,
+			LabelMajor:   render.TheInternetMajor,
+			Pseudo:       true,
+			Adjacency:    report.MakeIDList(ServerHostRenderedID),
 			NodeMetadata: report.MakeNodeMetadata(),
 			EdgeMetadata: report.EdgeMetadata{},
 		},
-		render.TheInternetID: theInternetNode,
 	}
 )

--- a/render/mapping.go
+++ b/render/mapping.go
@@ -33,11 +33,12 @@ const (
 // rendered topology.
 type LeafMapFunc func(report.NodeMetadata) (RenderableNode, bool)

-// PseudoFunc creates RenderableNode representing pseudo nodes given the dstNodeID.
-// The srcNode renderable node is essentially from MapFunc, representing one of
-// the rendered nodes this pseudo node refers to. srcNodeID and dstNodeID are
-// node IDs prior to mapping.
-type PseudoFunc func(srcNodeID string, srcNode RenderableNode, dstNodeID string, local report.Networks) (RenderableNode, bool)
+// PseudoFunc creates RenderableNode representing pseudo nodes given the nodeID.
+// dstNodeID is the node id of one of the nodes this node is attached to.
+// nodeID and dstNodeID are node IDs prior to mapping.  isClient indicated the direction
+// of the edge to dstNodeID - true indicates nodeID is the client, false indicates
+// nodeID is the server.
+type PseudoFunc func(nodeID string, dstNodeID string, isClient bool, local report.Networks) (RenderableNode, bool)

 // MapFunc is anything which can take an arbitrary RenderableNode and
 // return another RenderableNode.
@@ -323,29 +324,36 @@ func MapAddress2Host(n RenderableNode) (RenderableNode, bool) {
 // the report's local networks.  Otherwise, the returned function will
 // produce a single pseudo node per (dst address, src address, src port).
 func GenericPseudoNode(addresser func(id string) net.IP) PseudoFunc {
-	return func(src string, srcMapped RenderableNode, dst string, local report.Networks) (RenderableNode, bool) {
-		// Use the addresser to extract the destination IP
-		dstNodeAddr := addresser(dst)
-
+	return func(nodeID, dstNodeId string, isClient bool, local report.Networks) (RenderableNode, bool) {
+		// Use the addresser to extract the IP of the missing node
+		nodeAddr := addresser(nodeID)
 		// If the dstNodeAddr is not in a network local to this report, we emit an
 		// internet node
-		if !local.Contains(dstNodeAddr) {
+		if !local.Contains(nodeAddr) {
 			return newPseudoNode(TheInternetID, TheInternetMajor, ""), true
 		}

-		// Otherwise, the rule for non-internet psuedo nodes; emit 1 new node for each
-		// dstNodeAddr, srcNodeAddr, srcNodePort.
-		srcNodeAddr, srcNodePort := trySplitAddr(src)
+		if isClient {
+			// If the client node is missing, generate a single pseudo node for every (client ip, server ip, server por)
+			serverIP, serverPort := trySplitAddr(dstNodeId)
+			outputID := MakePseudoNodeID(nodeAddr.String(), serverIP, serverPort)
+			major := nodeAddr.String()
+			return newPseudoNode(outputID, major, ""), true
+		}

-		outputID := MakePseudoNodeID(dstNodeAddr.String(), srcNodeAddr, srcNodePort)
-		major := dstNodeAddr.String()
-		return newPseudoNode(outputID, major, ""), true
+		// Othereise (the server node is missing), generate a pseudo node for every (server ip, server port)
+		serverIP, serverPort := trySplitAddr(nodeID)
+		outputID := MakePseudoNodeID(serverIP, serverPort)
+		if serverPort != "" {
+			return newPseudoNode(outputID, serverIP+":"+serverPort, ""), true
+		}
+		return newPseudoNode(outputID, serverIP, ""), true
 	}
 }

 // PanicPseudoNode just panics; it is for Topologies without edges
-func PanicPseudoNode(src string, srcMapped RenderableNode, dst string, local report.Networks) (RenderableNode, bool) {
-	panic(dst)
+func PanicPseudoNode(src, dst string, isClient bool, local report.Networks) (RenderableNode, bool) {
+	panic(src)
 }

 // trySplitAddr is basically ParseArbitraryNodeID, since its callsites
--- a/render/render.go
+++ b/render/render.go
@@ -179,20 +179,41 @@ func (m LeafMap) Render(rpt report.Report) RenderableNodes {

 	// Walk the graph and make connections.
 	for src, dsts := range t.Adjacency {
-		var (
-			srcNodeID, ok     = report.ParseAdjacencyID(src)
-			srcRenderableID   = source2mapped[srcNodeID] // must exist
-			srcRenderableNode = nodes[srcRenderableID]   // must exist
-		)
+		srcNodeID, ok := report.ParseAdjacencyID(src)
 		if !ok {
 			log.Printf("bad adjacency ID %q", src)
 			continue
 		}

+		var (
+			srcRenderableID, ok1 = source2mapped[srcNodeID]
+			srcRenderableNode    = nodes[srcRenderableID]
+		)
+		if !ok1 {
+			// One of the entries in dsts must be a non-pseudo node
+			var existingDstNodeID string
+			for _, dstNodeID := range dsts {
+				if _, ok := source2mapped[dstNodeID]; ok {
+					existingDstNodeID = dstNodeID
+					break
+				}
+			}
+
+			pseudoNode, ok := m.Pseudo(srcNodeID, existingDstNodeID, true, localNetworks)
+			if !ok {
+				continue
+			}
+
+			srcRenderableID = pseudoNode.ID
+			srcRenderableNode = pseudoNode
+			nodes[srcRenderableID] = srcRenderableNode
+			source2mapped[srcNodeID] = srcRenderableID
+		}
+
 		for _, dstNodeID := range dsts {
 			dstRenderableID, ok := source2mapped[dstNodeID]
 			if !ok {
-				pseudoNode, ok := m.Pseudo(srcNodeID, srcRenderableNode, dstNodeID, localNetworks)
+				pseudoNode, ok := m.Pseudo(dstNodeID, srcNodeID, false, localNetworks)
 				if !ok {
 					continue
 				}
@@ -202,12 +223,10 @@ func (m LeafMap) Render(rpt report.Report) RenderableNodes {
 			}

 			srcRenderableNode.Adjacency = srcRenderableNode.Adjacency.Add(dstRenderableID)
-			srcRenderableNode.Origins = srcRenderableNode.Origins.Add(srcNodeID)
 			edgeID := report.MakeEdgeID(srcNodeID, dstNodeID)
 			if md, ok := t.EdgeMetadatas[edgeID]; ok {
 				srcRenderableNode.EdgeMetadata.Merge(md)
 			}
-
 		}

 		nodes[srcRenderableID] = srcRenderableNode
--- a/report/topology.go
+++ b/report/topology.go
@@ -85,8 +85,11 @@ func (t Topology) Validate() error {
 			errs = append(errs, fmt.Sprintf("invalid edge ID %q", edgeID))
 			continue
 		}
+		// For each edge, at least one of the ends must exist in nodemetadata
 		if _, ok := t.NodeMetadatas[srcNodeID]; !ok {
-			errs = append(errs, fmt.Sprintf("node metadata missing for source node ID %q (from edge %q)", srcNodeID, edgeID))
+			if _, ok := t.NodeMetadatas[dstNodeID]; !ok {
+				errs = append(errs, fmt.Sprintf("node metadatas missing for edge %q", edgeID))
+			}
 		}
 		dstNodeIDs, ok := t.Adjacency[MakeAdjacencyID(srcNodeID)]
 		if !ok {
@@ -99,14 +102,19 @@ func (t Topology) Validate() error {
 	}

 	// Check all adjancency keys has entries in NodeMetadata.
-	for adjacencyID := range t.Adjacency {
-		nodeID, ok := ParseAdjacencyID(adjacencyID)
+	for adjacencyID, dsts := range t.Adjacency {
+		srcNodeID, ok := ParseAdjacencyID(adjacencyID)
 		if !ok {
 			errs = append(errs, fmt.Sprintf("invalid adjacency ID %q", adjacencyID))
 			continue
 		}
-		if _, ok := t.NodeMetadatas[nodeID]; !ok {
-			errs = append(errs, fmt.Sprintf("node metadata missing for source node %q (from adjacency %q)", nodeID, adjacencyID))
+		for _, dstNodeID := range dsts {
+			// For each edge, at least one of the ends must exist in nodemetadata
+			if _, ok := t.NodeMetadatas[srcNodeID]; !ok {
+				if _, ok := t.NodeMetadatas[dstNodeID]; !ok {
+					errs = append(errs, fmt.Sprintf("node metadata missing from adjacency %q -> %q", srcNodeID, dstNodeID))
+				}
+			}
 		}
 	}

--- a/test/report_fixture.go
+++ b/test/report_fixture.go
@@ -79,11 +79,12 @@ var (
 	Report = report.Report{
 		Endpoint: report.Topology{
 			Adjacency: report.Adjacency{
-				report.MakeAdjacencyID(Client54001NodeID): report.MakeIDList(Server80NodeID),
-				report.MakeAdjacencyID(Client54002NodeID): report.MakeIDList(Server80NodeID),
-				report.MakeAdjacencyID(Server80NodeID): report.MakeIDList(
-					Client54001NodeID, Client54002NodeID, UnknownClient1NodeID, UnknownClient2NodeID,
-					UnknownClient3NodeID, RandomClientNodeID),
+				report.MakeAdjacencyID(Client54001NodeID):    report.MakeIDList(Server80NodeID),
+				report.MakeAdjacencyID(Client54002NodeID):    report.MakeIDList(Server80NodeID),
+				report.MakeAdjacencyID(UnknownClient1NodeID): report.MakeIDList(Server80NodeID),
+				report.MakeAdjacencyID(UnknownClient2NodeID): report.MakeIDList(Server80NodeID),
+				report.MakeAdjacencyID(UnknownClient3NodeID): report.MakeIDList(Server80NodeID),
+				report.MakeAdjacencyID(RandomClientNodeID):   report.MakeIDList(Server80NodeID),
 			},
 			NodeMetadatas: report.NodeMetadatas{
 				// NodeMetadata is arbitrary. We're free to put only precisely what we
@@ -117,27 +118,22 @@ var (
 					EgressPacketCount: newu64(20),
 					EgressByteCount:   newu64(200),
 				},
-
-				report.MakeEdgeID(Server80NodeID, Client54001NodeID): report.EdgeMetadata{
-					EgressPacketCount: newu64(10),
-					EgressByteCount:   newu64(100),
-				},
-				report.MakeEdgeID(Server80NodeID, Client54002NodeID): report.EdgeMetadata{
-					EgressPacketCount: newu64(20),
-					EgressByteCount:   newu64(200),
-				},
-				report.MakeEdgeID(Server80NodeID, UnknownClient1NodeID): report.EdgeMetadata{
+				report.MakeEdgeID(UnknownClient1NodeID, Server80NodeID): report.EdgeMetadata{
 					EgressPacketCount: newu64(30),
 					EgressByteCount:   newu64(300),
 				},
-				report.MakeEdgeID(Server80NodeID, UnknownClient2NodeID): report.EdgeMetadata{
+				report.MakeEdgeID(UnknownClient2NodeID, Server80NodeID): report.EdgeMetadata{
 					EgressPacketCount: newu64(40),
 					EgressByteCount:   newu64(400),
 				},
-				report.MakeEdgeID(Server80NodeID, UnknownClient3NodeID): report.EdgeMetadata{
+				report.MakeEdgeID(UnknownClient3NodeID, Server80NodeID): report.EdgeMetadata{
 					EgressPacketCount: newu64(50),
 					EgressByteCount:   newu64(500),
 				},
+				report.MakeEdgeID(RandomClientNodeID, Server80NodeID): report.EdgeMetadata{
+					EgressPacketCount: newu64(60),
+					EgressByteCount:   newu64(600),
+				},
 			},
 		},
 		Process: report.Topology{
@@ -201,9 +197,10 @@ var (
 		},
 		Address: report.Topology{
 			Adjacency: report.Adjacency{
-				report.MakeAdjacencyID(ClientAddressNodeID): report.MakeIDList(ServerAddressNodeID),
-				report.MakeAdjacencyID(ServerAddressNodeID): report.MakeIDList(
-					ClientAddressNodeID, UnknownAddress1NodeID, UnknownAddress2NodeID, RandomAddressNodeID), // no backlinks to unknown/random
+				report.MakeAdjacencyID(ClientAddressNodeID):   report.MakeIDList(ServerAddressNodeID),
+				report.MakeAdjacencyID(UnknownAddress1NodeID): report.MakeIDList(ServerAddressNodeID),
+				report.MakeAdjacencyID(UnknownAddress2NodeID): report.MakeIDList(ServerAddressNodeID),
+				report.MakeAdjacencyID(RandomAddressNodeID):   report.MakeIDList(ServerAddressNodeID),
 			},
 			NodeMetadatas: report.NodeMetadatas{
 				ClientAddressNodeID: report.MakeNodeMetadataWith(map[string]string{
@@ -219,9 +216,6 @@ var (
 				report.MakeEdgeID(ClientAddressNodeID, ServerAddressNodeID): report.EdgeMetadata{
 					MaxConnCountTCP: newu64(3),
 				},
-				report.MakeEdgeID(ServerAddressNodeID, ClientAddressNodeID): report.EdgeMetadata{
-					MaxConnCountTCP: newu64(3),
-				},
 			},
 		},
 		Host: report.Topology{