Node metadata matcher (#154)

This PR adds a matcher for node metadata fields. This is for #125.

Similarly to #137, we encode the node metadata information required in the aggregation rules in a pair of protos: (1) NodeMetadataMatch, and (2) NodeMetadataAction, the former related to the matching process, whereas the latter has to do with the formation of the fragment.

Envoy's node metadata is an opaque struct of type google.protobuf.Struct, which basically represents a dictionary of strings to Value.

This PR adds support for 3 of the 6 values: string, bool, and a nested struct of Value. The support for these other types is going to be added in separate PRs.

api/protos/aggregation/v1/aggregation.proto

@@ -32,6 +32,7 @@ message KeyerConfiguration {
   repeated Fragment fragments = 1 [(validate.rules).repeated.min_items = 1];
 }
 
+// [#next-free-field: 4]
 message StringMatch {
   oneof type {
     option (validate.required) = true;
@@ -46,6 +47,12 @@ message StringMatch {
   }
 }
 
+// [#next-free-field: 2]
+message BoolMatch {
+  bool value_match = 1;
+}
+
+// [#next-free-field: 4]
 message LocalityMatch {
   StringMatch region = 1;
 
@@ -54,6 +61,31 @@ message LocalityMatch {
   StringMatch sub_zone = 3;
 }
 
+// [#next-free-field: 2]
+message PathSegment {
+  string key = 1 [(validate.rules).string.min_len = 1];
+}
+
+// [#next-free-field: 3]
+message StructValueMatch {
+  // TODO: we have to match every single type described in
+  // https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Value.
+  oneof match {
+    option (validate.required) = true;
+
+    StringMatch string_match = 1;
+
+    BoolMatch bool_match = 2;
+  }
+}
+
+// [#next-free-field: 3]
+message NodeMetadataMatch {
+  repeated PathSegment path = 1 [(validate.rules).repeated.min_items = 1];
+
+  StructValueMatch match = 2 [(validate.rules).message.required = true];
+}
+
 // This is a recursive structure which allows complex nested match
 // configurations to be built using various logical operators.
 // [#next-free-field: 7]
@@ -68,7 +100,7 @@ message MatchPredicate {
   }
 
   // Match on a field in Envoy's request node.
-  // [#next-free-field: 4]
+  // [#next-free-field: 5]
   message RequestNodeMatch {
     oneof type {
       option (validate.required) = true;
@@ -78,6 +110,8 @@ message MatchPredicate {
       StringMatch cluster_match = 2;
 
       LocalityMatch locality_match = 3;
+
+      NodeMetadataMatch node_metadata_match = 4;
     }
   }
 
@@ -120,8 +154,8 @@ message MatchPredicate {
 // [#next-free-field: 5]
 message ResultPredicate {
 
+  // [#next-free-field: 3]
   message ResultAction {
-
     // TODO potentially use "safe regex"
     // https://github.com/envoyproxy/envoy/blob/10f756efa17e56c8d4d1033be7b4286410db4e01/api/envoy/type/matcher/v3/regex.proto
     // [#next-free-field: 3]
@@ -152,12 +186,20 @@ message ResultPredicate {
     ResultAction subzone_action = 3;
   }
 
+  // [#next-free-field: 3]
+  message NodeMetadataAction {
+    repeated PathSegment path = 1 [(validate.rules).repeated.min_items = 1];
+
+    ResultAction action = 2 [(validate.rules).message.required = true];
+  }
+
+  // [#next-free-field: 2]
   message AndResult {
     repeated ResultPredicate result_predicates = 1 [(validate.rules).repeated.min_items = 2];
   }
 
   // Rules for generating the resulting fragment from a Envoy request node.
-  // [#next-free-field: 4]
+  // [#next-free-field: 5]
   message RequestNodeFragment {
 
     oneof action {
@@ -166,6 +208,7 @@ message ResultPredicate {
       ResultAction id_action = 1;
       ResultAction cluster_action = 2;
       LocalityResultAction locality_action = 3;
+      NodeMetadataAction node_metadata_action = 4;
     }
   }
 

internal/app/mapper/mapper.go

@@ -9,6 +9,7 @@ import (
 	v3 "github.com/envoyproxy/go-control-plane/pkg/resource/v3"
 	"github.com/envoyproxy/xds-relay/internal/app/metrics"
 	"github.com/envoyproxy/xds-relay/internal/app/transport"
+	"google.golang.org/protobuf/types/known/structpb"
 
 	"github.com/uber-go/tally"
 
@@ -155,6 +156,11 @@ func isNodeMatch(matchPredicate *matchPredicate, req transport.Request) (bool, e
 		return compareLocality(localityMatch, req.GetLocality())
 	}
 
+	nodeMetadataMatch := predicate.GetNodeMetadataMatch()
+	if nodeMetadataMatch != nil {
+		return compareNodeMetadata(nodeMetadataMatch, req.GetNodeMetadata())
+	}
+
 	return false, fmt.Errorf("RequestNodeMatch is invalid")
 }
 
@@ -287,6 +293,9 @@ func getResultFromRequestNodePredicate(predicate *resultPredicate, req transport
 		resultFragment, err = getResultFragmentFromAction(req.GetCluster(), requestNodeFragment.GetClusterAction())
 	} else if requestNodeFragment.GetLocalityAction() != nil {
 		resultFragment, err = getFragmentFromLocalityAction(req.GetLocality(), requestNodeFragment.GetLocalityAction())
+	} else if requestNodeFragment.GetNodeMetadataAction() != nil {
+		resultFragment, err = getFragmentFromNodeMetadataAction(req.GetNodeMetadata(),
+			requestNodeFragment.GetNodeMetadataAction())
 	}
 
 	if err != nil {
@@ -439,6 +448,27 @@ func getFragmentFromLocalityAction(
 	return strings.Join(matches, "|"), nil
 }
 
+func getFragmentFromNodeMetadataAction(
+	nodeMetadata *structpb.Struct,
+	action *aggregationv1.ResultPredicate_NodeMetadataAction) (string, error) {
+	// Traverse to the right node
+	var value *structpb.Value = nil
+	var ok bool
+	for _, segment := range action.GetPath() {
+		fields := nodeMetadata.GetFields()
+		value, ok = fields[segment.Key]
+		if !ok {
+			// TODO what to do if the key doesn't map to a valid struct field?
+			return "", fmt.Errorf("Path to key is inexistent")
+		}
+		nodeMetadata = value.GetStructValue()
+	}
+
+	// TODO: We need to stringify values other than strings (bool, integers, etc) before
+	// extracting the fragment via a call to getResultFragmentFromAction.
+	return getResultFragmentFromAction(value.GetStringValue(), action.GetAction())
+}
+
 func compareString(stringMatch *aggregationv1.StringMatch, nodeValue string) (bool, error) {
 	if nodeValue == "" {
 		return false, fmt.Errorf("MatchPredicate Node field cannot be empty")
@@ -460,6 +490,10 @@ func compareString(stringMatch *aggregationv1.StringMatch, nodeValue string) (bo
 	return false, nil
 }
 
+func compareBool(boolMatch *aggregationv1.BoolMatch, boolValue bool) bool {
+	return boolMatch.ValueMatch == boolValue
+}
+
 func compareLocality(localityMatch *aggregationv1.LocalityMatch,
 	reqNodeLocality *transport.Locality) (bool, error) {
 	if reqNodeLocality == nil {
@@ -493,3 +527,38 @@ func compareLocality(localityMatch *aggregationv1.LocalityMatch,
 
 	return regionMatch && zoneMatch && subZoneMatch, nil
 }
+
+func compareNodeMetadata(nodeMetadataMatch *aggregationv1.NodeMetadataMatch,
+	nodeMetadata *structpb.Struct) (bool, error) {
+	if nodeMetadata == nil {
+		return false, fmt.Errorf("Metadata Node field cannot be empty")
+	}
+
+	var value *structpb.Value = nil
+	var ok bool
+	for _, segment := range nodeMetadataMatch.GetPath() {
+		// Starting from the second iteration, make sure that we're dealing with structs
+		if value != nil {
+			if value.GetStructValue() != nil {
+				nodeMetadata = value.GetStructValue()
+			} else {
+				// TODO: signal that the field is not a struct
+				return false, nil
+			}
+		}
+		fields := nodeMetadata.GetFields()
+		value, ok = fields[segment.Key]
+		if !ok {
+			return false, nil
+		}
+	}
+
+	// TODO: implement the other structpb.Value types.
+	if nodeMetadataMatch.Match.GetStringMatch() != nil {
+		return compareString(nodeMetadataMatch.Match.GetStringMatch(), value.GetStringValue())
+	} else if nodeMetadataMatch.Match.GetBoolMatch() != nil {
+		return compareBool(nodeMetadataMatch.Match.GetBoolMatch(), value.GetBoolValue()), nil
+	} else {
+		return false, fmt.Errorf("Invalid NodeMetadata Match")
+	}
+}