Removing dead EdgeMetadata rendering code

render/render.go

@@ -7,7 +7,6 @@ import (
 // Renderer is something that can render a report to a set of RenderableNodes.
 type Renderer interface {
 	Render(report.Report) RenderableNodes
-	EdgeMetadata(rpt report.Report, localID, remoteID string) report.EdgeMetadata
 	Stats(report.Report) Stats
 }
 
@@ -40,15 +39,6 @@ func (r Reduce) Render(rpt report.Report) RenderableNodes {
 	return result
 }
 
-// EdgeMetadata produces an EdgeMetadata for a given edge.
-func (r Reduce) EdgeMetadata(rpt report.Report, localID, remoteID string) report.EdgeMetadata {
-	metadata := report.EdgeMetadata{}
-	for _, renderer := range r {
-		metadata = metadata.Merge(renderer.EdgeMetadata(rpt, localID, remoteID))
-	}
-	return metadata
-}
-
 // Stats implements Renderer
 func (r Reduce) Stats(rpt report.Report) Stats {
 	var result Stats
@@ -118,36 +108,3 @@ func (m Map) render(rpt report.Report) (RenderableNodes, map[string]report.IDLis
 
 	return output, mapped
 }
-
-// EdgeMetadata gives the metadata of an edge from the perspective of the
-// srcRenderableID. Since an edgeID can have multiple edges on the address
-// level, it uses the supplied mapping function to translate address IDs to
-// renderable node (mapped) IDs.
-func (m Map) EdgeMetadata(rpt report.Report, srcRenderableID, dstRenderableID string) report.EdgeMetadata {
-	// First we need to map the ids in this layer into the ids in the underlying layer
-	_, mapped := m.render(rpt)        // this maps from old -> new
-	inverted := map[string][]string{} // this maps from new -> old(s)
-	for k, vs := range mapped {
-		for _, v := range vs {
-			existing := inverted[v]
-			existing = append(existing, k)
-			inverted[v] = existing
-		}
-	}
-
-	// Now work out a slice of edges this edge is constructed from
-	oldEdges := []struct{ src, dst string }{}
-	for _, oldSrcID := range inverted[srcRenderableID] {
-		for _, oldDstID := range inverted[dstRenderableID] {
-			oldEdges = append(oldEdges, struct{ src, dst string }{oldSrcID, oldDstID})
-		}
-	}
-
-	// Now recurse for each old edge
-	output := report.EdgeMetadata{}
-	for _, edge := range oldEdges {
-		metadata := m.Renderer.EdgeMetadata(rpt, edge.src, edge.dst)
-		output = output.Merge(metadata)
-	}
-	return output
-}

render/render_test.go

@@ -11,15 +11,11 @@ import (
 
 type mockRenderer struct {
 	render.RenderableNodes
-	edgeMetadata report.EdgeMetadata
 }
 
 func (m mockRenderer) Render(rpt report.Report) render.RenderableNodes {
 	return m.RenderableNodes
 }
-func (m mockRenderer) EdgeMetadata(rpt report.Report, localID, remoteID string) report.EdgeMetadata {
-	return m.edgeMetadata
-}
 func (m mockRenderer) Stats(rpt report.Report) render.Stats {
 	return render.Stats{}
 }
@@ -40,19 +36,6 @@ func TestReduceRender(t *testing.T) {
 	}
 }
 
-func TestReduceEdge(t *testing.T) {
-	renderer := render.Reduce([]render.Renderer{
-		mockRenderer{edgeMetadata: report.EdgeMetadata{EgressPacketCount: newu64(1)}},
-		mockRenderer{edgeMetadata: report.EdgeMetadata{EgressPacketCount: newu64(2)}},
-	})
-
-	want := report.EdgeMetadata{EgressPacketCount: newu64(3)}
-	have := renderer.EdgeMetadata(report.MakeReport(), "", "")
-	if !reflect.DeepEqual(want, have) {
-		t.Errorf("want %+v, have %+v", want, have)
-	}
-}
-
 func TestMapRender1(t *testing.T) {
 	// 1. Check when we return false, the node gets filtered out
 	mapper := render.Map{
@@ -114,70 +97,4 @@ func TestMapRender3(t *testing.T) {
 	}
 }
 
-func TestMapEdge(t *testing.T) {
-	selector := render.TopologySelector(func(_ report.Report) render.RenderableNodes {
-		return render.MakeRenderableNodes(report.Topology{
-			Nodes: report.Nodes{
-				"foo": report.MakeNode().WithMetadata(map[string]string{
-					"id": "foo",
-				}).WithEdge("bar", report.EdgeMetadata{
-					EgressPacketCount: newu64(1),
-					EgressByteCount:   newu64(2),
-				}),
-
-				"bar": report.MakeNode().WithMetadata(map[string]string{
-					"id": "bar",
-				}).WithEdge("foo", report.EdgeMetadata{
-					EgressPacketCount: newu64(3),
-					EgressByteCount:   newu64(4),
-				}),
-			},
-		})
-	})
-
-	mapper := render.Map{
-		MapFunc: func(node render.RenderableNode, _ report.Networks) render.RenderableNodes {
-			id := "_" + node.ID
-			return render.RenderableNodes{id: render.NewDerivedNode(id, node)}
-		},
-		Renderer: selector,
-	}
-
-	have := mapper.Render(report.MakeReport()).Prune()
-	want := (render.RenderableNodes{
-		"_foo": {
-			ID:      "_foo",
-			Origins: report.MakeIDList("foo"),
-			Node:    report.MakeNode().WithAdjacent("_bar"),
-			EdgeMetadata: report.EdgeMetadata{
-				EgressPacketCount:  newu64(1),
-				EgressByteCount:    newu64(2),
-				IngressPacketCount: newu64(3),
-				IngressByteCount:   newu64(4),
-			},
-		},
-		"_bar": {
-			ID:      "_bar",
-			Origins: report.MakeIDList("bar"),
-			Node:    report.MakeNode().WithAdjacent("_foo"),
-			EdgeMetadata: report.EdgeMetadata{
-				EgressPacketCount:  newu64(3),
-				EgressByteCount:    newu64(4),
-				IngressPacketCount: newu64(1),
-				IngressByteCount:   newu64(2),
-			},
-		},
-	}).Prune()
-	if !reflect.DeepEqual(want, have) {
-		t.Error(test.Diff(want, have))
-	}
-
-	if want, have := (report.EdgeMetadata{
-		EgressPacketCount: newu64(1),
-		EgressByteCount:   newu64(2),
-	}), mapper.EdgeMetadata(report.MakeReport(), "_foo", "_bar"); !reflect.DeepEqual(want, have) {
-		t.Error(test.Diff(want, have))
-	}
-}
-
 func newu64(value uint64) *uint64 { return &value }

render/selectors.go

@@ -13,22 +13,6 @@ func (t TopologySelector) Render(r report.Report) RenderableNodes {
 	return t(r)
 }
 
-// EdgeMetadata implements Renderer
-func (t TopologySelector) EdgeMetadata(rpt report.Report, srcID, dstID string) report.EdgeMetadata {
-	var (
-		nodes    = t(rpt)
-		metadata = report.EdgeMetadata{}
-	)
-	for src, node := range nodes {
-		for dst, edgeMeta := range node.Edges {
-			if src == srcID && dst == dstID {
-				return edgeMeta
-			}
-		}
-	}
-	return metadata
-}
-
 // Stats implements Renderer
 func (t TopologySelector) Stats(r report.Report) Stats {
 	return Stats{}