grpc 1.25.0 → 1.26.0.pre1

data/src/core/ext/filters/client_channel/subchannel.h

@@ -43,8 +43,7 @@
 // For debugging refcounting.
 #ifndef NDEBUG
 #define GRPC_SUBCHANNEL_REF(p, r) (p)->Ref(__FILE__, __LINE__, (r))
-#define GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(p, r) \
-  (p)->RefFromWeakRef(__FILE__, __LINE__, (r))
+#define GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(p, r) (p)->RefFromWeakRef()
 #define GRPC_SUBCHANNEL_UNREF(p, r) (p)->Unref(__FILE__, __LINE__, (r))
 #define GRPC_SUBCHANNEL_WEAK_REF(p, r) (p)->WeakRef(__FILE__, __LINE__, (r))
 #define GRPC_SUBCHANNEL_WEAK_UNREF(p, r) (p)->WeakUnref(__FILE__, __LINE__, (r))
@@ -198,12 +197,12 @@ class Subchannel {
   };
 
   // The ctor and dtor are not intended to use directly.
-  Subchannel(SubchannelKey* key, grpc_connector* connector,
+  Subchannel(SubchannelKey* key, OrphanablePtr<SubchannelConnector> connector,
              const grpc_channel_args* args);
   ~Subchannel();
 
   // Creates a subchannel given \a connector and \a args.
-  static Subchannel* Create(grpc_connector* connector,
+  static Subchannel* Create(OrphanablePtr<SubchannelConnector> connector,
                             const grpc_channel_args* args);
 
   // Strong and weak refcounting.
@@ -214,7 +213,7 @@ class Subchannel {
   // Attempts to return a strong ref when only the weak refcount is guaranteed
   // non-zero. If the strong refcount is zero, does not alter the refcount and
   // returns null.
-  Subchannel* RefFromWeakRef(GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+  Subchannel* RefFromWeakRef();
 
   // Gets the string representing the subchannel address.
   // Caller doesn't take ownership.
@@ -243,7 +242,7 @@ class Subchannel {
   // destroyed or when CancelConnectivityStateWatch() is called.
   void WatchConnectivityState(
       grpc_connectivity_state initial_state,
-      UniquePtr<char> health_check_service_name,
+      grpc_core::UniquePtr<char> health_check_service_name,
       OrphanablePtr<ConnectivityStateWatcherInterface> watcher);
 
   // Cancels a connectivity state watch.
@@ -294,8 +293,8 @@ class Subchannel {
    private:
     // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
     // be a set instead of a map.
-    Map<ConnectivityStateWatcherInterface*,
-        OrphanablePtr<ConnectivityStateWatcherInterface>>
+    std::map<ConnectivityStateWatcherInterface*,
+             OrphanablePtr<ConnectivityStateWatcherInterface>>
         watchers_;
   };
 
@@ -312,7 +311,7 @@ class Subchannel {
    public:
     void AddWatcherLocked(
         Subchannel* subchannel, grpc_connectivity_state initial_state,
-        UniquePtr<char> health_check_service_name,
+        grpc_core::UniquePtr<char> health_check_service_name,
         OrphanablePtr<ConnectivityStateWatcherInterface> watcher);
     void RemoveWatcherLocked(const char* health_check_service_name,
                              ConnectivityStateWatcherInterface* watcher);
@@ -328,7 +327,7 @@ class Subchannel {
    private:
     class HealthWatcher;
 
-    Map<const char*, OrphanablePtr<HealthWatcher>, StringLess> map_;
+    std::map<const char*, OrphanablePtr<HealthWatcher>, StringLess> map_;
   };
 
   class ConnectedSubchannelStateWatcher;
@@ -366,9 +365,9 @@ class Subchannel {
   gpr_atm ref_pair_;
 
   // Connection states.
-  grpc_connector* connector_ = nullptr;
+  OrphanablePtr<SubchannelConnector> connector_;
   // Set during connection.
-  grpc_connect_out_args connecting_result_;
+  SubchannelConnector::Result connecting_result_;
   grpc_closure on_connecting_finished_;
   // Active connection, or null.
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_;

data/src/core/ext/filters/client_channel/subchannel_interface.h

@@ -66,7 +66,7 @@ class SubchannelInterface : public RefCounted<SubchannelInterface> {
   // the previous watcher using CancelConnectivityStateWatch().
   virtual void WatchConnectivityState(
       grpc_connectivity_state initial_state,
-      UniquePtr<ConnectivityStateWatcherInterface> watcher) = 0;
+      std::unique_ptr<ConnectivityStateWatcherInterface> watcher) = 0;
 
   // Cancels a connectivity state watch.
   // If the watcher has already been destroyed, this is a no-op.

data/src/core/ext/filters/client_channel/xds/xds_api.cc

@@ -30,6 +30,7 @@
 
 #include "envoy/api/v2/core/address.upb.h"
 #include "envoy/api/v2/core/base.upb.h"
+#include "envoy/api/v2/core/health_check.upb.h"
 #include "envoy/api/v2/discovery.upb.h"
 #include "envoy/api/v2/eds.upb.h"
 #include "envoy/api/v2/endpoint/endpoint.upb.h"
@@ -87,7 +88,8 @@ bool XdsPriorityListUpdate::Contains(
   return false;
 }
 
-bool XdsDropConfig::ShouldDrop(const UniquePtr<char>** category_name) const {
+bool XdsDropConfig::ShouldDrop(
+    const grpc_core::UniquePtr<char>** category_name) const {
   for (size_t i = 0; i < drop_category_list_.size(); ++i) {
     const auto& drop_category = drop_category_list_[i];
     // Generate a random number in [0, 1000000).
@@ -113,9 +115,9 @@ void PopulateListValue(upb_arena* arena, google_protobuf_ListValue* list_value,
   }
 }
 
-void PopulateMetadata(
-    upb_arena* arena, google_protobuf_Struct* metadata_pb,
-    const Map<const char*, XdsBootstrap::MetadataValue, StringLess>& metadata) {
+void PopulateMetadata(upb_arena* arena, google_protobuf_Struct* metadata_pb,
+                      const std::map<const char*, XdsBootstrap::MetadataValue,
+                                     StringLess>& metadata) {
   for (const auto& p : metadata) {
     google_protobuf_Struct_FieldsEntry* field =
         google_protobuf_Struct_add_fields(metadata_pb, arena);
@@ -223,6 +225,13 @@ namespace {
 grpc_error* ServerAddressParseAndAppend(
     const envoy_api_v2_endpoint_LbEndpoint* lb_endpoint,
     ServerAddressList* list) {
+  // If health_status is not HEALTHY or UNKNOWN, skip this endpoint.
+  const int32_t health_status =
+      envoy_api_v2_endpoint_LbEndpoint_health_status(lb_endpoint);
+  if (health_status != envoy_api_v2_core_UNKNOWN &&
+      health_status != envoy_api_v2_core_HEALTHY) {
+    return GRPC_ERROR_NONE;
+  }
   // Find the ip:port.
   const envoy_api_v2_endpoint_Endpoint* endpoint =
       envoy_api_v2_endpoint_LbEndpoint_endpoint(lb_endpoint);
@@ -250,11 +259,11 @@ grpc_error* ServerAddressParseAndAppend(
 
 namespace {
 
-UniquePtr<char> StringCopy(const upb_strview& strview) {
+grpc_core::UniquePtr<char> StringCopy(const upb_strview& strview) {
   char* str = static_cast<char*>(gpr_malloc(strview.size + 1));
   memcpy(str, strview.data, strview.size);
   str[strview.size] = '\0';
-  return UniquePtr<char>(str);
+  return grpc_core::UniquePtr<char>(str);
 }
 
 }  // namespace
@@ -533,9 +542,10 @@ grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
   return LrsRequestEncode(request, arena.ptr());
 }
 
-grpc_error* XdsLrsResponseDecodeAndParse(const grpc_slice& encoded_response,
-                                         UniquePtr<char>* cluster_name,
-                                         grpc_millis* load_reporting_interval) {
+grpc_error* XdsLrsResponseDecodeAndParse(
+    const grpc_slice& encoded_response,
+    grpc_core::UniquePtr<char>* cluster_name,
+    grpc_millis* load_reporting_interval) {
   upb::Arena arena;
   // Decode the response.
   const envoy_service_load_stats_v2_LoadStatsResponse* decoded_response =

data/src/core/ext/filters/client_channel/xds/xds_api.h

@@ -59,7 +59,7 @@ class XdsPriorityListUpdate {
 
     size_t size() const { return localities.size(); }
 
-    Map<RefCountedPtr<XdsLocalityName>, Locality, XdsLocalityName::Less>
+    std::map<RefCountedPtr<XdsLocalityName>, Locality, XdsLocalityName::Less>
         localities;
   };
 
@@ -101,19 +101,20 @@ class XdsDropConfig : public RefCounted<XdsDropConfig> {
              parts_per_million == other.parts_per_million;
     }
 
-    UniquePtr<char> name;
+    grpc_core::UniquePtr<char> name;
     const uint32_t parts_per_million;
   };
 
   using DropCategoryList = InlinedVector<DropCategory, 2>;
 
-  void AddCategory(UniquePtr<char> name, uint32_t parts_per_million) {
+  void AddCategory(grpc_core::UniquePtr<char> name,
+                   uint32_t parts_per_million) {
     drop_category_list_.emplace_back(
         DropCategory{std::move(name), parts_per_million});
   }
 
   // The only method invoked from the data plane combiner.
-  bool ShouldDrop(const UniquePtr<char>** category_name) const;
+  bool ShouldDrop(const grpc_core::UniquePtr<char>** category_name) const;
 
   const DropCategoryList& drop_category_list() const {
     return drop_category_list_;
@@ -136,8 +137,16 @@ struct EdsUpdate {
   bool drop_all = false;
 };
 
-// TODO(juanlishen): Add fields as part of implementing CDS support.
-struct CdsUpdate {};
+struct CdsUpdate {
+  // The name to use in the EDS request.
+  // If null, the cluster name will be used.
+  grpc_core::UniquePtr<char> eds_service_name;
+  // The LRS server to use for load reporting.
+  // If null, load reporting will be disabled.
+  // If set to the empty string, will use the same server we obtained
+  // the CDS data from.
+  grpc_core::UniquePtr<char> lrs_load_reporting_server_name;
+};
 
 // Creates an EDS request querying \a service_name.
 grpc_slice XdsEdsRequestCreateAndEncode(const char* server_name,
@@ -162,9 +171,10 @@ grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
 // Parses the LRS response and returns \a cluster_name and \a
 // load_reporting_interval for client-side load reporting. If there is any
 // error, the output config is invalid.
-grpc_error* XdsLrsResponseDecodeAndParse(const grpc_slice& encoded_response,
-                                         UniquePtr<char>* cluster_name,
-                                         grpc_millis* load_reporting_interval);
+grpc_error* XdsLrsResponseDecodeAndParse(
+    const grpc_slice& encoded_response,
+    grpc_core::UniquePtr<char>* cluster_name,
+    grpc_millis* load_reporting_interval);
 
 }  // namespace grpc_core
 

data/src/core/ext/filters/client_channel/xds/xds_bootstrap.cc

@@ -29,8 +29,8 @@
 
 namespace grpc_core {
 
-UniquePtr<XdsBootstrap> XdsBootstrap::ReadFromFile(grpc_error** error) {
-  UniquePtr<char> path(gpr_getenv("GRPC_XDS_BOOTSTRAP"));
+std::unique_ptr<XdsBootstrap> XdsBootstrap::ReadFromFile(grpc_error** error) {
+  grpc_core::UniquePtr<char> path(gpr_getenv("GRPC_XDS_BOOTSTRAP"));
   if (path == nullptr) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "GRPC_XDS_BOOTSTRAP env var not set");
@@ -320,7 +320,7 @@ grpc_error* XdsBootstrap::ParseLocality(grpc_json* json) {
 
 InlinedVector<grpc_error*, 1> XdsBootstrap::ParseMetadataStruct(
     grpc_json* json,
-    Map<const char*, XdsBootstrap::MetadataValue, StringLess>* result) {
+    std::map<const char*, XdsBootstrap::MetadataValue, StringLess>* result) {
   InlinedVector<grpc_error*, 1> error_list;
   for (grpc_json* child = json->child; child != nullptr; child = child->next) {
     if (child->key == nullptr) {

data/src/core/ext/filters/client_channel/xds/xds_bootstrap.h

@@ -40,7 +40,7 @@ class XdsBootstrap {
     double double_value;
     const char* string_value;
     bool bool_value;
-    Map<const char*, MetadataValue, StringLess> struct_value;
+    std::map<const char*, MetadataValue, StringLess> struct_value;
     std::vector<MetadataValue> list_value;
   };
 
@@ -50,7 +50,7 @@ class XdsBootstrap {
     const char* locality_region = nullptr;
     const char* locality_zone = nullptr;
     const char* locality_subzone = nullptr;
-    Map<const char*, MetadataValue, StringLess> metadata;
+    std::map<const char*, MetadataValue, StringLess> metadata;
   };
 
   struct ChannelCreds {
@@ -60,7 +60,7 @@ class XdsBootstrap {
 
   // If *error is not GRPC_ERROR_NONE after returning, then there was an
   // error reading the file.
-  static UniquePtr<XdsBootstrap> ReadFromFile(grpc_error** error);
+  static std::unique_ptr<XdsBootstrap> ReadFromFile(grpc_error** error);
 
   // Do not instantiate directly -- use ReadFromFile() above instead.
   XdsBootstrap(grpc_slice contents, grpc_error** error);
@@ -80,7 +80,8 @@ class XdsBootstrap {
   grpc_error* ParseLocality(grpc_json* json);
 
   InlinedVector<grpc_error*, 1> ParseMetadataStruct(
-      grpc_json* json, Map<const char*, MetadataValue, StringLess>* result);
+      grpc_json* json,
+      std::map<const char*, MetadataValue, StringLess>* result);
   InlinedVector<grpc_error*, 1> ParseMetadataList(
       grpc_json* json, std::vector<MetadataValue>* result);
   grpc_error* ParseMetadataValue(grpc_json* json, size_t idx,
@@ -91,7 +92,7 @@ class XdsBootstrap {
 
   const char* server_uri_ = nullptr;
   InlinedVector<ChannelCreds, 1> channel_creds_;
-  UniquePtr<Node> node_;
+  std::unique_ptr<Node> node_;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/xds/xds_client.cc

@@ -244,7 +244,7 @@ class XdsClient::ChannelState::LrsCallState
   grpc_closure on_status_received_;
 
   // Load reporting state.
-  UniquePtr<char> cluster_name_;
+  grpc_core::UniquePtr<char> cluster_name_;
   grpc_millis load_reporting_interval_ = 0;
   OrphanablePtr<Reporter> reporter_;
 };
@@ -378,16 +378,16 @@ bool XdsClient::ChannelState::HasActiveAdsCall() const {
 
 void XdsClient::ChannelState::MaybeStartAdsCall() {
   if (ads_calld_ != nullptr) return;
-  ads_calld_.reset(New<RetryableCall<AdsCallState>>(
-      Ref(DEBUG_LOCATION, "ChannelState+ads")));
+  ads_calld_.reset(
+      new RetryableCall<AdsCallState>(Ref(DEBUG_LOCATION, "ChannelState+ads")));
 }
 
 void XdsClient::ChannelState::StopAdsCall() { ads_calld_.reset(); }
 
 void XdsClient::ChannelState::MaybeStartLrsCall() {
   if (lrs_calld_ != nullptr) return;
-  lrs_calld_.reset(New<RetryableCall<LrsCallState>>(
-      Ref(DEBUG_LOCATION, "ChannelState+lrs")));
+  lrs_calld_.reset(
+      new RetryableCall<LrsCallState>(Ref(DEBUG_LOCATION, "ChannelState+lrs")));
 }
 
 void XdsClient::ChannelState::StopLrsCall() { lrs_calld_.reset(); }
@@ -396,7 +396,7 @@ void XdsClient::ChannelState::StartConnectivityWatchLocked() {
   grpc_channel_element* client_channel_elem =
       grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel_));
   GPR_ASSERT(client_channel_elem->filter == &grpc_client_channel_filter);
-  watcher_ = New<StateWatcher>(Ref());
+  watcher_ = new StateWatcher(Ref());
   grpc_client_channel_start_connectivity_watch(
       client_channel_elem, GRPC_CHANNEL_IDLE,
       OrphanablePtr<AsyncConnectivityStateWatcherInterface>(watcher_));
@@ -639,7 +639,7 @@ void XdsClient::ChannelState::AdsCallState::OnResponseReceived(
 }
 
 void XdsClient::ChannelState::AdsCallState::OnResponseReceivedLocked(
-    void* arg, grpc_error* error) {
+    void* arg, grpc_error* /*error*/) {
   AdsCallState* ads_calld = static_cast<AdsCallState*>(arg);
   XdsClient* xds_client = ads_calld->xds_client();
   // Empty payload means the call was cancelled.
@@ -736,8 +736,11 @@ void XdsClient::ChannelState::AdsCallState::OnResponseReceivedLocked(
       }
     }
     // Start load reporting if needed.
-    LrsCallState* lrs_calld = ads_calld->chand()->lrs_calld_->calld();
-    if (lrs_calld != nullptr) lrs_calld->MaybeStartReportingLocked();
+    auto& lrs_call = ads_calld->chand()->lrs_calld_;
+    if (lrs_call != nullptr) {
+      LrsCallState* lrs_calld = lrs_call->calld();
+      if (lrs_calld != nullptr) lrs_calld->MaybeStartReportingLocked();
+    }
     // Ignore identical update.
     const EdsUpdate& prev_update = xds_client->cluster_state_.eds_update;
     const bool priority_list_changed =
@@ -1083,7 +1086,7 @@ void XdsClient::ChannelState::LrsCallState::OnInitialRequestSent(
 }
 
 void XdsClient::ChannelState::LrsCallState::OnInitialRequestSentLocked(
-    void* arg, grpc_error* error) {
+    void* arg, grpc_error* /*error*/) {
   LrsCallState* lrs_calld = static_cast<LrsCallState*>(arg);
   // Clear the send_message_payload_.
   grpc_byte_buffer_destroy(lrs_calld->send_message_payload_);
@@ -1102,7 +1105,7 @@ void XdsClient::ChannelState::LrsCallState::OnResponseReceived(
 }
 
 void XdsClient::ChannelState::LrsCallState::OnResponseReceivedLocked(
-    void* arg, grpc_error* error) {
+    void* arg, grpc_error* /*error*/) {
   LrsCallState* lrs_calld = static_cast<LrsCallState*>(arg);
   XdsClient* xds_client = lrs_calld->xds_client();
   // Empty payload means the call was cancelled.
@@ -1121,7 +1124,7 @@ void XdsClient::ChannelState::LrsCallState::OnResponseReceivedLocked(
   // This anonymous lambda is a hack to avoid the usage of goto.
   [&]() {
     // Parse the response.
-    UniquePtr<char> new_cluster_name;
+    grpc_core::UniquePtr<char> new_cluster_name;
     grpc_millis new_load_reporting_interval;
     grpc_error* parse_error = XdsLrsResponseDecodeAndParse(
         response_slice, &new_cluster_name, &new_load_reporting_interval);
@@ -1237,24 +1240,24 @@ bool XdsClient::ChannelState::LrsCallState::IsCurrentCallOnChannel() const {
 
 namespace {
 
-UniquePtr<char> GenerateBuildVersionString() {
+grpc_core::UniquePtr<char> GenerateBuildVersionString() {
   char* build_version_str;
   gpr_asprintf(&build_version_str, "gRPC C-core %s %s", grpc_version_string(),
                GPR_PLATFORM_STRING);
-  return UniquePtr<char>(build_version_str);
+  return grpc_core::UniquePtr<char>(build_version_str);
 }
 
 }  // namespace
 
 XdsClient::XdsClient(Combiner* combiner, grpc_pollset_set* interested_parties,
                      StringView server_name,
-                     UniquePtr<ServiceConfigWatcherInterface> watcher,
+                     std::unique_ptr<ServiceConfigWatcherInterface> watcher,
                      const grpc_channel_args& channel_args, grpc_error** error)
     : build_version_(GenerateBuildVersionString()),
       combiner_(GRPC_COMBINER_REF(combiner, "xds_client")),
       interested_parties_(interested_parties),
       bootstrap_(XdsBootstrap::ReadFromFile(error)),
-      server_name_(server_name.dup()),
+      server_name_(StringViewToCString(server_name)),
       service_config_watcher_(std::move(watcher)) {
   if (*error != GRPC_ERROR_NONE) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
@@ -1286,18 +1289,31 @@ void XdsClient::Orphan() {
   Unref(DEBUG_LOCATION, "XdsClient::Orphan()");
 }
 
-void XdsClient::WatchClusterData(StringView cluster,
-                                 UniquePtr<ClusterWatcherInterface> watcher) {
-  // TODO(juanlishen): Implement.
+void XdsClient::WatchClusterData(
+    StringView cluster, std::unique_ptr<ClusterWatcherInterface> watcher) {
+  ClusterWatcherInterface* w = watcher.get();
+  cluster_state_.cluster_watchers[w] = std::move(watcher);
+  // TODO(juanlishen): Start CDS call if not already started and return
+  // real data via watcher.
+  CdsUpdate update;
+  update.eds_service_name = StringViewToCString(cluster);
+  update.lrs_load_reporting_server_name.reset(gpr_strdup(""));
+  w->OnClusterChanged(std::move(update));
 }
 
 void XdsClient::CancelClusterDataWatch(StringView cluster,
                                        ClusterWatcherInterface* watcher) {
-  // TODO(juanlishen): Implement.
+  auto it = cluster_state_.cluster_watchers.find(watcher);
+  if (it != cluster_state_.cluster_watchers.end()) {
+    cluster_state_.cluster_watchers.erase(it);
+  }
+  if (chand_ != nullptr && cluster_state_.cluster_watchers.empty()) {
+    // TODO(juanlishen): Stop CDS call.
+  }
 }
 
-void XdsClient::WatchEndpointData(StringView cluster,
-                                  UniquePtr<EndpointWatcherInterface> watcher) {
+void XdsClient::WatchEndpointData(
+    StringView /*cluster*/, std::unique_ptr<EndpointWatcherInterface> watcher) {
   EndpointWatcherInterface* w = watcher.get();
   cluster_state_.endpoint_watchers[w] = std::move(watcher);
   // If we've already received an EDS update, notify the new watcher
@@ -1308,7 +1324,7 @@ void XdsClient::WatchEndpointData(StringView cluster,
   chand_->MaybeStartAdsCall();
 }
 
-void XdsClient::CancelEndpointDataWatch(StringView cluster,
+void XdsClient::CancelEndpointDataWatch(StringView /*cluster*/,
                                         EndpointWatcherInterface* watcher) {
   auto it = cluster_state_.endpoint_watchers.find(watcher);
   if (it != cluster_state_.endpoint_watchers.end()) {
@@ -1319,14 +1335,20 @@ void XdsClient::CancelEndpointDataWatch(StringView cluster,
   }
 }
 
-void XdsClient::AddClientStats(StringView cluster,
+void XdsClient::AddClientStats(StringView /*lrs_server*/,
+                               StringView /*cluster*/,
                                XdsClientStats* client_stats) {
+  // TODO(roth): When we add support for direct federation, use the
+  // server name specified in lrs_server.
   cluster_state_.client_stats.insert(client_stats);
   chand_->MaybeStartLrsCall();
 }
 
-void XdsClient::RemoveClientStats(StringView cluster,
+void XdsClient::RemoveClientStats(StringView /*lrs_server*/,
+                                  StringView /*cluster*/,
                                   XdsClientStats* client_stats) {
+  // TODO(roth): When we add support for direct federation, use the
+  // server name specified in lrs_server.
   // TODO(roth): In principle, we should try to send a final load report
   // containing whatever final stats have been accumulated since the
   // last load report.
@@ -1362,14 +1384,19 @@ void XdsClient::NotifyOnServiceConfig(void* arg, grpc_error* error) {
   XdsClient* self = static_cast<XdsClient*>(arg);
   // TODO(roth): When we add support for WeightedClusters, select the
   // LB policy based on that functionality.
-  static const char* json =
-      "{\n"
-      "  \"loadBalancingConfig\":[\n"
-      "    { \"xds_experimental\":{} }\n"
-      "  ]\n"
-      "}";
+  char* json;
+  gpr_asprintf(&json,
+               "{\n"
+               "  \"loadBalancingConfig\":[\n"
+               "    { \"cds_experimental\":{\n"
+               "      \"cluster\": \"%s\"\n"
+               "    } }\n"
+               "  ]\n"
+               "}",
+               self->server_name_.get());
   RefCountedPtr<ServiceConfig> service_config =
       ServiceConfig::Create(json, &error);
+  gpr_free(json);
   if (error != GRPC_ERROR_NONE) {
     self->service_config_watcher_->OnError(error);
   } else {