grpc 1.78.1 → 1.80.0

data/src/core/xds/grpc/xds_listener_parser.cc

@@ -251,7 +251,7 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
         auto extension = ExtractXdsExtension(context, typed_config, errors);
         if (!extension.has_value()) continue;
         const XdsHttpFilterImpl* filter_impl =
-            http_filter_registry.GetFilterForType(extension->type);
+            http_filter_registry.GetFilterForTopLevelType(extension->type);
         if (filter_impl == nullptr) {
           if (!is_optional) errors->AddError("unsupported filter type");
           continue;
@@ -264,13 +264,20 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
           }
           continue;
         }
-        std::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
-            filter_impl->GenerateFilterConfig(name, context,
-                                              std::move(*extension), errors);
-        if (filter_config.has_value()) {
-          http_connection_manager.http_filters.emplace_back(
-              XdsListenerResource::HttpConnectionManager::HttpFilter{
-                  std::string(name), std::move(*filter_config)});
+        http_connection_manager.http_filters.emplace_back();
+        auto& entry = http_connection_manager.http_filters.back();
+        entry.name = std::string(name);
+        entry.config_proto_type = filter_impl->ConfigProtoName();
+        if (!is_client || !IsXdsChannelFilterChainPerRouteEnabled()) {
+          std::optional<Json> filter_config = filter_impl->GenerateFilterConfig(
+              name, context, *extension, errors);
+          if (filter_config.has_value()) {
+            entry.config = std::move(*filter_config);
+          }
+        }
+        if (IsXdsChannelFilterChainPerRouteEnabled()) {
+          entry.filter_config = filter_impl->ParseTopLevelConfig(
+              name, context, *extension, errors);
         }
       }
     }
@@ -284,23 +291,21 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
     // out of which only one gets added in the final list.
     for (const auto& http_filter : http_connection_manager.http_filters) {
       const XdsHttpFilterImpl* filter_impl =
-          http_filter_registry.GetFilterForType(
-              http_filter.config.config_proto_type_name);
+          http_filter_registry.GetFilterForTopLevelType(
+              http_filter.config_proto_type);
       if (&http_filter != &http_connection_manager.http_filters.back()) {
         // Filters before the last filter must not be terminal.
         if (filter_impl->IsTerminalFilter()) {
-          errors->AddError(
-              absl::StrCat("terminal filter for config type ",
-                           http_filter.config.config_proto_type_name,
-                           " must be the last filter in the chain"));
+          errors->AddError(absl::StrCat(
+              "terminal filter for config type ", http_filter.config_proto_type,
+              " must be the last filter in the chain"));
         }
       } else {
         // The last filter must be terminal.
         if (!filter_impl->IsTerminalFilter()) {
-          errors->AddError(
-              absl::StrCat("non-terminal filter for config type ",
-                           http_filter.config.config_proto_type_name,
-                           " is the last filter in the chain"));
+          errors->AddError(absl::StrCat("non-terminal filter for config type ",
+                                        http_filter.config_proto_type,
+                                        " is the last filter in the chain"));
         }
       }
     }

data/src/core/xds/grpc/xds_matcher.cc

@@ -27,7 +27,7 @@
 namespace grpc_core {
 
 //
-// XdsMatcher
+// XdsMatcher::OnMatch
 //
 
 bool XdsMatcher::OnMatch::operator==(const OnMatch& other) const {
@@ -82,6 +82,15 @@ bool XdsMatcher::OnMatch::FindMatches(const MatchContext& context,
       });
 }
 
+void XdsMatcherList::OnMatch::ForEachAction(
+    absl::FunctionRef<void(const Action&)> func) const {
+  Match(
+      action, [&](const std::unique_ptr<Action>& action) { func(*action); },
+      [&](const std::unique_ptr<XdsMatcher>& matcher) {
+        matcher->ForEachAction(func);
+      });
+}
+
 //
 // XdsMatcherList
 //
@@ -120,6 +129,16 @@ bool XdsMatcherList::FindMatches(const MatchContext& context,
   return false;
 }
 
