grpc 1.44.0.pre2 → 1.46.3

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

@@ -55,7 +55,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
     virtual void OnGenericResourceChanged(
         const XdsResourceType::ResourceData* resource)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnError(grpc_error_handle error)
+    virtual void OnError(absl::Status status)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
     virtual void OnResourceDoesNotExist()
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
@@ -114,9 +114,9 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
   // Adds and removes drop stats for cluster_name and eds_service_name.
   RefCountedPtr<XdsClusterDropStats> AddClusterDropStats(
-      absl::string_view lrs_server, absl::string_view cluster_name,
+      const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
       absl::string_view eds_service_name);
-  void RemoveClusterDropStats(absl::string_view /*lrs_server*/,
+  void RemoveClusterDropStats(const XdsBootstrap::XdsServer& xds_server,
                               absl::string_view cluster_name,
                               absl::string_view eds_service_name,
                               XdsClusterDropStats* cluster_drop_stats);
@@ -124,11 +124,11 @@ class XdsClient : public DualRefCounted<XdsClient> {
   // Adds and removes locality stats for cluster_name and eds_service_name
   // for the specified locality.
   RefCountedPtr<XdsClusterLocalityStats> AddClusterLocalityStats(
-      absl::string_view lrs_server, absl::string_view cluster_name,
+      const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
       absl::string_view eds_service_name,
       RefCountedPtr<XdsLocalityName> locality);
   void RemoveClusterLocalityStats(
-      absl::string_view /*lrs_server*/, absl::string_view cluster_name,
+      const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
       absl::string_view eds_service_name,
       const RefCountedPtr<XdsLocalityName>& locality,
       XdsClusterLocalityStats* cluster_locality_stats);
@@ -189,12 +189,13 @@ class XdsClient : public DualRefCounted<XdsClient> {
     LrsCallState* lrs_calld() const;
 
     void MaybeStartLrsCall();
-    void StopLrsCall();
+    void StopLrsCallLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
     bool HasAdsCall() const;
     bool HasActiveAdsCall() const;
 
-    void StartConnectivityWatchLocked();
+    void StartConnectivityWatchLocked()
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
     void CancelConnectivityWatchLocked();
 
     void SubscribeLocked(const XdsResourceType* type,
@@ -252,14 +253,31 @@ class XdsClient : public DualRefCounted<XdsClient> {
     std::map<RefCountedPtr<XdsLocalityName>, LocalityState,
              XdsLocalityName::Less>
         locality_stats;
-    grpc_millis last_report_time = ExecCtx::Get()->Now();
+    Timestamp last_report_time = ExecCtx::Get()->Now();
   };
 
-  class Notifier;
+  // Load report data.
+  using LoadReportMap = std::map<
+      std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
+      LoadReportState>;
+
+  struct LoadReportServer {
+    RefCountedPtr<ChannelState> channel_state;
+    LoadReportMap load_report_map;
+  };
 
   // Sends an error notification to all watchers.
-  void NotifyOnErrorLocked(grpc_error_handle error)
+  void NotifyOnErrorLocked(absl::Status status)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  // Sends an error notification to a specific set of watchers.
+  void NotifyWatchersOnErrorLocked(
+      const std::map<ResourceWatcherInterface*,
+                     RefCountedPtr<ResourceWatcherInterface>>& watchers,
+      absl::Status status);
+  // Sends a resource-does-not-exist notification to a specific set of watchers.
+  void NotifyWatchersOnResourceDoesNotExist(
+      const std::map<ResourceWatcherInterface*,
+                     RefCountedPtr<ResourceWatcherInterface>>& watchers);
 
   void MaybeRegisterResourceTypeLocked(const XdsResourceType* resource_type)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
@@ -268,22 +286,23 @@ class XdsClient : public DualRefCounted<XdsClient> {
   const XdsResourceType* GetResourceTypeLocked(absl::string_view resource_type)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
-  static absl::StatusOr<XdsResourceName> ParseXdsResourceName(
+  absl::StatusOr<XdsResourceName> ParseXdsResourceName(
       absl::string_view name, const XdsResourceType* type);
   static std::string ConstructFullXdsResourceName(
       absl::string_view authority, absl::string_view resource_type,
       const XdsResourceKey& key);
 
   XdsApi::ClusterLoadReportMap BuildLoadReportSnapshotLocked(
-      bool send_all_clusters, const std::set<std::string>& clusters)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+      const XdsBootstrap::XdsServer& xds_server, bool send_all_clusters,
+      const std::set<std::string>& clusters) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   RefCountedPtr<ChannelState> GetOrCreateChannelStateLocked(
       const XdsBootstrap::XdsServer& server) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   std::unique_ptr<XdsBootstrap> bootstrap_;
   grpc_channel_args* args_;
-  const grpc_millis request_timeout_;
+  const Duration request_timeout_;
+  const bool xds_federation_enabled_;
   grpc_pollset_set* interested_parties_;
   OrphanablePtr<CertificateProviderStore> certificate_provider_store_;
   XdsApi api_;
@@ -305,11 +324,8 @@ class XdsClient : public DualRefCounted<XdsClient> {
   std::map<std::string /*authority*/, AuthorityState> authority_state_map_
       ABSL_GUARDED_BY(mu_);
 
-  // Load report data.
-  std::map<
-      std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
-      LoadReportState>
-      load_report_map_ ABSL_GUARDED_BY(mu_);
+  std::map<XdsBootstrap::XdsServer, LoadReportServer>
+      xds_load_report_server_map_ ABSL_GUARDED_BY(mu_);
 
   // Stores started watchers whose resource name was not parsed successfully,
   // waiting to be cancelled or reset in Orphan().

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

@@ -41,20 +41,20 @@ uint64_t GetAndResetCounter(std::atomic<uint64_t>* from) {
 // XdsClusterDropStats
 //
 
-XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
-                                         absl::string_view lrs_server_name,
-                                         absl::string_view cluster_name,
-                                         absl::string_view eds_service_name)
+XdsClusterDropStats::XdsClusterDropStats(
+    RefCountedPtr<XdsClient> xds_client,
+    const XdsBootstrap::XdsServer& lrs_server, absl::string_view cluster_name,
+    absl::string_view eds_service_name)
     : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
                      ? "XdsClusterDropStats"
                      : nullptr),
       xds_client_(std::move(xds_client)),
-      lrs_server_name_(lrs_server_name),
+      lrs_server_(lrs_server),
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO, "[xds_client %p] created drop stats %p for {%s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_name_).c_str(),
+            xds_client_.get(), this, lrs_server_.server_uri.c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str());
   }
@@ -64,11 +64,11 @@ XdsClusterDropStats::~XdsClusterDropStats() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] destroying drop stats %p for {%s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_name_).c_str(),
+            xds_client_.get(), this, lrs_server_.server_uri.c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str());
   }
