Adjust UI disaply of Global, Public, Private (#10014)

Author: caseydavenport

goldmane/pkg/aggregator/index.go

@@ -16,6 +16,7 @@ package aggregator
 
 import (
 	"math"
+	"slices"
 	"sort"
 
 	"github.com/sirupsen/logrus"
@@ -195,9 +196,9 @@ func (idx *index[E]) Remove(d *types.DiachronicFlow) {
 		// The DiachronicFlow at the returned index is the same as the DiachronicFlow to be removed.
 		// Remove it from the index.
 		if logrus.IsLevelEnabled(logrus.DebugLevel) {
-			logrus.WithFields(d.Key.Fields()).Debug("Removing diachronic flow from index")
+			logrus.WithFields(d.Key.Fields()).Debug("Removing flow from index")
 		}
-		idx.diachronics = append(idx.diachronics[:index], idx.diachronics[index+1:]...)
+		idx.diachronics = slices.Delete(idx.diachronics, index, index+1)
 		return
 	} else {
 		// The DiachronicFlow at the returned index is not the same as the DiachronicFlow to be removed.

goldmane/pkg/types/filters.go

@@ -21,6 +21,41 @@ import (
 	"github.com/projectcalico/calico/goldmane/proto"
 )
 
+const (
+	pub    = "pub"
+	pvt    = "pvt"
+	global = "Global"
+)
+
+// The UI displays some values differently than they are stored within Goldmane. As such,
+// users may sends filters for the UI displayed values, but we need to match against the
+// actual stored values. For example, the UI displays "PUBLIC NETWORK" but the stored value
+// is "pub".
+func names(valFn func() string) func() []string {
+	return func() []string {
+		n := valFn()
+		switch n {
+		case pub:
+			return []string{"PUBLIC NETWORK", pub}
+		case pvt:
+			return []string{"PRIVATE NETWORK", pvt}
+
+		}
+		return []string{n}
+	}
+}
+
+func namespaces(valFn func() string) func() []string {
+	return func() []string {
+		n := valFn()
+		switch n {
+		case global:
+			return []string{"-", global}
+		}
+		return []string{n}
+	}
+}
+
 // Matches returns true if the given flow Matches the given filter.
 func Matches(filter *proto.Filter, key *FlowKey) bool {
 	if filter == nil {
@@ -29,11 +64,11 @@ func Matches(filter *proto.Filter, key *FlowKey) bool {
 	}
 
 	comps := []matcher{
-		&stringComparison{filter: filter.SourceNames, valFn: key.SourceName},
-		&stringComparison{filter: filter.DestNames, valFn: key.DestName},
-		&stringComparison{filter: filter.SourceNamespaces, valFn: key.SourceNamespace},
-		&stringComparison{filter: filter.DestNamespaces, valFn: key.DestNamespace},
-		&stringComparison{filter: filter.Protocols, valFn: key.Proto},
+		&stringComparison{filter: filter.SourceNames, genVals: names(key.SourceName)},
+		&stringComparison{filter: filter.DestNames, genVals: names(key.DestName)},
+		&stringComparison{filter: filter.SourceNamespaces, genVals: namespaces(key.SourceNamespace)},
+		&stringComparison{filter: filter.DestNamespaces, genVals: namespaces(key.DestNamespace)},
+		&stringComparison{filter: filter.Protocols, genVals: func() []string { return []string{key.Proto()} }},
 		&actionMatch{filter: filter.Actions, key: key},
 		&portComparison{filter: filter.DestPorts, key: key},
 		&policyComparison{filter: filter.Policies, key: key},
@@ -86,7 +121,10 @@ func (p *portComparison) matches() bool {
 
 type stringComparison struct {
 	filter []*proto.StringMatch
-	valFn  func() string
+
+	// genVals returns a list of values on the underlying object to compare against the filter.
+	// If any of the values match, the comparison is considered a match.
+	genVals func() []string
 }
 
 func (c stringComparison) matches() bool {
@@ -99,14 +137,19 @@ func (c stringComparison) matches() bool {
 }
 
 func (c stringComparison) matchFilter(filter *proto.StringMatch) bool {
-	val := c.valFn()
+	vals := c.genVals()
 
 	if filter.Type == proto.MatchType_Exact {
-		return val == filter.Value
+		return slices.Contains(vals, filter.Value)
 	}
 
 	// Match type is not exact, so we need to do a substring match.
-	return strings.Contains(val, filter.Value)
+	for _, val := range vals {
+		if strings.Contains(val, filter.Value) {
+			return true
+		}
+	}
+	return false
 }
 
 type policyComparison struct {

whisker-backend/pkg/apis/v1/flows.go

@@ -116,8 +116,10 @@ func (a Actions) AsProtos() []proto.Action {
 	return protos
 }
 
-type SortBy proto.SortBy
-type SortBys []SortBy
+type (
+	SortBy  proto.SortBy
+	SortBys []SortBy
+)
 
 func (p SortBy) String() string                { return proto.SortBy(p).String() }
 func (p SortBy) MarshalJSON() ([]byte, error)  { return marshalToBytes(p) }

whisker-backend/pkg/handlers/v1/flows.go

@@ -139,6 +139,12 @@ func (hdlr *flowsHdlr) ListFilterHints(ctx apictx.Context, params whiskerv1.Flow
 
 	hints := make([]whiskerv1.FlowFilterHintResponse, len(gmhints))
 	for i, hint := range gmhints {
+		switch params.Type.AsProto() {
+		case proto.FilterType_FilterTypeSourceNamespace, proto.FilterType_FilterTypeDestNamespace:
+			hint.Value = protoToNamespace(hint.Value)
+		case proto.FilterType_FilterTypeSourceName, proto.FilterType_FilterTypeDestName:
+			hint.Value = protoToName(hint.Value)
+		}
 		hints[i] = whiskerv1.FlowFilterHintResponse{Value: hint.Value}
 	}
 

whisker-backend/pkg/handlers/v1/protoconvert.go

@@ -22,11 +22,25 @@ import (
 	whiskerv1 "github.com/projectcalico/calico/whisker-backend/pkg/apis/v1"
 )
 
-func toProtoStringMatches(matches []whiskerv1.FilterMatch[string]) []*proto.StringMatch {
+const (
+	global = "Global"
+
+	publicNetwork  = "PUBLIC NETWORK"
+	privateNetwork = "PRIVATE NETWORK"
+
+	pub = "pub"
+	pvt = "pvt"
+)
+
+func toProtoStringMatches(matches []whiskerv1.FilterMatch[string], conv func(string) string) []*proto.StringMatch {
 	var protos []*proto.StringMatch
 	for _, match := range matches {
+		val := match.V
+		if conv != nil {
+			val = conv(val)
+		}
 		protos = append(protos, &proto.StringMatch{
-			Value: match.V,
+			Value: val,
 			Type:  match.Type.AsProto(),
 		})
 	}
@@ -63,11 +77,11 @@ func toProtoSortByOptions(sortBys whiskerv1.SortBys) []*proto.SortOption {
 
 func toProtoFilter(filters whiskerv1.Filters) *proto.Filter {
 	return &proto.Filter{
-		SourceNames:      toProtoStringMatches(filters.SourceNames),
-		SourceNamespaces: toProtoStringMatches(filters.SourceNamespaces),
-		DestNames:        toProtoStringMatches(filters.DestNames),
-		DestNamespaces:   toProtoStringMatches(filters.DestNamespaces),
-		Protocols:        toProtoStringMatches(filters.Protocols),
+		SourceNames:      toProtoStringMatches(filters.SourceNames, toProtoName),
+		SourceNamespaces: toProtoStringMatches(filters.SourceNamespaces, toProtoNamespace),
+		DestNames:        toProtoStringMatches(filters.DestNames, toProtoName),
+		DestNamespaces:   toProtoStringMatches(filters.DestNamespaces, toProtoNamespace),
+		Protocols:        toProtoStringMatches(filters.Protocols, nil),
 		DestPorts:        toProtoPorts(filters.DestPorts),
 		Actions:          filters.Actions.AsProtos(),
 		Policies:         toProtoPolicyMatch(filters.Policies),
@@ -130,11 +144,11 @@ func protoToFlow(flow *proto.Flow) whiskerv1.FlowResponse {
 		EndTime:   time.Unix(flow.EndTime, 0),
 		Action:    whiskerv1.Action(flow.Key.Action),
 
-		SourceName:      flow.Key.SourceName,
+		SourceName:      protoToName(flow.Key.SourceName),
 		SourceNamespace: flow.Key.SourceNamespace,
 		SourceLabels:    strings.Join(flow.SourceLabels, " | "),
 
-		DestName:      flow.Key.DestName,
+		DestName:      protoToName(flow.Key.DestName),
 		DestNamespace: flow.Key.DestNamespace,
 		DestLabels:    strings.Join(flow.DestLabels, " | "),
 
@@ -148,3 +162,39 @@ func protoToFlow(flow *proto.Flow) whiskerv1.FlowResponse {
 		BytesOut:   flow.BytesOut,
 	}
 }
+
+// The Goldmane API uses an empty namespace to represent "no namespace", but the UI wants a value.
+func protoToNamespace(namespace string) string {
+	if namespace == "" || namespace == "-" {
+		return global
+	}
+	return namespace
+}
+
+func toProtoNamespace(namespace string) string {
+	if namespace == global {
+		return "-"
+	}
+	return namespace
+}
+
+// The Goldmane API uses "pub" and "pvt" for special names - for public and private network spaces.
+func protoToName(name string) string {
+	switch name {
+	case pub:
+		return publicNetwork
+	case pvt:
+		return privateNetwork
+	}
+	return name
+}
+
+func toProtoName(name string) string {
+	switch name {
+	case publicNetwork:
+		return pub
+	case privateNetwork:
+		return pvt
+	}
+	return name
+}