grpc 1.51.0 → 1.52.0.pre2

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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>
 

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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_CLIENT_STATS_H
 #define GRPC_CORE_EXT_XDS_XDS_CLIENT_STATS_H
@@ -239,4 +239,4 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_XDS_XDS_CLIENT_STATS_H */
+#endif  // GRPC_CORE_EXT_XDS_XDS_CLIENT_STATS_H

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

@@ -35,6 +35,7 @@
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/core/v3/config_source.upb.h"
+#include "envoy/config/core/v3/health_check.upb.h"
 #include "envoy/config/endpoint/v3/endpoint.upb.h"
 #include "envoy/config/endpoint/v3/endpoint_components.upb.h"
 #include "envoy/extensions/clusters/aggregate/v3/cluster.upb.h"
@@ -57,6 +58,7 @@
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/validation_errors.h"
@@ -74,41 +76,61 @@ bool XdsCustomLbPolicyEnabled() {
   return parse_succeeded && parsed_value;
 }
 
+// TODO(eostroukhov): Remove once this feature is no longer experimental.
+bool XdsHostOverrideEnabled() {
+  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_ENABLE_HOST_OVERRIDE");
+  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;
+}
+
 //
 // XdsClusterResource
 //
 
 std::string XdsClusterResource::ToString() const {
   std::vector<std::string> contents;
-  switch (cluster_type) {
-    case EDS:
-      contents.push_back("cluster_type=EDS");
-      if (!eds_service_name.empty()) {
-        contents.push_back(absl::StrCat("eds_service_name=", eds_service_name));
-      }
-      break;
-    case LOGICAL_DNS:
-      contents.push_back("cluster_type=LOGICAL_DNS");
-      contents.push_back(absl::StrCat("dns_hostname=", dns_hostname));
-      break;
-    case AGGREGATE:
-      contents.push_back("cluster_type=AGGREGATE");
-      contents.push_back(
-          absl::StrCat("prioritized_cluster_names=[",
-                       absl::StrJoin(prioritized_cluster_names, ", "), "]"));
+  Match(
+      type,
+      [&](const Eds& eds) {
+        contents.push_back("type=EDS");
+        if (!eds.eds_service_name.empty()) {
+          contents.push_back(
+              absl::StrCat("eds_service_name=", eds.eds_service_name));
+        }
+      },
+      [&](const LogicalDns& logical_dns) {
+        contents.push_back("type=LOGICAL_DNS");
+        contents.push_back(absl::StrCat("dns_hostname=", logical_dns.hostname));
+      },
+      [&](const Aggregate& aggregate) {
+        contents.push_back("type=AGGREGATE");
+        contents.push_back(absl::StrCat(
+            "prioritized_cluster_names=[",
+            absl::StrJoin(aggregate.prioritized_cluster_names, ", "), "]"));
+      });
+  contents.push_back(
+      absl::StrCat("lb_policy_config=", Json{lb_policy_config}.Dump()));
+  if (lrs_load_reporting_server.has_value()) {
+    contents.push_back(absl::StrCat("lrs_load_reporting_server_name=",
+                                    lrs_load_reporting_server->server_uri()));
   }
   if (!common_tls_context.Empty()) {
     contents.push_back(
         absl::StrCat("common_tls_context=", common_tls_context.ToString()));
   }
-  if (lrs_load_reporting_server.has_value()) {
-    contents.push_back(absl::StrCat("lrs_load_reporting_server_name=",
-                                    lrs_load_reporting_server->server_uri()));
-  }
-  contents.push_back(
-      absl::StrCat("lb_policy_config=", Json{lb_policy_config}.Dump()));
   contents.push_back(
       absl::StrCat("max_concurrent_requests=", max_concurrent_requests));
+  if (!host_override_statuses.empty()) {
+    std::vector<const char*> statuses;
+    statuses.reserve(host_override_statuses.size());
+    for (const auto& status : host_override_statuses) {
+      statuses.push_back(status.ToString());
+    }
+    contents.push_back(absl::StrCat("override_host_statuses={",
+                                    absl::StrJoin(statuses, ", "), "}"));
+  }
   return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
 }
 
@@ -163,8 +185,9 @@ CommonTlsContext UpstreamTlsContextParse(
   return common_tls_context;
 }
 
-void EdsConfigParse(const envoy_config_cluster_v3_Cluster* cluster,
-                    XdsClusterResource* cds_update, ValidationErrors* errors) {
+XdsClusterResource::Eds EdsConfigParse(
+    const envoy_config_cluster_v3_Cluster* cluster, ValidationErrors* errors) {
+  XdsClusterResource::Eds eds;
   ValidationErrors::ScopedField field(errors, ".eds_cluster_config");
   const envoy_config_cluster_v3_Cluster_EdsClusterConfig* eds_cluster_config =
       envoy_config_cluster_v3_Cluster_eds_cluster_config(cluster);
@@ -187,20 +210,22 @@ void EdsConfigParse(const envoy_config_cluster_v3_Cluster* cluster,
           envoy_config_cluster_v3_Cluster_EdsClusterConfig_service_name(
               eds_cluster_config);
       if (service_name.size != 0) {
-        cds_update->eds_service_name = UpbStringToStdString(service_name);
+        eds.eds_service_name = UpbStringToStdString(service_name);
       }
     }
   }
+  return eds;
 }
 
-void LogicalDnsParse(const envoy_config_cluster_v3_Cluster* cluster,
-                     XdsClusterResource* cds_update, ValidationErrors* errors) {
+XdsClusterResource::LogicalDns LogicalDnsParse(
+    const envoy_config_cluster_v3_Cluster* cluster, ValidationErrors* errors) {
+  XdsClusterResource::LogicalDns logical_dns;
   ValidationErrors::ScopedField field(errors, ".load_assignment");
   const auto* load_assignment =
       envoy_config_cluster_v3_Cluster_load_assignment(cluster);
   if (load_assignment == nullptr) {
     errors->AddError("field not present for LOGICAL_DNS cluster");
-    return;
+    return logical_dns;
   }
   ValidationErrors::ScopedField field2(errors, ".endpoints");
   size_t num_localities;
@@ -211,7 +236,7 @@ void LogicalDnsParse(const envoy_config_cluster_v3_Cluster* cluster,
     errors->AddError(absl::StrCat(
         "must contain exactly one locality for LOGICAL_DNS cluster, found ",
         num_localities));
-    return;
+    return logical_dns;
   }
   ValidationErrors::ScopedField field3(errors, "[0].lb_endpoints");
   size_t num_endpoints;
@@ -222,27 +247,27 @@ void LogicalDnsParse(const envoy_config_cluster_v3_Cluster* cluster,
     errors->AddError(absl::StrCat(
         "must contain exactly one endpoint for LOGICAL_DNS cluster, found ",
         num_endpoints));
-    return;
+    return logical_dns;
   }
   ValidationErrors::ScopedField field4(errors, "[0].endpoint");
   const auto* endpoint =
       envoy_config_endpoint_v3_LbEndpoint_endpoint(endpoints[0]);
   if (endpoint == nullptr) {
     errors->AddError("field not present");
-    return;
+    return logical_dns;
   }
   ValidationErrors::ScopedField field5(errors, ".address");
   const auto* address = envoy_config_endpoint_v3_Endpoint_address(endpoint);
   if (address == nullptr) {
     errors->AddError("field not present");
-    return;
+    return logical_dns;
   }
   ValidationErrors::ScopedField field6(errors, ".socket_address");
   const auto* socket_address =
       envoy_config_core_v3_Address_socket_address(address);
   if (socket_address == nullptr) {
     errors->AddError("field not present");
-    return;
+    return logical_dns;
   }
   if (envoy_config_core_v3_SocketAddress_resolver_name(socket_address).size !=
       0) {
@@ -260,30 +285,32 @@ void LogicalDnsParse(const envoy_config_cluster_v3_Cluster* cluster,
     ValidationErrors::ScopedField field(errors, ".port_value");
     errors->AddError("field not present");
   }
-  cds_update->dns_hostname = JoinHostPort(
+  logical_dns.hostname = JoinHostPort(
       address_str,
       envoy_config_core_v3_SocketAddress_port_value(socket_address));
+  return logical_dns;
 }
 
-void AggregateClusterParse(const XdsResourceType::DecodeContext& context,
-                           absl::string_view serialized_config,
-                           XdsClusterResource* cds_update,
-                           ValidationErrors* errors) {
+XdsClusterResource::Aggregate AggregateClusterParse(
+    const XdsResourceType::DecodeContext& context,
+    absl::string_view serialized_config, ValidationErrors* errors) {
+  XdsClusterResource::Aggregate aggregate;
   const auto* aggregate_cluster_config =
       envoy_extensions_clusters_aggregate_v3_ClusterConfig_parse(
           serialized_config.data(), serialized_config.size(), context.arena);
   if (aggregate_cluster_config == nullptr) {
     errors->AddError("can't parse aggregate cluster config");
-    return;
+    return aggregate;
   }
   size_t size;
   const upb_StringView* clusters =
       envoy_extensions_clusters_aggregate_v3_ClusterConfig_clusters(
           aggregate_cluster_config, &size);
   for (size_t i = 0; i < size; ++i) {
-    cds_update->prioritized_cluster_names.emplace_back(
+    aggregate.prioritized_cluster_names.emplace_back(
         UpbStringToStdString(clusters[i]));
   }
+  return aggregate;
 }
 
 void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
@@ -393,12 +420,10 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
   // Check the cluster discovery type.
   if (envoy_config_cluster_v3_Cluster_type(cluster) ==
       envoy_config_cluster_v3_Cluster_EDS) {
-    cds_update.cluster_type = XdsClusterResource::ClusterType::EDS;
-    EdsConfigParse(cluster, &cds_update, &errors);
+    cds_update.type = EdsConfigParse(cluster, &errors);
   } else if (envoy_config_cluster_v3_Cluster_type(cluster) ==
              envoy_config_cluster_v3_Cluster_LOGICAL_DNS) {
-    cds_update.cluster_type = XdsClusterResource::ClusterType::LOGICAL_DNS;
-    LogicalDnsParse(cluster, &cds_update, &errors);
+    cds_update.type = LogicalDnsParse(cluster, &errors);
   } else if (envoy_config_cluster_v3_Cluster_has_cluster_type(cluster)) {
     ValidationErrors::ScopedField field(&errors, ".cluster_type");
     const auto* custom_cluster_type =
@@ -419,14 +444,14 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
         errors.AddError(
             absl::StrCat("unknown cluster_type extension: ", type_url));
       } else {
-        cds_update.cluster_type = XdsClusterResource::ClusterType::AGGREGATE;
         // Retrieve aggregate clusters.
         ValidationErrors::ScopedField field(
             &errors,
             ".value[envoy.extensions.clusters.aggregate.v3.ClusterConfig]");
         absl::string_view serialized_config =
             UpbStringToAbsl(google_protobuf_Any_value(typed_config));
-        AggregateClusterParse(context, serialized_config, &cds_update, &errors);
+        cds_update.type =
+            AggregateClusterParse(context, serialized_config, &errors);
       }
     }
   } else {
@@ -602,6 +627,29 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
     }
     cds_update.outlier_detection = outlier_detection_update;
   }
+  // Validate override host status.
+  if (XdsHostOverrideEnabled()) {
+    const auto* common_lb_config =
+        envoy_config_cluster_v3_Cluster_common_lb_config(cluster);
+    if (common_lb_config != nullptr) {
+      ValidationErrors::ScopedField field(&errors, ".common_lb_config");
+      const auto* override_host_status =
+          envoy_config_cluster_v3_Cluster_CommonLbConfig_override_host_status(
+              common_lb_config);
+      if (override_host_status != nullptr) {
+        ValidationErrors::ScopedField field(&errors, ".override_host_status");
+        size_t size;
+        const int32_t* statuses = envoy_config_core_v3_HealthStatusSet_statuses(
+            override_host_status, &size);
+        for (size_t i = 0; i < size; ++i) {
+          auto status = XdsHealthStatus::FromUpb(statuses[i]);
+          if (status.has_value()) {
+            cds_update.host_override_statuses.insert(*status);
+          }
+        }
+      }
+    }
+  }
   // Return result.
   if (!errors.ok()) return errors.status("errors validating Cluster resource");
   return cds_update;

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

@@ -23,11 +23,13 @@
 
 #include <algorithm>
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "absl/types/variant.h"
 #include "envoy/config/cluster/v3/cluster.upbdefs.h"
 #include "envoy/extensions/clusters/aggregate/v3/cluster.upbdefs.h"
 #include "envoy/extensions/transport_sockets/tls/v3/tls.upbdefs.h"
@@ -38,6 +40,7 @@
 #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_health_status.h"
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/lib/json/json.h"
@@ -45,30 +48,49 @@
 namespace grpc_core {
 
 bool XdsCustomLbPolicyEnabled();
+bool XdsHostOverrideEnabled();
 
 struct XdsClusterResource : public XdsResourceType::ResourceData {
-  enum ClusterType { EDS, LOGICAL_DNS, AGGREGATE };
-  ClusterType cluster_type;
-  // For cluster type EDS.
-  // The name to use in the EDS request.
-  // If empty, the cluster name will be used.
-  std::string eds_service_name;
-  // For cluster type LOGICAL_DNS.
-  // The hostname to lookup in DNS.
-  std::string dns_hostname;
-  // For cluster type AGGREGATE.
-  // The prioritized list of cluster names.
-  std::vector<std::string> prioritized_cluster_names;
+  struct Eds {
+    // If empty, defaults to the cluster name.
+    std::string eds_service_name;
 
-  // Tls Context used by clients
-  CommonTlsContext common_tls_context;
+    bool operator==(const Eds& other) const {
+      return eds_service_name == other.eds_service_name;
+    }
+  };
+
+  struct LogicalDns {
+    // The hostname to lookup in DNS.
+    std::string hostname;
+
+    bool operator==(const LogicalDns& other) const {
+      return hostname == other.hostname;
+    }
+  };
+
+  struct Aggregate {
+    // Prioritized list of cluster names.
+    std::vector<std::string> prioritized_cluster_names;
+
+    bool operator==(const Aggregate& other) const {
+      return prioritized_cluster_names == other.prioritized_cluster_names;
+    }
+  };
+
+  absl::variant<Eds, LogicalDns, Aggregate> type;
+
+  // The LB policy to use for locality and endpoint picking.
+  Json::Array lb_policy_config;
+
+  // Note: Remaining fields are not used for aggregate clusters.
 
   // The LRS server to use for load reporting.
   // If not set, load reporting will be disabled.
   absl::optional<GrpcXdsBootstrap::GrpcXdsServer> lrs_load_reporting_server;
 
-  // The LB policy to use for locality and endpoint picking.
-  Json::Array lb_policy_config;
+  // Tls Context used by clients
+  CommonTlsContext common_tls_context;
 
   // Maximum number of outstanding requests can be made to the upstream
   // cluster.
@@ -76,16 +98,15 @@ struct XdsClusterResource : public XdsResourceType::ResourceData {
 
   absl::optional<OutlierDetectionConfig> outlier_detection;
 
+  std::set<XdsHealthStatus> host_override_statuses;
+
   bool operator==(const XdsClusterResource& other) const {
-    return cluster_type == other.cluster_type &&
-           eds_service_name == other.eds_service_name &&
-           dns_hostname == other.dns_hostname &&
-           prioritized_cluster_names == other.prioritized_cluster_names &&
-           common_tls_context == other.common_tls_context &&
+    return type == other.type && lb_policy_config == other.lb_policy_config &&
            lrs_load_reporting_server == other.lrs_load_reporting_server &&
-           lb_policy_config == other.lb_policy_config &&
+           common_tls_context == other.common_tls_context &&
            max_concurrent_requests == other.max_concurrent_requests &&
-           outlier_detection == other.outlier_detection;
+           outlier_detection == other.outlier_detection &&
+           host_override_statuses == other.host_override_statuses;
   }
 
   std::string ToString() const;

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

@@ -20,11 +20,10 @@
 
 #include <stddef.h>
 
-#include <algorithm>
 #include <map>
 #include <utility>
 
-#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/variant.h"
 #include "upb/json_encode.h"
@@ -33,10 +32,7 @@
 
 #include <grpc/support/log.h>
 
-#include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/proto/grpc/lookup/v1/rls_config.upb.h"
 #include "src/proto/grpc/lookup/v1/rls_config.upbdefs.h"
 
@@ -46,34 +42,38 @@ namespace grpc_core {
 // XdsRouteLookupClusterSpecifierPlugin
 //
 
-const char* kXdsRouteLookupClusterSpecifierPluginConfigName =
-    "grpc.lookup.v1.RouteLookupClusterSpecifier";
+absl::string_view XdsRouteLookupClusterSpecifierPlugin::ConfigProtoName()
+    const {
+  return "grpc.lookup.v1.RouteLookupClusterSpecifier";
+}
 
 void XdsRouteLookupClusterSpecifierPlugin::PopulateSymtab(
     upb_DefPool* symtab) const {
   grpc_lookup_v1_RouteLookupConfig_getmsgdef(symtab);
 }
 
-absl::StatusOr<std::string>
-XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
-    XdsExtension extension, upb_Arena* arena, upb_DefPool* symtab) const {
+Json XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
+    XdsExtension extension, upb_Arena* arena, upb_DefPool* symtab,
+    ValidationErrors* errors) const {
   absl::string_view* serialized_plugin_config =
       absl::get_if<absl::string_view>(&extension.value);
   if (serialized_plugin_config == nullptr) {
-    return absl::InvalidArgumentError("could not parse plugin config");
+    errors->AddError("could not parse plugin config");
+    return {};
   }
   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");
+    errors->AddError("could not parse plugin config");
+    return {};
   }
   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");
+    ValidationErrors::ScopedField field(errors, ".route_lookup_config");
+    errors->AddError("field not present");
+    return {};
   }
   upb::Status status;
   const upb_MessageDef* msg_type =
@@ -81,42 +81,23 @@ XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
   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())));
+    errors->AddError(absl::StrCat("failed to dump proto to JSON: ",
+                                  upb_Status_ErrorMessage(status.ptr())));
+    return {};
   }
   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;
   auto json = Json::Parse(reinterpret_cast<char*>(buf));
   GPR_ASSERT(json.ok());
-  rls_policy["routeLookupConfig"] = std::move(*json);
-  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));
-  // 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.
-  auto config =
-      CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
-          lb_policy_config);
-  if (!config.ok()) {
-    return absl::InvalidArgumentError(absl::StrCat(
-        kXdsRouteLookupClusterSpecifierPluginConfigName,
-        " ClusterSpecifierPlugin returned invalid LB policy config: ",
-        config.status().message()));
-  }
-  return lb_policy_config.Dump();
+  return Json::Array{Json::Object{
+      {"rls_experimental",
+       Json::Object{
+           {"routeLookupConfig", std::move(*json)},
+           {"childPolicy",
+            Json::Array{Json::Object{{"cds_experimental", Json::Object()}}}},
+           {"childPolicyConfigTargetFieldName", "cluster"},
+       }}}};
 }
 
 //
@@ -124,14 +105,13 @@ XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
 //
 
 XdsClusterSpecifierPluginRegistry::XdsClusterSpecifierPluginRegistry() {
-  RegisterPlugin(std::make_unique<XdsRouteLookupClusterSpecifierPlugin>(),
-                 kXdsRouteLookupClusterSpecifierPluginConfigName);
+  RegisterPlugin(std::make_unique<XdsRouteLookupClusterSpecifierPlugin>());
 }
 
 void XdsClusterSpecifierPluginRegistry::RegisterPlugin(
-    std::unique_ptr<XdsClusterSpecifierPluginImpl> plugin,
-    absl::string_view config_proto_type_name) {
-  registry_[config_proto_type_name] = std::move(plugin);
+    std::unique_ptr<XdsClusterSpecifierPluginImpl> plugin) {
+  absl::string_view name = plugin->ConfigProtoName();
+  registry_[name] = std::move(plugin);
 }
 
 const XdsClusterSpecifierPluginImpl*