-  xds_client_->RemoveClusterDropStats(lrs_server_name_, cluster_name_,
+  xds_client_->RemoveClusterDropStats(lrs_server_, cluster_name_,
                                       eds_service_name_, this);
   xds_client_.reset(DEBUG_LOCATION, "DropStats");
 }
@@ -95,21 +95,21 @@ void XdsClusterDropStats::AddCallDropped(const std::string& category) {
 //
 
 XdsClusterLocalityStats::XdsClusterLocalityStats(
-    RefCountedPtr<XdsClient> xds_client, absl::string_view lrs_server_name,
-    absl::string_view cluster_name, absl::string_view eds_service_name,
-    RefCountedPtr<XdsLocalityName> name)
+    RefCountedPtr<XdsClient> xds_client,
+    const XdsBootstrap::XdsServer& lrs_server, absl::string_view cluster_name,
+    absl::string_view eds_service_name, RefCountedPtr<XdsLocalityName> name)
     : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
                      ? "XdsClusterLocalityStats"
                      : nullptr),
       xds_client_(std::move(xds_client)),
-      lrs_server_name_(lrs_server_name),
+      lrs_server_(lrs_server),
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name),
       name_(std::move(name)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] created locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_name_).c_str(),
+            xds_client_.get(), this, lrs_server_.server_uri.c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str(),
             name_->AsHumanReadableString().c_str());
@@ -120,12 +120,12 @@ XdsClusterLocalityStats::~XdsClusterLocalityStats() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] destroying locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_name_).c_str(),
+            xds_client_.get(), this, lrs_server_.server_uri.c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str(),
             name_->AsHumanReadableString().c_str());
   }
-  xds_client_->RemoveClusterLocalityStats(lrs_server_name_, cluster_name_,
+  xds_client_->RemoveClusterLocalityStats(lrs_server_, cluster_name_,
                                           eds_service_name_, name_, this);
   xds_client_.reset(DEBUG_LOCATION, "LocalityStats");
 }

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