+void XdsMatcherList::ForEachAction(
+    absl::FunctionRef<void(const Action&)> func) const {
+  for (const auto& [_, on_match] : matchers_) {
+    on_match.ForEachAction(func);
+  }
+  if (on_no_match_.has_value()) {
+    on_no_match_->ForEachAction(func);
+  }
+}
+
 bool XdsMatcherList::AndPredicate::Equals(const Predicate& other) const {
   if (type() != other.type()) return false;
   const auto& o = DownCast<const AndPredicate&>(other);
@@ -213,6 +232,16 @@ bool XdsMatcherExactMap::FindMatches(const MatchContext& context,
   return false;
 }
 
+void XdsMatcherExactMap::ForEachAction(
+    absl::FunctionRef<void(const Action&)> func) const {
+  for (const auto& [_, on_match] : map_) {
+    on_match.ForEachAction(func);
+  }
+  if (on_no_match_.has_value()) {
+    on_no_match_->ForEachAction(func);
+  }
+}
+
 //
 // XdsMatcherPrefixMap
 //
@@ -256,10 +285,6 @@ bool XdsMatcherPrefixMap::FindMatches(const MatchContext& context,
   auto input = input_->GetValue(context);
   std::vector<const OnMatch*> on_match_results;
   root_.ForEachPrefixMatch(input.value_or(""), [&](const OnMatch& on_match) {
-    if (!on_match.keep_matching) {
-      // Don't need previous entries if we can use this one.
-      on_match_results.clear();
-    }
     on_match_results.push_back(&on_match);
   });
   for (auto it = on_match_results.rbegin(); it != on_match_results.rend();
@@ -274,4 +299,14 @@ bool XdsMatcherPrefixMap::FindMatches(const MatchContext& context,
   return false;
 }
 
+void XdsMatcherPrefixMap::ForEachAction(
+    absl::FunctionRef<void(const Action&)> func) const {
+  root_.ForEach([&](absl::string_view /*key*/, const OnMatch& on_match) {
+    on_match.ForEachAction(func);
+  });
+  if (on_no_match_.has_value()) {
+    on_no_match_->ForEachAction(func);
+  }
+}
+
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_matcher.h

@@ -105,6 +105,7 @@ class XdsMatcher {
     bool operator!=(const OnMatch& other) const { return !(*this == other); }
 
     bool FindMatches(const MatchContext& context, Result& result) const;
+    void ForEachAction(absl::FunctionRef<void(const Action&)> func) const;
     std::string ToString() const;
 
     std::variant<std::unique_ptr<Action>, std::unique_ptr<XdsMatcher>> action;
@@ -125,6 +126,12 @@ class XdsMatcher {
   // considered successful.
   virtual bool FindMatches(const MatchContext& context,
                            Result& result) const = 0;
+
+  // Calls func for each action in the matcher.  This can be used to
+  // initialize data structures that the caller needs for matching after
+  // the matcher tree has already been constructed.
+  virtual void ForEachAction(
+      absl::FunctionRef<void(const Action&)> func) const = 0;
 };
 
 //
@@ -223,6 +230,8 @@ class XdsMatcherList : public XdsMatcher {
   bool Equals(const XdsMatcher& other) const override;
   std::string ToString() const override;
   bool FindMatches(const MatchContext& context, Result& result) const override;
+  void ForEachAction(
+      absl::FunctionRef<void(const Action&)> func) const override;
 
  private:
   template <typename T>
@@ -401,6 +410,8 @@ class XdsMatcherExactMap : public XdsMatcher {
   bool Equals(const XdsMatcher& other) const override;
   std::string ToString() const override;
   bool FindMatches(const MatchContext& context, Result& result) const override;
+  void ForEachAction(
+      absl::FunctionRef<void(const Action&)> func) const override;
 
  private:
   std::unique_ptr<InputValue<absl::string_view>> input_;
@@ -420,6 +431,8 @@ class XdsMatcherPrefixMap : public XdsMatcher {
   bool Equals(const XdsMatcher& other) const override;
   std::string ToString() const override;
   bool FindMatches(const MatchContext& context, Result& result) const override;
+  void ForEachAction(
+      absl::FunctionRef<void(const Action&)> func) const override;
 
  private:
   TrieLookupTree<XdsMatcher::OnMatch> root_;

data/src/core/xds/grpc/xds_matcher_action.h

@@ -23,11 +23,11 @@ namespace grpc_core {
 
 class XdsMatcherActionFactory {
  public:
+  virtual ~XdsMatcherActionFactory() = default;
   virtual absl::string_view type() const = 0;
   virtual std::unique_ptr<XdsMatcher::Action> ParseAndCreateAction(
       const XdsResourceType::DecodeContext& context,
       absl::string_view serialized_value, ValidationErrors* errors) const = 0;
-  virtual ~XdsMatcherActionFactory() = default;
 };
 
 class XdsMatcherActionRegistry {

data/src/core/xds/grpc/xds_matcher_parse.cc

@@ -36,6 +36,12 @@ std::unique_ptr<XdsMatcherList::Predicate> ParsePredicate(
     const XdsResourceType::DecodeContext& context,
     const xds_type_matcher_v3_Matcher_MatcherList_Predicate* predicate,
     const UniqueTypeName& matcher_context, ValidationErrors* errors);
+std::unique_ptr<XdsMatcher> ParseXdsMatcherRecursive(
+    const XdsResourceType::DecodeContext& context,
+    const xds_type_matcher_v3_Matcher* matcher,
+    const XdsMatcherActionRegistry& action_registry,
+    const UniqueTypeName& matcher_context, bool allow_keep_matching, int depth,
+    ValidationErrors* errors);
 
 // Function to parse "xds_core_v3_TypedExtensionConfig" to generate
 // XdsMatcher::Input<T>
@@ -76,36 +82,25 @@ std::unique_ptr<XdsMatcher::Action> ParseAction(
   return action_registry.ParseAndCreateAction(context, *extension, errors);
 }
 
-// Parse and generate input matcher with type string_view
-// Parsing "xds_type_matcher_v3_StringMatcher" to generate StringMatcher
-std::unique_ptr<XdsMatcherList::InputMatcher<absl::string_view>>
-ParseStringMatcher(const XdsResourceType::DecodeContext& context,
-                   const xds_type_matcher_v3_StringMatcher* string_matcher_upb,
-                   ValidationErrors* errors) {
-  if (string_matcher_upb == nullptr) {
-    errors->AddError("field not present");
-    return nullptr;
-  }
-  auto string_matcher = StringMatcherParse(context, string_matcher_upb, errors);
-  return std::make_unique<XdsMatcherList::StringInputMatcher>(
-      std::move(string_matcher));
-}
-
 // Parse OnMatch components of the matcher
-// TODO(bpawan): b/431645556 this should have a max recursion depth
 XdsMatcher::OnMatch ParseOnMatch(
     const XdsResourceType::DecodeContext& context,
     const xds_type_matcher_v3_Matcher_OnMatch* on_match,
     const XdsMatcherActionRegistry& action_registry,
-    const UniqueTypeName& matcher_context, ValidationErrors* errors) {
+    const UniqueTypeName& matcher_context, bool allow_keep_matching, int depth,
+    ValidationErrors* errors) {
   if (on_match == nullptr) {
     errors->AddError("field not present");
     return XdsMatcher::OnMatch(std::unique_ptr<XdsMatcher::Action>(nullptr),
                                false);
   }
-  // TODO(bpawan): b/431645620 Parse keep matching once we move to latest xds
-  // protos
-  bool keep_matching = false;
+  // Handle keep_matching.
+  bool keep_matching =
+      xds_type_matcher_v3_Matcher_OnMatch_keep_matching(on_match);
+  if (keep_matching && !allow_keep_matching) {
+    ValidationErrors::ScopedField field(errors, ".keep_matching");
+    errors->AddError("not supported in this component");
+  }
   // Action is a variant which can have Action or a Nested Matcher
   if (const auto* action_proto =
           xds_type_matcher_v3_Matcher_OnMatch_action(on_match);
@@ -117,8 +112,9 @@ XdsMatcher::OnMatch ParseOnMatch(
                  xds_type_matcher_v3_Matcher_OnMatch_matcher(on_match);
              matcher_proto != nullptr) {
     ValidationErrors::ScopedField field(errors, ".matcher");
-    auto nested_matcher = ParseXdsMatcher(
-        context, matcher_proto, action_registry, matcher_context, errors);
+    auto nested_matcher = ParseXdsMatcherRecursive(
+        context, matcher_proto, action_registry, matcher_context,
+        allow_keep_matching, depth + 1, errors);
     return XdsMatcher::OnMatch(std::move(nested_matcher), keep_matching);
   } else {
     errors->AddError("One of action or matcher should be present");
@@ -132,7 +128,8 @@ absl::flat_hash_map<std::string, XdsMatcher::OnMatch> ParseMatchMap(
     const XdsResourceType::DecodeContext& context,
     const xds_type_matcher_v3_Matcher_MatcherTree_MatchMap* match_map,
     const XdsMatcherActionRegistry& action_registry,
-    const UniqueTypeName& matcher_context, ValidationErrors* errors) {
+    const UniqueTypeName& matcher_context, bool allow_keep_matching, int depth,
+    ValidationErrors* errors) {
   absl::flat_hash_map<std::string, XdsMatcher::OnMatch> result;
   if (xds_type_matcher_v3_Matcher_MatcherTree_MatchMap_map_size(match_map) ==
       0) {
@@ -146,7 +143,8 @@ absl::flat_hash_map<std::string, XdsMatcher::OnMatch> ParseMatchMap(
       match_map, &upb_key, &value, &iter)) {
     ValidationErrors::ScopedField field(errors, ".on_match");
     auto on_match =
-        ParseOnMatch(context, value, action_registry, matcher_context, errors);
+        ParseOnMatch(context, value, action_registry, matcher_context,
+                     allow_keep_matching, depth, errors);
     result.emplace(UpbStringToStdString(upb_key), std::move(on_match));
   }
   return result;
@@ -166,8 +164,8 @@ std::unique_ptr<XdsMatcherList::Predicate> ParseSinglePredicate(
     const auto* value_match_proto =
         xds_type_matcher_v3_Matcher_MatcherList_Predicate_SinglePredicate_value_match(
             single_predicate);
-    input_string_matcher =
-        ParseStringMatcher(context, value_match_proto, errors);
+    input_string_matcher = std::make_unique<XdsMatcherList::StringInputMatcher>(
+        StringMatcherParse(context, value_match_proto, errors));
   }
   std::unique_ptr<XdsMatcher::InputValue<absl::string_view>> input_string_value;
   {
@@ -258,7 +256,8 @@ std::vector<XdsMatcherList::FieldMatcher> ParseFieldMatcherList(
     const XdsResourceType::DecodeContext& context,
     const xds_type_matcher_v3_Matcher_MatcherList* matcher_list,
     const XdsMatcherActionRegistry& action_registry,
-    const UniqueTypeName& matcher_context, ValidationErrors* errors) {
+    const UniqueTypeName& matcher_context, bool allow_keep_matching, int depth,
+    ValidationErrors* errors) {
   std::vector<XdsMatcherList::FieldMatcher> field_matcher_list;
   size_t matcher_list_size;
   auto field_matchers = xds_type_matcher_v3_Matcher_MatcherList_matchers(
@@ -276,7 +275,7 @@ std::vector<XdsMatcherList::FieldMatcher> ParseFieldMatcherList(
           xds_type_matcher_v3_Matcher_MatcherList_FieldMatcher_on_match(
               field_matchers[i]);
       return ParseOnMatch(context, on_match_upb, action_registry,
-                          matcher_context, errors);
+                          matcher_context, allow_keep_matching, depth, errors);
     }();
     auto predicate = [&]() {
       ValidationErrors::ScopedField field(errors, ".predicate");
@@ -290,27 +289,29 @@ std::vector<XdsMatcherList::FieldMatcher> ParseFieldMatcherList(
   return field_matcher_list;
 }
 
-}  // namespace
-
-// Parse Matcher Proto
-// This the top level function expected to be called for the matcher.proto
-std::unique_ptr<XdsMatcher> ParseXdsMatcher(
+std::unique_ptr<XdsMatcher> ParseXdsMatcherRecursive(
     const XdsResourceType::DecodeContext& context,
     const xds_type_matcher_v3_Matcher* matcher,
     const XdsMatcherActionRegistry& action_registry,
-    const UniqueTypeName& matcher_context, ValidationErrors* errors) {
+    const UniqueTypeName& matcher_context, bool allow_keep_matching, int depth,
+    ValidationErrors* errors) {
+  if (depth == 16) {
+    errors->AddError("matcher tree exceeds max recursion depth");
+    return nullptr;
+  }
   std::optional<XdsMatcher::OnMatch> on_no_match;
   if (xds_type_matcher_v3_Matcher_has_on_no_match(matcher)) {
     ValidationErrors::ScopedField field(errors, ".on_no_match");
-    on_no_match =
-        ParseOnMatch(context, xds_type_matcher_v3_Matcher_on_no_match(matcher),
-                     action_registry, matcher_context, errors);
+    on_no_match = ParseOnMatch(
+        context, xds_type_matcher_v3_Matcher_on_no_match(matcher),
+        action_registry, matcher_context, allow_keep_matching, depth, errors);
   }
   if (xds_type_matcher_v3_Matcher_has_matcher_list(matcher)) {
     ValidationErrors::ScopedField field(errors, ".matcher_list");
     auto matcher_list = xds_type_matcher_v3_Matcher_matcher_list(matcher);
     auto field_matcher_list = ParseFieldMatcherList(
-        context, matcher_list, action_registry, matcher_context, errors);
+        context, matcher_list, action_registry, matcher_context,
+        allow_keep_matching, depth, errors);
     return std::make_unique<XdsMatcherList>(std::move(field_matcher_list),
                                             std::move(on_no_match));
   } else if (xds_type_matcher_v3_Matcher_has_matcher_tree(matcher)) {
@@ -329,7 +330,7 @@ std::unique_ptr<XdsMatcher> ParseXdsMatcher(
       auto map = ParseMatchMap(
           context,
           xds_type_matcher_v3_Matcher_MatcherTree_exact_match_map(matcher_tree),
-          action_registry, matcher_context, errors);
+          action_registry, matcher_context, allow_keep_matching, depth, errors);
       return std::make_unique<XdsMatcherExactMap>(
           std::move(input), std::move(map), std::move(on_no_match));
     } else if (xds_type_matcher_v3_Matcher_MatcherTree_has_prefix_match_map(
@@ -339,7 +340,7 @@ std::unique_ptr<XdsMatcher> ParseXdsMatcher(
           context,
           xds_type_matcher_v3_Matcher_MatcherTree_prefix_match_map(
               matcher_tree),
-          action_registry, matcher_context, errors);
+          action_registry, matcher_context, allow_keep_matching, depth, errors);
       return std::make_unique<XdsMatcherPrefixMap>(
           std::move(input), std::move(map), std::move(on_no_match));
     } else {
@@ -353,4 +354,23 @@ std::unique_ptr<XdsMatcher> ParseXdsMatcher(
   return nullptr;
 }
 
+}  // namespace
+
+// Parse Matcher Proto
+// This the top level function expected to be called for the matcher.proto
+std::unique_ptr<XdsMatcher> ParseXdsMatcher(
+    const XdsResourceType::DecodeContext& context,
+    const xds_type_matcher_v3_Matcher* matcher,
+    const XdsMatcherActionRegistry& action_registry,
+    const UniqueTypeName& matcher_context, bool allow_keep_matching,
+    ValidationErrors* errors) {
+  if (matcher == nullptr) {
+    errors->AddError("field not set");
+    return nullptr;
+  }
+  return ParseXdsMatcherRecursive(context, matcher, action_registry,
+                                  matcher_context, allow_keep_matching,
+                                  /*depth=*/0, errors);
+}
+
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_matcher_parse.h

@@ -32,7 +32,8 @@ std::unique_ptr<XdsMatcher> ParseXdsMatcher(
     const XdsResourceType::DecodeContext& context,
     const xds_type_matcher_v3_Matcher* matcher,
     const XdsMatcherActionRegistry& action_registry,
-    const UniqueTypeName& matcher_context, ValidationErrors* errors);
+    const UniqueTypeName& matcher_context, bool allow_keep_matching,
+    ValidationErrors* errors);
 
 }  // namespace grpc_core
 

data/src/core/xds/grpc/xds_route_config.cc

@@ -31,6 +31,17 @@
 
 namespace grpc_core {
 
+//
+// XdsRouteConfigResource::FilterConfigOverride
+//
+
+std::string XdsRouteConfigResource::FilterConfigOverride::ToString() const {
+  return absl::StrCat(
+      "{config_proto_type=", config_proto_type, ", config=", JsonDump(config),
+      ", filter_config=",
+      filter_config == nullptr ? "null" : filter_config->ToString(), "}");
+}
+
 //
 // XdsRouteConfigResource::RetryPolicy
 //
@@ -229,7 +240,7 @@ std::string XdsRouteConfigResource::Route::ToString() const {
 }
 
 //
-// XdsRouteConfigResource::Route
+// XdsRouteConfigResource::VirtualHost
 //
 
 std::string XdsRouteConfigResource::VirtualHost::ToString() const {

data/src/core/xds/grpc/xds_route_config.h

@@ -38,8 +38,21 @@
 namespace grpc_core {
 
 struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
-  using TypedPerFilterConfig =
-      std::map<std::string, XdsHttpFilterImpl::FilterConfig>;
+  struct FilterConfigOverride {
+    absl::string_view config_proto_type;
+    Json config;
+    RefCountedPtr<const FilterConfig> filter_config;
+
+    bool operator==(const FilterConfigOverride& other) const {
+      if (config_proto_type != other.config_proto_type) return false;
+      if (config != other.config) return false;
+      if (filter_config == nullptr) return other.filter_config != nullptr;
+      if (other.filter_config == nullptr) return false;
+      return *filter_config == *other.filter_config;
+    }
+    std::string ToString() const;
+  };
+  using TypedPerFilterConfig = std::map<std::string, FilterConfigOverride>;
 
   using ClusterSpecifierPluginMap =
       std::map<std::string /*cluster_specifier_plugin_name*/,

data/src/core/xds/grpc/xds_route_config_parser.cc

@@ -398,16 +398,22 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
         DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
             .http_filter_registry();
     const XdsHttpFilterImpl* filter_impl =
-        http_filter_registry.GetFilterForType(extension_to_use->type);
+        http_filter_registry.GetFilterForOverrideType(extension_to_use->type);
     if (filter_impl == nullptr) {
       if (!is_optional) errors->AddError("unsupported filter type");
       continue;
     }
-    std::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
-        filter_impl->GenerateFilterConfigOverride(
-            key, context, std::move(*extension_to_use), errors);
+    auto& entry = typed_per_filter_config[std::string(key)];
+    entry.config_proto_type = filter_impl->OverrideConfigProtoName();
+    std::optional<Json> filter_config =
+        filter_impl->GenerateFilterConfigOverride(key, context,
+                                                  *extension_to_use, errors);
     if (filter_config.has_value()) {
-      typed_per_filter_config[std::string(key)] = std::move(*filter_config);
+      entry.config = std::move(*filter_config);
+    }
+    if (IsXdsChannelFilterChainPerRouteEnabled()) {
+      entry.filter_config = filter_impl->ParseOverrideConfig(
+          key, context, *extension_to_use, errors);
     }
   }
   return typed_per_filter_config;