Decorators, begone!

Decorators were just a complicated way of constructing filters.
2026-07-28 17:51:21 +00:00 · 2017-11-21 20:16:30 +00:00
parent 093857f37f
commit 88e8b52d66
9 changed files with 65 additions and 122 deletions
--- a/app/api_topologies.go
+++ b/app/api_topologies.go
@@ -336,9 +336,8 @@ type APITopologyOptionGroup struct {
 	NoneLabel string `json:"noneLabel,omitempty"`
 }

-// Get the render filters to use for this option group as a Decorator, if any.
-// If second arg is false, no decorator was needed.
-func (g APITopologyOptionGroup) getFilterDecorator(value string) (render.Decorator, bool) {
+// Get the render filters to use for this option group, if any, or nil otherwise.
+func (g APITopologyOptionGroup) filter(value string) render.FilterFunc {
 	selectType := g.SelectType
 	if selectType == "" {
 		selectType = "one"
@@ -351,7 +350,7 @@ func (g APITopologyOptionGroup) getFilterDecorator(value string) (render.Decorat
 		values = strings.Split(value, ",")
 	default:
 		log.Errorf("Invalid select type %s for option group %s, ignoring option", selectType, g.ID)
-		return nil, false
+		return nil
 	}
 	filters := []render.FilterFunc{}
 	for _, opt := range g.Options {
@@ -374,11 +373,9 @@ func (g APITopologyOptionGroup) getFilterDecorator(value string) (render.Decorat
 		}
 	}
 	if len(filters) == 0 {
-		return nil, false
+		return nil
 	}
-	// Since we've encoded whether to ignore pseudo topologies into each subfilter,
-	// we want no special behaviour for pseudo topologies here, which corresponds to MakePseudo
-	return render.MakeFilterPseudoDecorator(render.AnyFilterFunc(filters...)), true
+	return render.AnyFilterFunc(filters...)
 }

 // APITopologyOption describes a &param=value to a given topology.
@@ -487,24 +484,24 @@ func (r *Registry) renderTopologies(rpt report.Report, req *http.Request) []APIT
 	topologies := []APITopologyDesc{}
 	req.ParseForm()
 	r.walk(func(desc APITopologyDesc) {
-		renderer, decorator, _ := r.RendererForTopology(desc.id, req.Form, rpt)
-		desc.Stats = decorateWithStats(rpt, renderer, decorator)
+		renderer, filter, _ := r.RendererForTopology(desc.id, req.Form, rpt)
+		desc.Stats = decorateWithStats(rpt, renderer, filter)
 		for i, sub := range desc.SubTopologies {
-			renderer, decorator, _ := r.RendererForTopology(sub.id, req.Form, rpt)
-			desc.SubTopologies[i].Stats = decorateWithStats(rpt, renderer, decorator)
+			renderer, filter, _ := r.RendererForTopology(sub.id, req.Form, rpt)
+			desc.SubTopologies[i].Stats = decorateWithStats(rpt, renderer, filter)
 		}
 		topologies = append(topologies, desc)
 	})
 	return updateFilters(rpt, topologies)
 }

-func decorateWithStats(rpt report.Report, renderer render.Renderer, decorator render.Decorator) topologyStats {
+func decorateWithStats(rpt report.Report, renderer render.Renderer, filter render.FilterFunc) topologyStats {
 	var (
 		nodes     int
 		realNodes int
 		edges     int
 	)
-	r := render.Decorate(rpt, renderer, decorator)
+	r := render.Render(rpt, renderer, filter)
 	for _, n := range r.Nodes {
 		nodes++
 		if n.Topology != render.Pseudo {
@@ -521,7 +518,7 @@ func decorateWithStats(rpt report.Report, renderer render.Renderer, decorator re
 }

 // RendererForTopology ..
-func (r *Registry) RendererForTopology(topologyID string, values url.Values, rpt report.Report) (render.Renderer, render.Decorator, error) {
+func (r *Registry) RendererForTopology(topologyID string, values url.Values, rpt report.Report) (render.Renderer, render.FilterFunc, error) {
 	topology, ok := r.get(topologyID)
 	if !ok {
 		return nil, nil, fmt.Errorf("topology not found: %s", topologyID)
@@ -533,15 +530,15 @@ func (r *Registry) RendererForTopology(topologyID string, values url.Values, rpt
 		return topology.renderer, nil, nil
 	}

-	var decorators []render.Decorator
+	var filters []render.FilterFunc
 	for _, group := range topology.Options {
 		value := values.Get(group.ID)
-		if decorator, ok := group.getFilterDecorator(value); ok {
-			decorators = append(decorators, decorator)
+		if filter := group.filter(value); filter != nil {
+			filters = append(filters, filter)
 		}
 	}
-	if len(decorators) > 0 {
-		return topology.renderer, render.ComposeDecorators(decorators...), nil
+	if len(filters) > 0 {
+		return topology.renderer, render.ComposeFilterFuncs(filters...), nil
 	}
 	return topology.renderer, nil, nil
 }
@@ -554,7 +551,7 @@ func captureReporter(rep Reporter, f reporterHandler) CtxHandlerFunc {
 	}
 }

-type rendererHandler func(context.Context, render.Renderer, render.Decorator, report.RenderContext, http.ResponseWriter, *http.Request)
+type rendererHandler func(context.Context, render.Renderer, render.FilterFunc, report.RenderContext, http.ResponseWriter, *http.Request)

 func (r *Registry) captureRenderer(rep Reporter, f rendererHandler) CtxHandlerFunc {
 	return func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
@@ -572,11 +569,11 @@ func (r *Registry) captureRenderer(rep Reporter, f rendererHandler) CtxHandlerFu
 			return
 		}
 		req.ParseForm()
-		renderer, decorator, err := r.RendererForTopology(topologyID, req.Form, rpt)
+		renderer, filter, err := r.RendererForTopology(topologyID, req.Form, rpt)
 		if err != nil {
 			respondWith(w, http.StatusInternalServerError, err)
 			return
 		}
-		f(ctx, renderer, decorator, RenderContextForReporter(rep, rpt), w, req)
+		f(ctx, renderer, filter, RenderContextForReporter(rep, rpt), w, req)
 	}
 }
--- a/app/api_topologies_test.go
+++ b/app/api_topologies_test.go
@@ -109,7 +109,7 @@ func TestRendererForTopologyWithFiltering(t *testing.T) {
 	urlvalues.Set(systemGroupID, customAPITopologyOptionFilterID)
 	urlvalues.Set("stopped", "running")
 	urlvalues.Set("pseudo", "hide")
-	renderer, decorator, err := topologyRegistry.RendererForTopology("containers", urlvalues, fixture.Report)
+	renderer, filter, err := topologyRegistry.RendererForTopology("containers", urlvalues, fixture.Report)
 	if err != nil {
 		t.Fatalf("Topology Registry Report error: %s", err)
 	}
@@ -118,7 +118,7 @@ func TestRendererForTopologyWithFiltering(t *testing.T) {
 	input.Container.Nodes[fixture.ClientContainerNodeID] = input.Container.Nodes[fixture.ClientContainerNodeID].WithLatests(map[string]string{
 		docker.LabelPrefix + "works.weave.role": "system",
 	})
-	have := utils.Prune(render.Decorate(input, renderer, decorator).Nodes)
+	have := utils.Prune(render.Render(input, renderer, filter).Nodes)
 	want := utils.Prune(expected.RenderedContainers.Copy())
 	delete(want, fixture.ClientContainerNodeID)
 	delete(want, render.MakePseudoNodeID(render.UncontainedID, fixture.ServerHostID))
@@ -140,7 +140,7 @@ func TestRendererForTopologyNoFiltering(t *testing.T) {
 	urlvalues.Set(systemGroupID, customAPITopologyOptionFilterID)
 	urlvalues.Set("stopped", "running")
 	urlvalues.Set("pseudo", "hide")
-	renderer, decorator, err := topologyRegistry.RendererForTopology("containers", urlvalues, fixture.Report)
+	renderer, filter, err := topologyRegistry.RendererForTopology("containers", urlvalues, fixture.Report)
 	if err != nil {
 		t.Fatalf("Topology Registry Report error: %s", err)
 	}
@@ -149,7 +149,7 @@ func TestRendererForTopologyNoFiltering(t *testing.T) {
 	input.Container.Nodes[fixture.ClientContainerNodeID] = input.Container.Nodes[fixture.ClientContainerNodeID].WithLatests(map[string]string{
 		docker.LabelPrefix + "works.weave.role": "system",
 	})
-	have := utils.Prune(render.Decorate(input, renderer, decorator).Nodes)
+	have := utils.Prune(render.Render(input, renderer, filter).Nodes)
 	want := utils.Prune(expected.RenderedContainers.Copy())
 	delete(want, render.MakePseudoNodeID(render.UncontainedID, fixture.ServerHostID))
 	delete(want, render.OutgoingInternetID)
@@ -178,12 +178,12 @@ func getTestContainerLabelFilterTopologySummary(t *testing.T, exclude bool) (det
 	urlvalues.Set(systemGroupID, customAPITopologyOptionFilterID)
 	urlvalues.Set("stopped", "running")
 	urlvalues.Set("pseudo", "hide")
-	renderer, decorator, err := topologyRegistry.RendererForTopology("containers", urlvalues, fixture.Report)
+	renderer, filter, err := topologyRegistry.RendererForTopology("containers", urlvalues, fixture.Report)
 	if err != nil {
 		return nil, err
 	}

-	return detailed.Summaries(report.RenderContext{Report: fixture.Report}, render.Decorate(fixture.Report, renderer, decorator).Nodes), nil
+	return detailed.Summaries(report.RenderContext{Report: fixture.Report}, render.Render(fixture.Report, renderer, filter).Nodes), nil
 }

 func TestAPITopologyAddsKubernetes(t *testing.T) {
--- a/app/api_topology.go
+++ b/app/api_topology.go
@@ -29,23 +29,23 @@ type APINode struct {
 }

 // Full topology.
-func handleTopology(ctx context.Context, renderer render.Renderer, decorator render.Decorator, rc report.RenderContext, w http.ResponseWriter, r *http.Request) {
+func handleTopology(ctx context.Context, renderer render.Renderer, filter render.FilterFunc, rc report.RenderContext, w http.ResponseWriter, r *http.Request) {
 	respondWith(w, http.StatusOK, APITopology{
-		Nodes: detailed.Summaries(rc, render.Decorate(rc.Report, renderer, decorator).Nodes),
+		Nodes: detailed.Summaries(rc, render.Render(rc.Report, renderer, filter).Nodes),
 	})
 }

 // Individual nodes.
-func handleNode(ctx context.Context, renderer render.Renderer, decorator render.Decorator, rc report.RenderContext, w http.ResponseWriter, r *http.Request) {
+func handleNode(ctx context.Context, renderer render.Renderer, filter render.FilterFunc, rc report.RenderContext, w http.ResponseWriter, r *http.Request) {
 	var (
 		vars       = mux.Vars(r)
 		topologyID = vars["topology"]
 		nodeID     = vars["id"]
 	)
-	// We must not lose the node during decoration. We achieve that by
+	// We must not lose the node during filtering. We achieve that by
 	// (1) rendering the report with the base renderer, without
-	// decoration, which gives us the node (if it exists at all), then
-	// (2) performing a normal decorated render of the report. If the
+	// filtering, which gives us the node (if it exists at all), then
+	// (2) performing a normal filtered render of the report. If the
 	// node is lost in the second step, we simply put it back.
 	//
 	// To avoid repeating the work from step (1) in step (2), we
@@ -57,11 +57,11 @@ func handleNode(ctx context.Context, renderer render.Renderer, decorator render.
 		http.NotFound(w, r)
 		return
 	}
-	if decorator != nil {
-		nodes = render.Decorate(rc.Report, render.ConstantRenderer{Nodes: nodes}, decorator)
-		if decoratedNode, ok := nodes.Nodes[nodeID]; ok {
-			node = decoratedNode
-		} else { // we've lost the node during decoration; put it back
+	if filter != nil {
+		nodes = render.Render(rc.Report, render.ConstantRenderer{Nodes: nodes}, filter)
+		if filteredNode, ok := nodes.Nodes[nodeID]; ok {
+			node = filteredNode
+		} else { // we've lost the node during filtering; put it back
 			nodes.Nodes[nodeID] = node
 			nodes.Filtered--
 		}
@@ -135,12 +135,12 @@ func handleWebsocket(
 			log.Errorf("Error generating report: %v", err)
 			return
 		}
-		renderer, decorator, err := topologyRegistry.RendererForTopology(topologyID, r.Form, re)
+		renderer, filter, err := topologyRegistry.RendererForTopology(topologyID, r.Form, re)
 		if err != nil {
 			log.Errorf("Error generating report: %v", err)
 			return
 		}
-		newTopo := detailed.Summaries(RenderContextForReporter(rep, re), render.Decorate(re, renderer, decorator).Nodes)
+		newTopo := detailed.Summaries(RenderContextForReporter(rep, re), render.Render(re, renderer, filter).Nodes)
 		diff := detailed.TopoDiff(previousTopo, newTopo)
 		previousTopo = newTopo

--- a/app/benchmark_internal_test.go
+++ b/app/benchmark_internal_test.go
@@ -65,10 +65,10 @@ func BenchmarkTopologyContainers(b *testing.B) {

 func benchmarkOneTopology(b *testing.B, topologyID string) {
 	benchmarkRender(b, func(report report.Report) {
-		renderer, decorator, err := topologyRegistry.RendererForTopology(topologyID, url.Values{}, report)
+		renderer, filter, err := topologyRegistry.RendererForTopology(topologyID, url.Values{}, report)
 		if err != nil {
 			b.Fatal(err)
 		}
-		render.Decorate(report, renderer, decorator)
+		render.Render(report, renderer, filter)
 	})
 }