@@ -29,6 +29,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
+#include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -128,7 +129,7 @@ class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
   };
 
   XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
-                      absl::string_view lrs_server_name,
+                      const XdsBootstrap::XdsServer& lrs_server,
                       absl::string_view cluster_name,
                       absl::string_view eds_service_name);
   ~XdsClusterDropStats() override;
@@ -141,7 +142,7 @@ class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
 
  private:
   RefCountedPtr<XdsClient> xds_client_;
-  absl::string_view lrs_server_name_;
+  const XdsBootstrap::XdsServer& lrs_server_;
   absl::string_view cluster_name_;
   absl::string_view eds_service_name_;
   std::atomic<uint64_t> uncategorized_drops_{0};
@@ -202,7 +203,7 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
   };
 
   XdsClusterLocalityStats(RefCountedPtr<XdsClient> xds_client,
-                          absl::string_view lrs_server_name,
+                          const XdsBootstrap::XdsServer& lrs_server_,
                           absl::string_view cluster_name,
                           absl::string_view eds_service_name,
                           RefCountedPtr<XdsLocalityName> name);
@@ -216,7 +217,7 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
 
  private:
   RefCountedPtr<XdsClient> xds_client_;
-  absl::string_view lrs_server_name_;
+  const XdsBootstrap::XdsServer& lrs_server_;
   absl::string_view cluster_name_;
   absl::string_view eds_service_name_;
   RefCountedPtr<XdsLocalityName> name_;

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

@@ -70,9 +70,9 @@ std::string XdsClusterResource::ToString() const {
     contents.push_back(absl::StrFormat("common_tls_context=%s",
                                        common_tls_context.ToString()));
   }
