grpc 1.50.0 → 1.51.0

data/src/core/ext/xds/xds_listener.h

@@ -24,7 +24,6 @@
 
 #include <algorithm>
 #include <array>
-#include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
@@ -32,10 +31,13 @@
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "absl/types/variant.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
 #include "upb/def.h"
 
+#include "src/core/ext/xds/xds_bootstrap_grpc.h"
+#include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/ext/xds/xds_resource_type.h"
@@ -46,36 +48,14 @@
 
 namespace grpc_core {
 
-// TODO(roth): When we can use absl::variant<>, consider using that
-// here, to enforce the fact that only one of the two fields can be set.
-struct XdsListenerResource {
-  struct DownstreamTlsContext {
-    CommonTlsContext common_tls_context;
-    bool require_client_certificate = false;
-
-    bool operator==(const DownstreamTlsContext& other) const {
-      return common_tls_context == other.common_tls_context &&
-             require_client_certificate == other.require_client_certificate;
-    }
-
-    std::string ToString() const;
-    bool Empty() const;
-  };
-
-  enum class ListenerType {
-    kTcpListener = 0,
-    kHttpApiListener,
-  } type;
-
+struct XdsListenerResource : public XdsResourceType::ResourceData {
   struct HttpConnectionManager {
-    // The name to use in the RDS request.
-    std::string route_config_name;
+    // The RDS resource name or inline RouteConfiguration.
+    absl::variant<std::string, XdsRouteConfigResource> route_config;
+
     // Storing the Http Connection Manager Common Http Protocol Option
     // max_stream_duration
     Duration http_max_stream_duration;
-    // The RouteConfiguration to use for this listener.
-    // Present only if it is inlined in the LDS response.
-    absl::optional<XdsRouteConfigResource> rds_update;
 
     struct HttpFilter {
       std::string name;
@@ -90,21 +70,26 @@ struct XdsListenerResource {
     std::vector<HttpFilter> http_filters;
 
     bool operator==(const HttpConnectionManager& other) const {
-      return route_config_name == other.route_config_name &&
+      return route_config == other.route_config &&
              http_max_stream_duration == other.http_max_stream_duration &&
-             rds_update == other.rds_update &&
              http_filters == other.http_filters;
     }
 
     std::string ToString() const;
   };
 
-  // Populated for type=kHttpApiListener.
-  HttpConnectionManager http_connection_manager;
+  struct DownstreamTlsContext {
+    CommonTlsContext common_tls_context;
+    bool require_client_certificate = false;
+
+    bool operator==(const DownstreamTlsContext& other) const {
+      return common_tls_context == other.common_tls_context &&
+             require_client_certificate == other.require_client_certificate;
+    }
 
-  // Populated for type=kTcpListener.
-  // host:port listening_address set when type is kTcpListener
-  std::string address;
+    std::string ToString() const;
+    bool Empty() const;
+  };
 
   struct FilterChainData {
     DownstreamTlsContext downstream_tls_context;
@@ -185,15 +170,26 @@ struct XdsListenerResource {
     }
 
     std::string ToString() const;
-  } filter_chain_map;
+  };
+
+  struct TcpListener {
+    std::string address;  // host:port listening address
+    FilterChainMap filter_chain_map;
+    absl::optional<FilterChainData> default_filter_chain;
+
+    bool operator==(const TcpListener& other) const {
+      return address == other.address &&
+             filter_chain_map == other.filter_chain_map &&
+             default_filter_chain == other.default_filter_chain;
+    }
 
-  absl::optional<FilterChainData> default_filter_chain;
+    std::string ToString() const;
+  };
+
+  absl::variant<HttpConnectionManager, TcpListener> listener;
 
   bool operator==(const XdsListenerResource& other) const {
-    return http_connection_manager == other.http_connection_manager &&
-           address == other.address &&
-           filter_chain_map == other.filter_chain_map &&
-           default_filter_chain == other.default_filter_chain;
+    return listener == other.listener;
   }
 
   std::string ToString() const;
@@ -205,21 +201,21 @@ class XdsListenerResourceType
   absl::string_view type_url() const override {
     return "envoy.config.listener.v3.Listener";
   }
-  absl::string_view v2_type_url() const override {
-    return "envoy.api.v2.Listener";
-  }
 
   DecodeResult Decode(const XdsResourceType::DecodeContext& context,
-                      absl::string_view serialized_resource,
-                      bool is_v2) const override;
+                      absl::string_view serialized_resource) const override;
 
   bool AllResourcesRequiredInSotW() const override { return true; }
 
-  void InitUpbSymtab(upb_DefPool* symtab) const override {
+  void InitUpbSymtab(XdsClient* xds_client,
+                     upb_DefPool* symtab) const override {
     envoy_config_listener_v3_Listener_getmsgdef(symtab);
     envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_getmsgdef(
         symtab);
-    XdsHttpFilterRegistry::PopulateSymtab(symtab);
+    const auto& http_filter_registry =
+        static_cast<const GrpcXdsBootstrap&>(xds_client->bootstrap())
+            .http_filter_registry();
+    http_filter_registry.PopulateSymtab(symtab);
   }
 };
 

data/src/core/ext/xds/xds_resource_type.h

@@ -69,13 +69,9 @@ class XdsResourceType {
   // Returns v3 resource type.
   virtual absl::string_view type_url() const = 0;
 
-  // Returns v2 resource type.
-  virtual absl::string_view v2_type_url() const = 0;
-
   // Decodes and validates a serialized resource proto.
   virtual DecodeResult Decode(const DecodeContext& context,
-                              absl::string_view serialized_resource,
-                              bool is_v2) const = 0;
+                              absl::string_view serialized_resource) const = 0;
 
   // Returns true if r1 and r2 are equal.
   // Must be invoked only on resources returned by this object's Decode()
@@ -99,12 +95,8 @@ class XdsResourceType {
   // properly in logs.
   // Note: This won't actually work properly until upb adds support for
   // Any fields in textproto printing (internal b/178821188).
-  virtual void InitUpbSymtab(upb_DefPool* symtab) const = 0;
-
-  // Convenience method for checking if resource_type matches this type.
-  // Checks against both type_url() and v2_type_url().
-  // If is_v2 is non-null, it will be set to true if matching v2_type_url().
-  bool IsType(absl::string_view resource_type, bool* is_v2) const;
+  virtual void InitUpbSymtab(XdsClient* xds_client,
+                             upb_DefPool* symtab) const = 0;
 };
 
 }  // namespace grpc_core

data/src/core/ext/xds/xds_resource_type_impl.h

@@ -30,13 +30,11 @@ namespace grpc_core {
 
 // Base class for XdsResourceType implementations.
 // Handles all down-casting logic for a particular resource type struct.
+// ResourceTypeStruct must inherit from XdsResourceType::ResourceData,
+// must be copy-constructible, and must implement operator==().
 template <typename Subclass, typename ResourceTypeStruct>
 class XdsResourceTypeImpl : public XdsResourceType {
  public:
-  struct ResourceDataSubclass : public ResourceData {
-    ResourceTypeStruct resource;
-  };
-
   // XdsClient watcher that handles down-casting.
   class WatcherInterface : public XdsClient::ResourceWatcherInterface {
    public:
@@ -44,11 +42,10 @@ class XdsResourceTypeImpl : public XdsResourceType {
 
    private:
     // Get result from XdsClient generic watcher interface, perform
-    // down-casting, and invoke the caller's OnListenerChanged() method.
+    // down-casting, and invoke the caller's OnResourceChanged() method.
     void OnGenericResourceChanged(
         const XdsResourceType::ResourceData* resource) override {
-      OnResourceChanged(
-          static_cast<const ResourceDataSubclass*>(resource)->resource);
+      OnResourceChanged(*static_cast<const ResourceTypeStruct*>(resource));
     }
   };
 
@@ -73,16 +70,14 @@ class XdsResourceTypeImpl : public XdsResourceType {
 
   bool ResourcesEqual(const ResourceData* r1,
                       const ResourceData* r2) const override {
-    return static_cast<const ResourceDataSubclass*>(r1)->resource ==
-           static_cast<const ResourceDataSubclass*>(r2)->resource;
+    return *static_cast<const ResourceTypeStruct*>(r1) ==
+           *static_cast<const ResourceTypeStruct*>(r2);
   }
 
   std::unique_ptr<ResourceData> CopyResource(
       const ResourceData* resource) const override {
-    auto* resource_copy = new ResourceDataSubclass();
-    resource_copy->resource =
-        static_cast<const ResourceDataSubclass*>(resource)->resource;
-    return std::unique_ptr<ResourceData>(resource_copy);
+    return std::make_unique<ResourceTypeStruct>(
+        *static_cast<const ResourceTypeStruct*>(resource));
   }
 };
 

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

@@ -28,7 +28,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -58,12 +57,10 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/xds/upb_utils.h"
-#include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/ext/xds/xds_resource_type.h"
-#include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/ext/xds/xds_routing.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/debug/trace.h"
@@ -71,20 +68,11 @@
 #include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/matchers/matchers.h"
 
 namespace grpc_core {
 
-// TODO(yashykt): Remove once RBAC is no longer experimental
-bool XdsRbacEnabled() {
-  auto value = GetEnv("GRPC_XDS_EXPERIMENTAL_RBAC");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 // TODO(donnadionne): Remove once RLS is no longer experimental
 bool XdsRlsEnabled() {
   auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_RLS_LB");
@@ -144,7 +132,7 @@ XdsRouteConfigResource::Route::RouteAction::HashPolicy::HashPolicy(
       regex_substitution(other.regex_substitution) {
   if (other.regex != nullptr) {
     regex =
-        absl::make_unique<RE2>(other.regex->pattern(), other.regex->options());
+        std::make_unique<RE2>(other.regex->pattern(), other.regex->options());
   }
 }
 
@@ -155,7 +143,7 @@ XdsRouteConfigResource::Route::RouteAction::HashPolicy::operator=(
   header_name = other.header_name;
   if (other.regex != nullptr) {
     regex =
-        absl::make_unique<RE2>(other.regex->pattern(), other.regex->options());
+        std::make_unique<RE2>(other.regex->pattern(), other.regex->options());
   }
   regex_substitution = other.regex_substitution;
   return *this;
@@ -243,6 +231,7 @@ XdsRouteConfigResource::Route::RouteAction::ClusterWeight::ToString() const {
 
 std::string XdsRouteConfigResource::Route::RouteAction::ToString() const {
   std::vector<std::string> contents;
+  contents.reserve(hash_policies.size());
   for (const HashPolicy& hash_policy : hash_policies) {
     contents.push_back(absl::StrCat("hash_policy=", hash_policy.ToString()));
   }
@@ -345,45 +334,56 @@ ClusterSpecifierPluginParse(
     const envoy_config_route_v3_RouteConfiguration* route_config) {
   XdsRouteConfigResource::ClusterSpecifierPluginMap
       cluster_specifier_plugin_map;
+  const auto& cluster_specifier_plugin_registry =
+      static_cast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+          .cluster_specifier_plugin_registry();
   size_t num_cluster_specifier_plugins;
   const envoy_config_route_v3_ClusterSpecifierPlugin* const*
       cluster_specifier_plugin =
           envoy_config_route_v3_RouteConfiguration_cluster_specifier_plugins(
               route_config, &num_cluster_specifier_plugins);
   for (size_t i = 0; i < num_cluster_specifier_plugins; ++i) {
-    const envoy_config_core_v3_TypedExtensionConfig* extension =
+    const envoy_config_core_v3_TypedExtensionConfig* typed_extension_config =
         envoy_config_route_v3_ClusterSpecifierPlugin_extension(
             cluster_specifier_plugin[i]);
     std::string name = UpbStringToStdString(
-        envoy_config_core_v3_TypedExtensionConfig_name(extension));
+        envoy_config_core_v3_TypedExtensionConfig_name(typed_extension_config));
     if (cluster_specifier_plugin_map.find(name) !=
         cluster_specifier_plugin_map.end()) {
       return absl::InvalidArgumentError(absl::StrCat(
           "Duplicated definition of cluster_specifier_plugin ", name));
     }
     const google_protobuf_Any* any =
-        envoy_config_core_v3_TypedExtensionConfig_typed_config(extension);
+        envoy_config_core_v3_TypedExtensionConfig_typed_config(
+            typed_extension_config);
     if (any == nullptr) {
       return absl::InvalidArgumentError(
           "Could not obtrain TypedExtensionConfig for plugin config.");
     }
-    auto plugin_type = ExtractExtensionTypeName(context, any);
-    if (!plugin_type.ok()) return plugin_type.status();
+    ValidationErrors validation_errors;
+    ValidationErrors::ScopedField field(
+        &validation_errors, absl::StrCat(".cluster_specifier_plugins[", i,
+                                         "].extension.typed_config"));
+    auto extension = ExtractXdsExtension(context, any, &validation_errors);
+    if (!validation_errors.ok()) {
+      return validation_errors.status("could not determine extension type");
+    }
+    GPR_ASSERT(extension.has_value());
     bool is_optional = envoy_config_route_v3_ClusterSpecifierPlugin_is_optional(
         cluster_specifier_plugin[i]);
     const XdsClusterSpecifierPluginImpl* cluster_specifier_plugin_impl =
-        XdsClusterSpecifierPluginRegistry::GetPluginForType(plugin_type->type);
+        cluster_specifier_plugin_registry.GetPluginForType(extension->type);
     std::string lb_policy_config;
     if (cluster_specifier_plugin_impl == nullptr) {
       if (!is_optional) {
         return absl::InvalidArgumentError(absl::StrCat(
-            "Unknown ClusterSpecifierPlugin type ", plugin_type->type));
+            "Unknown ClusterSpecifierPlugin type ", extension->type));
       }
       // Optional plugin, leave lb_policy_config empty.
     } else {
       auto config =
           cluster_specifier_plugin_impl->GenerateLoadBalancingPolicyConfig(
-              google_protobuf_Any_value(any), context.arena, context.symtab);
+              std::move(*extension), context.arena, context.symtab);
       if (!config.ok()) return config.status();
       lb_policy_config = std::move(*config);
     }
@@ -581,7 +581,7 @@ absl::Status RouteRuntimeFractionParse(
       route->matchers.fraction_per_million = numerator;
     }
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 template <typename ParentType, typename EntryType>
@@ -627,23 +627,31 @@ ParseTypedPerFilterConfig(
             absl::StrCat("no filter config specified for filter name ", key));
       }
     }
-    auto type = ExtractExtensionTypeName(context, any);
-    if (!type.ok()) return type.status();
+    ValidationErrors errors;
+    ValidationErrors::ScopedField field(
+        &errors, absl::StrCat(".typed_per_filter_config[", key, "]"));
+    auto extension = ExtractXdsExtension(context, any, &errors);
+    if (!errors.ok()) {
+      return errors.status("could not determine extension type");
+    }
+    GPR_ASSERT(extension.has_value());
+    const auto& http_filter_registry =
+        static_cast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+            .http_filter_registry();
     const XdsHttpFilterImpl* filter_impl =
-        XdsHttpFilterRegistry::GetFilterForType(type->type);
+        http_filter_registry.GetFilterForType(extension->type);
     if (filter_impl == nullptr) {
       if (is_optional) continue;
-      return absl::InvalidArgumentError(
-          absl::StrCat("no filter registered for config type ", type->type));
+      return absl::InvalidArgumentError(absl::StrCat(
+          "no filter registered for config type ", extension->type));
     }
-    absl::StatusOr<XdsHttpFilterImpl::FilterConfig> filter_config =
-        filter_impl->GenerateFilterConfigOverride(
-            google_protobuf_Any_value(any), context.arena);
-    if (!filter_config.ok()) {
-      return absl::InvalidArgumentError(
-          absl::StrCat("filter config for type ", type->type,
-                       " failed to parse: ", filter_config.status().message()));
+    absl::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
+        filter_impl->GenerateFilterConfigOverride(std::move(*extension),
+                                                  context.arena, &errors);
+    if (!errors.ok()) {
+      return errors.status("errors validation extension");
     }
+    GPR_ASSERT(filter_config.has_value());
     typed_per_filter_config[std::string(key)] = std::move(*filter_config);
   }
   return typed_per_filter_config;
@@ -698,14 +706,23 @@ absl::Status RetryPolicyParse(
       errors.emplace_back(
           "RouteAction RetryPolicy RetryBackoff missing base interval.");
     } else {
+      ValidationErrors validation_errors;
       retry_to_return.retry_back_off.base_interval =
-          ParseDuration(base_interval);
+          ParseDuration(base_interval, &validation_errors);
+      if (!validation_errors.ok()) {
+        errors.emplace_back(
+            validation_errors.status("base_interval").message());
+      }
     }
     const google_protobuf_Duration* max_interval =
         envoy_config_route_v3_RetryPolicy_RetryBackOff_max_interval(backoff);
     Duration max;
     if (max_interval != nullptr) {
-      max = ParseDuration(max_interval);
+      ValidationErrors validation_errors;
+      max = ParseDuration(max_interval, &validation_errors);
+      if (!validation_errors.ok()) {
+        errors.emplace_back(validation_errors.status("max_interval").message());
+      }
     } else {
       // if max interval is not set, it is 10x the base.
       max = 10 * retry_to_return.retry_back_off.base_interval;
@@ -783,19 +800,17 @@ absl::StatusOr<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
       cluster.weight = google_protobuf_UInt32Value_value(weight);
       if (cluster.weight == 0) continue;
       sum_of_weights += cluster.weight;
-      if (context.server.ShouldUseV3()) {
-        auto typed_per_filter_config = ParseTypedPerFilterConfig<
-            envoy_config_route_v3_WeightedCluster_ClusterWeight,
-            envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry>(
-            context, cluster_weight,
-            envoy_config_route_v3_WeightedCluster_ClusterWeight_typed_per_filter_config_next,
-            envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_key,
-            envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_value);
-        if (!typed_per_filter_config.ok()) {
-          return typed_per_filter_config.status();
-        }
-        cluster.typed_per_filter_config = std::move(*typed_per_filter_config);
+      auto typed_per_filter_config = ParseTypedPerFilterConfig<
+          envoy_config_route_v3_WeightedCluster_ClusterWeight,
+          envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry>(
+          context, cluster_weight,
+          envoy_config_route_v3_WeightedCluster_ClusterWeight_typed_per_filter_config_next,
+          envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_key,
+          envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_value);
+      if (!typed_per_filter_config.ok()) {
+        return typed_per_filter_config.status();
       }
+      cluster.typed_per_filter_config = std::move(*typed_per_filter_config);
       action_weighted_clusters.emplace_back(std::move(cluster));
     }
     if (total_weight != sum_of_weights) {
@@ -847,7 +862,11 @@ absl::StatusOr<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
                 max_stream_duration);
       }
       if (duration != nullptr) {
-        route.max_stream_duration = ParseDuration(duration);
+        ValidationErrors validation_errors;
+        route.max_stream_duration = ParseDuration(duration, &validation_errors);
+        if (!validation_errors.ok()) {
+          return validation_errors.status("max_stream_duration");
+        }
       }
     }
   }
@@ -888,7 +907,7 @@ absl::StatusOr<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
           continue;
         }
         RE2::Options options;
-        policy.regex = absl::make_unique<RE2>(
+        policy.regex = std::make_unique<RE2>(
             UpbStringToStdString(
                 envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher)),
             options);
@@ -980,19 +999,17 @@ absl::StatusOr<XdsRouteConfigResource> XdsRouteConfigResource::Parse(
       return absl::InvalidArgumentError("VirtualHost has no domains");
     }
     // Parse typed_per_filter_config.
-    if (context.server.ShouldUseV3()) {
-      auto typed_per_filter_config = ParseTypedPerFilterConfig<
-          envoy_config_route_v3_VirtualHost,
-          envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry>(
-          context, virtual_hosts[i],
-          envoy_config_route_v3_VirtualHost_typed_per_filter_config_next,
-          envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_key,
-          envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_value);
-      if (!typed_per_filter_config.ok()) {
-        return typed_per_filter_config.status();
-      }
-      vhost.typed_per_filter_config = std::move(*typed_per_filter_config);
+    auto typed_per_filter_config = ParseTypedPerFilterConfig<
+        envoy_config_route_v3_VirtualHost,
+        envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry>(
+        context, virtual_hosts[i],
+        envoy_config_route_v3_VirtualHost_typed_per_filter_config_next,
+        envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_key,
+        envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_value);
+    if (!typed_per_filter_config.ok()) {
+      return typed_per_filter_config.status();
     }
+    vhost.typed_per_filter_config = std::move(*typed_per_filter_config);
     // Parse retry policy.
     absl::optional<XdsRouteConfigResource::RetryPolicy>
         virtual_host_retry_policy;
@@ -1063,19 +1080,17 @@ absl::StatusOr<XdsRouteConfigResource> XdsRouteConfigResource::Parse(
         route.action
             .emplace<XdsRouteConfigResource::Route::NonForwardingAction>();
       }
-      if (context.server.ShouldUseV3()) {
-        auto typed_per_filter_config = ParseTypedPerFilterConfig<
-            envoy_config_route_v3_Route,
-            envoy_config_route_v3_Route_TypedPerFilterConfigEntry>(
-            context, routes[j],
-            envoy_config_route_v3_Route_typed_per_filter_config_next,
-            envoy_config_route_v3_Route_TypedPerFilterConfigEntry_key,
-            envoy_config_route_v3_Route_TypedPerFilterConfigEntry_value);
-        if (!typed_per_filter_config.ok()) {
-          return typed_per_filter_config.status();
-        }
-        route.typed_per_filter_config = std::move(*typed_per_filter_config);
+      auto typed_per_filter_config = ParseTypedPerFilterConfig<
+          envoy_config_route_v3_Route,
+          envoy_config_route_v3_Route_TypedPerFilterConfigEntry>(
+          context, routes[j],
+          envoy_config_route_v3_Route_typed_per_filter_config_next,
+          envoy_config_route_v3_Route_TypedPerFilterConfigEntry_key,
+          envoy_config_route_v3_Route_TypedPerFilterConfigEntry_value);
+      if (!typed_per_filter_config.ok()) {
+        return typed_per_filter_config.status();
       }
+      route.typed_per_filter_config = std::move(*typed_per_filter_config);
       vhost.routes.emplace_back(std::move(route));
     }
     if (vhost.routes.empty()) {
@@ -1114,7 +1129,7 @@ void MaybeLogRouteConfiguration(
 
 XdsResourceType::DecodeResult XdsRouteConfigResourceType::Decode(
     const XdsResourceType::DecodeContext& context,
-    absl::string_view serialized_resource, bool /*is_v2*/) const {
+    absl::string_view serialized_resource) const {
   DecodeResult result;
   // Parse serialized proto.
   auto* resource = envoy_config_route_v3_RouteConfiguration_parse(
@@ -1142,9 +1157,8 @@ XdsResourceType::DecodeResult XdsRouteConfigResourceType::Decode(
               context.client, result.name->c_str(),
               rds_update->ToString().c_str());
     }
-    auto resource = absl::make_unique<ResourceDataSubclass>();
-    resource->resource = std::move(*rds_update);
-    result.resource = std::move(resource);
+    result.resource =
+        std::make_unique<XdsRouteConfigResource>(std::move(*rds_update));
   }
   return result;
 }

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

@@ -36,6 +36,8 @@
 #include "re2/re2.h"
 #include "upb/def.h"
 
+#include "src/core/ext/xds/xds_bootstrap_grpc.h"
+#include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/ext/xds/xds_resource_type.h"
@@ -46,9 +48,7 @@
 
 namespace grpc_core {
 
-bool XdsRbacEnabled();
-
-struct XdsRouteConfigResource {
+struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
   using TypedPerFilterConfig =
       std::map<std::string, XdsHttpFilterImpl::FilterConfig>;
 
@@ -222,17 +222,17 @@ class XdsRouteConfigResourceType
   absl::string_view type_url() const override {
     return "envoy.config.route.v3.RouteConfiguration";
   }
-  absl::string_view v2_type_url() const override {
-    return "envoy.api.v2.RouteConfiguration";
-  }
 
   DecodeResult Decode(const XdsResourceType::DecodeContext& context,
-                      absl::string_view serialized_resource,
-                      bool /*is_v2*/) const override;
+                      absl::string_view serialized_resource) const override;
 
-  void InitUpbSymtab(upb_DefPool* symtab) const override {
+  void InitUpbSymtab(XdsClient* xds_client,
+                     upb_DefPool* symtab) const override {
     envoy_config_route_v3_RouteConfiguration_getmsgdef(symtab);
-    XdsClusterSpecifierPluginRegistry::PopulateSymtab(symtab);
+    const auto& cluster_specifier_plugin_registry =
+        static_cast<const GrpcXdsBootstrap&>(xds_client->bootstrap())
+            .cluster_specifier_plugin_registry();
+    cluster_specifier_plugin_registry.PopulateSymtab(symtab);
   }
 };
 

data/src/core/ext/xds/xds_routing.cc

@@ -220,6 +220,7 @@ const XdsHttpFilterImpl::FilterConfig* FindFilterConfigOverride(
 
 absl::StatusOr<XdsRouting::GeneratePerHttpFilterConfigsResult>
 XdsRouting::GeneratePerHTTPFilterConfigs(
+    const XdsHttpFilterRegistry& http_filter_registry,
     const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
         http_filters,
     const XdsRouteConfigResource::VirtualHost& vhost,
@@ -233,7 +234,7 @@ XdsRouting::GeneratePerHTTPFilterConfigs(
     // Find filter.  This is guaranteed to succeed, because it's checked
     // at config validation time in the XdsApi code.
     const XdsHttpFilterImpl* filter_impl =
-        XdsHttpFilterRegistry::GetFilterForType(
+        http_filter_registry.GetFilterForType(
             http_filter.config.config_proto_type_name);
     GPR_ASSERT(filter_impl != nullptr);
     // If there is not actually any C-core filter associated with this

data/src/core/ext/xds/xds_routing.h

@@ -31,6 +31,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/ext/xds/xds_listener.h"
 #include "src/core/ext/xds/xds_route_config.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -90,6 +91,7 @@ class XdsRouting {
   // Generates a map of per_filter_configs. \a args is consumed.
   static absl::StatusOr<GeneratePerHttpFilterConfigsResult>
   GeneratePerHTTPFilterConfigs(
+      const XdsHttpFilterRegistry& http_filter_registry,
       const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
           http_filters,
       const XdsRouteConfigResource::VirtualHost& vhost,