-  if (lrs_load_reporting_server_name.has_value()) {
+  if (lrs_load_reporting_server.has_value()) {
     contents.push_back(absl::StrFormat("lrs_load_reporting_server_name=%s",
-                                       lrs_load_reporting_server_name.value()));
+                                       lrs_load_reporting_server->server_uri));
   }
   contents.push_back(absl::StrCat("lb_policy=", lb_policy));
   if (lb_policy == "RING_HASH") {
@@ -104,7 +104,7 @@ grpc_error_handle UpstreamTlsContextParse(
   auto* typed_config =
       envoy_config_core_v3_TransportSocket_typed_config(transport_socket);
   if (typed_config != nullptr) {
-    const upb_strview encoded_upstream_tls_context =
+    const upb_StringView encoded_upstream_tls_context =
         google_protobuf_Any_value(typed_config);
     auto* upstream_tls_context =
         envoy_extensions_transport_sockets_tls_v3_UpstreamTlsContext_parse(
@@ -235,12 +235,13 @@ grpc_error_handle CdsResourceParse(
     const envoy_config_core_v3_ConfigSource* eds_config =
         envoy_config_cluster_v3_Cluster_EdsClusterConfig_eds_config(
             eds_cluster_config);
-    if (!envoy_config_core_v3_ConfigSource_has_ads(eds_config)) {
-      errors.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("EDS ConfigSource is not ADS."));
+    if (!envoy_config_core_v3_ConfigSource_has_ads(eds_config) &&
+        !envoy_config_core_v3_ConfigSource_has_self(eds_config)) {
+      errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "EDS ConfigSource is not ADS or SELF."));
     }
     // Record EDS service_name (if any).
-    upb_strview service_name =
+    upb_StringView service_name =
         envoy_config_cluster_v3_Cluster_EdsClusterConfig_service_name(
             eds_cluster_config);
     if (service_name.size != 0) {
@@ -262,7 +263,7 @@ grpc_error_handle CdsResourceParse(
       const envoy_config_cluster_v3_Cluster_CustomClusterType*
           custom_cluster_type =
               envoy_config_cluster_v3_Cluster_cluster_type(cluster);
-      upb_strview type_name =
+      upb_StringView type_name =
           envoy_config_cluster_v3_Cluster_CustomClusterType_name(
               custom_cluster_type);
       if (UpbStringToAbsl(type_name) != "envoy.clusters.aggregate") {
@@ -274,23 +275,24 @@ grpc_error_handle CdsResourceParse(
         const google_protobuf_Any* typed_config =
             envoy_config_cluster_v3_Cluster_CustomClusterType_typed_config(
                 custom_cluster_type);
-        const upb_strview aggregate_cluster_config_upb_strview =
+        const upb_StringView aggregate_cluster_config_upb_stringview =
             google_protobuf_Any_value(typed_config);
         const envoy_extensions_clusters_aggregate_v3_ClusterConfig*
             aggregate_cluster_config =
                 envoy_extensions_clusters_aggregate_v3_ClusterConfig_parse(
-                    aggregate_cluster_config_upb_strview.data,
-                    aggregate_cluster_config_upb_strview.size, context.arena);
+                    aggregate_cluster_config_upb_stringview.data,
+                    aggregate_cluster_config_upb_stringview.size,
+                    context.arena);
         if (aggregate_cluster_config == nullptr) {
           errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "Can't parse aggregate cluster."));
         } else {
           size_t size;
-          const upb_strview* clusters =
+          const upb_StringView* clusters =
               envoy_extensions_clusters_aggregate_v3_ClusterConfig_clusters(
                   aggregate_cluster_config, &size);
           for (size_t i = 0; i < size; ++i) {
-            const upb_strview cluster = clusters[i];
+            const upb_StringView cluster = clusters[i];
             cds_update->prioritized_cluster_names.emplace_back(
                 UpbStringToStdString(cluster));
           }
@@ -368,7 +370,7 @@ grpc_error_handle CdsResourceParse(
       errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           ": LRS ConfigSource is not self."));
     }
-    cds_update->lrs_load_reporting_server_name.emplace("");
+    cds_update->lrs_load_reporting_server.emplace(context.server);
   }
   // The Cluster resource encodes the circuit breaking parameters in a list of
   // Thresholds messages, where each message specifies the parameters for a
@@ -403,10 +405,10 @@ void MaybeLogCluster(const XdsEncodingContext& context,
                      const envoy_config_cluster_v3_Cluster* cluster) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-    const upb_msgdef* msg_type =
+    const upb_MessageDef* msg_type =
         envoy_config_cluster_v3_Cluster_getmsgdef(context.symtab);
     char buf[10240];
-    upb_text_encode(cluster, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(cluster, msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] Cluster: %s", context.client, buf);
   }
 }

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

@@ -52,9 +52,7 @@ struct XdsClusterResource {
 
   // The LRS server to use for load reporting.
   // If not set, load reporting will be disabled.
-  // If set to the empty string, will use the same server we obtained the CDS
-  // data from.
-  absl::optional<std::string> lrs_load_reporting_server_name;
+  absl::optional<XdsBootstrap::XdsServer> lrs_load_reporting_server;
 
   // The LB policy to use (e.g., "ROUND_ROBIN" or "RING_HASH").
   std::string lb_policy;
@@ -71,8 +69,7 @@ struct XdsClusterResource {
            dns_hostname == other.dns_hostname &&
            prioritized_cluster_names == other.prioritized_cluster_names &&
            common_tls_context == other.common_tls_context &&
-           lrs_load_reporting_server_name ==
-               other.lrs_load_reporting_server_name &&
+           lrs_load_reporting_server == other.lrs_load_reporting_server &&
            lb_policy == other.lb_policy &&
            min_ring_size == other.min_ring_size &&
            max_ring_size == other.max_ring_size &&
@@ -98,7 +95,7 @@ class XdsClusterResourceType
 
   bool AllResourcesRequiredInSotW() const override { return true; }
 
-  void InitUpbSymtab(upb_symtab* symtab) const override {
+  void InitUpbSymtab(upb_DefPool* symtab) const override {
     envoy_config_cluster_v3_Cluster_getmsgdef(symtab);
     envoy_extensions_clusters_aggregate_v3_ClusterConfig_getmsgdef(symtab);
     envoy_extensions_transport_sockets_tls_v3_UpstreamTlsContext_getmsgdef(

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

@@ -0,0 +1,142 @@
+//
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
+
+#include "absl/strings/str_format.h"
+#include "envoy/extensions/filters/http/router/v3/router.upb.h"
+#include "envoy/extensions/filters/http/router/v3/router.upbdefs.h"
+#include "google/protobuf/duration.upb.h"
+#include "upb/json_encode.h"
+
+#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
+#include "src/core/ext/xds/upb_utils.h"
+#include "src/proto/grpc/lookup/v1/rls_config.upb.h"
+#include "src/proto/grpc/lookup/v1/rls_config.upbdefs.h"
+
+namespace grpc_core {
+
+const char* kXdsRouteLookupClusterSpecifierPluginConfigName =
+    "grpc.lookup.v1.RouteLookupClusterSpecifier";
+
+void XdsRouteLookupClusterSpecifierPlugin::PopulateSymtab(
+    upb_DefPool* symtab) const {
+  grpc_lookup_v1_RouteLookupConfig_getmsgdef(symtab);
+}
+
+absl::StatusOr<std::string>
+XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
+    upb_StringView serialized_plugin_config, upb_Arena* arena,
+    upb_DefPool* symtab) const {
+  const auto* specifier = grpc_lookup_v1_RouteLookupClusterSpecifier_parse(
+      serialized_plugin_config.data, serialized_plugin_config.size, arena);
+  if (specifier == nullptr) {
+    return absl::InvalidArgumentError("Could not parse plugin config");
+  }
+  const auto* plugin_config =
+      grpc_lookup_v1_RouteLookupClusterSpecifier_route_lookup_config(specifier);
+  if (plugin_config == nullptr) {
+    return absl::InvalidArgumentError(
+        "Could not get route lookup config from route lookup cluster "
+        "specifier");
+  }
+  upb::Status status;
+  const upb_MessageDef* msg_type =
+      grpc_lookup_v1_RouteLookupConfig_getmsgdef(symtab);
+  size_t json_size = upb_JsonEncode(plugin_config, msg_type, symtab, 0, nullptr,
+                                    0, status.ptr());
+  if (json_size == static_cast<size_t>(-1)) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("failed to dump proto to JSON: ",
+                     upb_Status_ErrorMessage(status.ptr())));
+  }
+  void* buf = upb_Arena_Malloc(arena, json_size + 1);
+  upb_JsonEncode(plugin_config, msg_type, symtab, 0,
+                 reinterpret_cast<char*>(buf), json_size + 1, status.ptr());
+  Json::Object rls_policy;
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  rls_policy["routeLookupConfig"] =
+      Json::Parse(reinterpret_cast<char*>(buf), &error);
+  GPR_ASSERT(error == GRPC_ERROR_NONE);
+  Json::Object cds_policy;
+  cds_policy["cds_experimental"] = Json::Object();
+  Json::Array child_policy;
+  child_policy.emplace_back(std::move(cds_policy));
+  rls_policy["childPolicy"] = std::move(child_policy);
+  rls_policy["childPolicyConfigTargetFieldName"] = "cluster";
+  Json::Object policy;
+  policy["rls_experimental"] = std::move(rls_policy);
+  Json::Array policies;
+  policies.emplace_back(std::move(policy));
+  Json lb_policy_config(std::move(policies));
+  grpc_error_handle parse_error = GRPC_ERROR_NONE;
+  // TODO(roth): If/when we ever add a second plugin, refactor this code
+  // somehow such that we automatically validate the resulting config against
+  // the gRPC LB policy registry instead of requiring each plugin to do that
+  // itself.
+  LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(lb_policy_config,
+                                                        &parse_error);
+  if (parse_error != GRPC_ERROR_NONE) {
+    absl::Status status = absl::InvalidArgumentError(absl::StrCat(
+        kXdsRouteLookupClusterSpecifierPluginConfigName,
+        " ClusterSpecifierPlugin returned invalid LB policy config: ",
+        grpc_error_std_string(parse_error)));
+    GRPC_ERROR_UNREF(parse_error);
+    return status;
+  }
+  return lb_policy_config.Dump();
+}
+
+namespace {
+
+using PluginRegistryMap =
+    std::map<absl::string_view, std::unique_ptr<XdsClusterSpecifierPluginImpl>>;
+
+PluginRegistryMap* g_plugin_registry = nullptr;
+
+}  // namespace
+
+const XdsClusterSpecifierPluginImpl*
+XdsClusterSpecifierPluginRegistry::GetPluginForType(
+    absl::string_view config_proto_type_name) {
+  auto it = g_plugin_registry->find(config_proto_type_name);
+  if (it == g_plugin_registry->end()) return nullptr;
+  return it->second.get();
+}
+
+void XdsClusterSpecifierPluginRegistry::PopulateSymtab(upb_DefPool* symtab) {
+  for (const auto& p : *g_plugin_registry) {
+    p.second->PopulateSymtab(symtab);
+  }
+}
+
+void XdsClusterSpecifierPluginRegistry::RegisterPlugin(
+    std::unique_ptr<XdsClusterSpecifierPluginImpl> plugin,
+    absl::string_view config_proto_type_name) {
+  (*g_plugin_registry)[config_proto_type_name] = std::move(plugin);
+}
+
+void XdsClusterSpecifierPluginRegistry::Init() {
+  g_plugin_registry = new PluginRegistryMap;
+  RegisterPlugin(absl::make_unique<XdsRouteLookupClusterSpecifierPlugin>(),
+                 kXdsRouteLookupClusterSpecifierPluginConfigName);
+}
+
+void XdsClusterSpecifierPluginRegistry::Shutdown() { delete g_plugin_registry; }
+
+}  // namespace grpc_core

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

@@ -0,0 +1,79 @@
+//
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_EXT_XDS_XDS_CLUSTER_SPECIFIER_PLUGIN_H
+#define GRPC_CORE_EXT_XDS_XDS_CLUSTER_SPECIFIER_PLUGIN_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+#include <set>
+#include <string>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "google/protobuf/any.upb.h"
+#include "upb/def.h"
+
+#include <grpc/grpc.h>
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/json/json.h"
+
+namespace grpc_core {
+
+class XdsClusterSpecifierPluginImpl {
+ public:
+  virtual ~XdsClusterSpecifierPluginImpl() = default;
+
+  // Loads the proto message into the upb symtab.
+  virtual void PopulateSymtab(upb_DefPool* symtab) const = 0;
+
+  // Returns the LB policy config in JSON form.
+  virtual absl::StatusOr<std::string> GenerateLoadBalancingPolicyConfig(
+      upb_StringView serialized_plugin_config, upb_Arena* arena,
+      upb_DefPool* symtab) const = 0;
+};
+
+class XdsRouteLookupClusterSpecifierPlugin
+    : public XdsClusterSpecifierPluginImpl {
+  void PopulateSymtab(upb_DefPool* symtab) const override;
+
+  absl::StatusOr<std::string> GenerateLoadBalancingPolicyConfig(
+      upb_StringView serialized_plugin_config, upb_Arena* arena,
+      upb_DefPool* symtab) const override;
+};
+
+class XdsClusterSpecifierPluginRegistry {
+ public:
+  static void RegisterPlugin(
+      std::unique_ptr<XdsClusterSpecifierPluginImpl> plugin,
+      absl::string_view config_proto_type_name);
+
+  static void PopulateSymtab(upb_DefPool* symtab);
+
+  static const XdsClusterSpecifierPluginImpl* GetPluginForType(
+      absl::string_view config_proto_type_name);
+
+  // Global init and shutdown.
+  static void Init();
+  static void Shutdown();
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_CLUSTER_SPECIFIER_PLUGIN_H

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

@@ -365,23 +365,23 @@ grpc_error_handle CommonTlsContext::Parse(
                                        &errors);
 }
 
-grpc_error_handle ExtractHttpFilterTypeName(const XdsEncodingContext& context,
-                                            const google_protobuf_Any* any,
-                                            absl::string_view* filter_type) {
-  *filter_type = UpbStringToAbsl(google_protobuf_Any_type_url(any));
-  if (*filter_type == "type.googleapis.com/xds.type.v3.TypedStruct" ||
-      *filter_type == "type.googleapis.com/udpa.type.v1.TypedStruct") {
-    upb_strview any_value = google_protobuf_Any_value(any);
+grpc_error_handle ExtractExtensionTypeName(const XdsEncodingContext& context,
+                                           const google_protobuf_Any* any,
+                                           absl::string_view* extension_type) {
+  *extension_type = UpbStringToAbsl(google_protobuf_Any_type_url(any));
+  if (*extension_type == "type.googleapis.com/xds.type.v3.TypedStruct" ||
+      *extension_type == "type.googleapis.com/udpa.type.v1.TypedStruct") {
+    upb_StringView any_value = google_protobuf_Any_value(any);
     const auto* typed_struct = xds_type_v3_TypedStruct_parse(
         any_value.data, any_value.size, context.arena);
     if (typed_struct == nullptr) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "could not parse TypedStruct from filter config");
+          "could not parse TypedStruct from extension");
     }
-    *filter_type =
+    *extension_type =
         UpbStringToAbsl(xds_type_v3_TypedStruct_type_url(typed_struct));
   }
-  *filter_type = absl::StripPrefix(*filter_type, "type.googleapis.com/");
+  *extension_type = absl::StripPrefix(*extension_type, "type.googleapis.com/");
   return GRPC_ERROR_NONE;
 }