grpc 1.61.0 → 1.62.0.pre1

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

@@ -34,11 +34,17 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
+#include "envoy/config/core/v3/base.upb.h"
+#include "envoy/service/status/v3/csds.upb.h"
+#include "google/protobuf/any.upb.h"
+#include "google/protobuf/timestamp.upb.h"
+#include "upb/base/string_view.h"
 #include "upb/mem/arena.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_api.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_client_stats.h"
@@ -488,7 +494,7 @@ void XdsClient::XdsChannel::Orphan() ABSL_NO_THREAD_SAFETY_ANALYSIS {
   // At this time, all strong refs are removed, remove from channel map to
   // prevent subsequent subscription from trying to use this XdsChannel as
   // it is shutting down.
-  xds_client_->xds_server_channel_map_.erase(&server_);
+  xds_client_->xds_channel_map_.erase(server_.Key());
   ads_call_.reset();
   lrs_call_.reset();
 }
@@ -510,7 +516,7 @@ void XdsClient::XdsChannel::MaybeStartLrsCall() {
 }
 
 void XdsClient::XdsChannel::StopLrsCallLocked() {
-  xds_client_->xds_load_report_server_map_.erase(&server_);
+  xds_client_->xds_load_report_server_map_.erase(server_.Key());
   lrs_call_.reset();
 }
 
@@ -1308,8 +1314,8 @@ void XdsClient::XdsChannel::LrsCall::Orphan() {
 
 void XdsClient::XdsChannel::LrsCall::MaybeScheduleNextReportLocked() {
   // If there are no more registered stats to report, cancel the call.
-  auto it =
-      xds_client()->xds_load_report_server_map_.find(&xds_channel()->server_);
+  auto it = xds_client()->xds_load_report_server_map_.find(
+      xds_channel()->server_.Key());
   if (it == xds_client()->xds_load_report_server_map_.end() ||
       it->second.load_report_map.empty()) {
     it->second.xds_channel->StopLrsCallLocked();
@@ -1531,14 +1537,15 @@ void XdsClient::Orphan() {
 
 RefCountedPtr<XdsClient::XdsChannel> XdsClient::GetOrCreateXdsChannelLocked(
     const XdsBootstrap::XdsServer& server, const char* reason) {
-  auto it = xds_server_channel_map_.find(&server);
-  if (it != xds_server_channel_map_.end()) {
+  std::string key = server.Key();
+  auto it = xds_channel_map_.find(key);
+  if (it != xds_channel_map_.end()) {
     return it->second->Ref(DEBUG_LOCATION, reason);
   }
   // Channel not found, so create a new one.
   auto xds_channel =
       MakeRefCounted<XdsChannel>(WeakRef(DEBUG_LOCATION, "XdsChannel"), server);
-  xds_server_channel_map_[&server] = xds_channel.get();
+  xds_channel_map_[std::move(key)] = xds_channel.get();
   return xds_channel;
 }
 
@@ -1580,14 +1587,6 @@ void XdsClient::WatchResource(const XdsResourceType* type,
     xds_server = authority->server();
   }
   if (xds_server == nullptr) xds_server = &bootstrap_->server();
-  // Canonify the xDS server instance, so that we make sure we're using
-  // the same instance as will be used in AddClusterDropStats() and
-  // AddClusterLocalityStats().  This may yield a different result than
-  // the logic above if the same server is listed both in the authority
-  // and as the top-level server.
-  // TODO(roth): This is really ugly -- need to find a better way to
-  // index the xDS server than by address here.
-  xds_server = bootstrap_->FindXdsServer(*xds_server);
   {
     MutexLock lock(&mu_);
     MaybeRegisterResourceTypeLocked(type);
@@ -1781,23 +1780,21 @@ std::string XdsClient::ConstructFullXdsResourceName(
 RefCountedPtr<XdsClusterDropStats> XdsClient::AddClusterDropStats(
     const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
     absl::string_view eds_service_name) {
-  const auto* server = bootstrap_->FindXdsServer(xds_server);
-  if (server == nullptr) return nullptr;
   auto key =
       std::make_pair(std::string(cluster_name), std::string(eds_service_name));
   RefCountedPtr<XdsClusterDropStats> cluster_drop_stats;
   {
     MutexLock lock(&mu_);
-    // We jump through some hoops here to make sure that the const
-    // XdsBootstrap::XdsServer& and absl::string_views
-    // stored in the XdsClusterDropStats object point to the
-    // XdsBootstrap::XdsServer and strings
-    // in the load_report_map_ key, so that they have the same lifetime.
-    auto server_it =
-        xds_load_report_server_map_.emplace(server, LoadReportServer()).first;
+    // We jump through some hoops here to make sure that the
+    // absl::string_views stored in the XdsClusterDropStats object point
+    // to the strings in the xds_load_report_server_map_ keys, so that
+    // they have the same lifetime.
+    auto server_it = xds_load_report_server_map_
+                         .emplace(xds_server.Key(), LoadReportServer())
+                         .first;
     if (server_it->second.xds_channel == nullptr) {
-      server_it->second.xds_channel =
-          GetOrCreateXdsChannelLocked(*server, "load report map (drop stats)");
+      server_it->second.xds_channel = GetOrCreateXdsChannelLocked(
+          xds_server, "load report map (drop stats)");
     }
     auto load_report_it = server_it->second.load_report_map
                               .emplace(std::move(key), LoadReportState())
@@ -1812,7 +1809,7 @@ RefCountedPtr<XdsClusterDropStats> XdsClient::AddClusterDropStats(
             load_report_state.drop_stats->GetSnapshotAndReset();
       }
       cluster_drop_stats = MakeRefCounted<XdsClusterDropStats>(
-          Ref(DEBUG_LOCATION, "DropStats"), *server,
+          Ref(DEBUG_LOCATION, "DropStats"), server_it->first /*xds_server*/,
           load_report_it->first.first /*cluster_name*/,
           load_report_it->first.second /*eds_service_name*/);
       load_report_state.drop_stats = cluster_drop_stats.get();
@@ -1824,13 +1821,11 @@ RefCountedPtr<XdsClusterDropStats> XdsClient::AddClusterDropStats(
 }
 
 void XdsClient::RemoveClusterDropStats(
-    const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
+    absl::string_view xds_server_key, absl::string_view cluster_name,
     absl::string_view eds_service_name,
     XdsClusterDropStats* cluster_drop_stats) {
-  const auto* server = bootstrap_->FindXdsServer(xds_server);
-  if (server == nullptr) return;
   MutexLock lock(&mu_);
-  auto server_it = xds_load_report_server_map_.find(server);
+  auto server_it = xds_load_report_server_map_.find(xds_server_key);
   if (server_it == xds_load_report_server_map_.end()) return;
   auto load_report_it = server_it->second.load_report_map.find(
       std::make_pair(std::string(cluster_name), std::string(eds_service_name)));
@@ -1849,23 +1844,21 @@ RefCountedPtr<XdsClusterLocalityStats> XdsClient::AddClusterLocalityStats(
     const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
     absl::string_view eds_service_name,
     RefCountedPtr<XdsLocalityName> locality) {
-  const auto* server = bootstrap_->FindXdsServer(xds_server);
-  if (server == nullptr) return nullptr;
   auto key =
       std::make_pair(std::string(cluster_name), std::string(eds_service_name));
   RefCountedPtr<XdsClusterLocalityStats> cluster_locality_stats;
   {
     MutexLock lock(&mu_);
-    // We jump through some hoops here to make sure that the const
-    // XdsBootstrap::XdsServer& and absl::string_views
-    // stored in the XdsClusterDropStats object point to the
-    // XdsBootstrap::XdsServer and strings
-    // in the load_report_map_ key, so that they have the same lifetime.
-    auto server_it =
-        xds_load_report_server_map_.emplace(server, LoadReportServer()).first;
+    // We jump through some hoops here to make sure that the
+    // absl::string_views stored in the XdsClusterDropStats object point
+    // to the strings in the xds_load_report_server_map_ keys, so that
+    // they have the same lifetime.
+    auto server_it = xds_load_report_server_map_
+                         .emplace(xds_server.Key(), LoadReportServer())
+                         .first;
     if (server_it->second.xds_channel == nullptr) {
       server_it->second.xds_channel = GetOrCreateXdsChannelLocked(
-          *server, "load report map (locality stats)");
+          xds_server, "load report map (locality stats)");
     }
     auto load_report_it = server_it->second.load_report_map
                               .emplace(std::move(key), LoadReportState())
@@ -1882,7 +1875,7 @@ RefCountedPtr<XdsClusterLocalityStats> XdsClient::AddClusterLocalityStats(
             locality_state.locality_stats->GetSnapshotAndReset();
       }
       cluster_locality_stats = MakeRefCounted<XdsClusterLocalityStats>(
-          Ref(DEBUG_LOCATION, "LocalityStats"), *server,
+          Ref(DEBUG_LOCATION, "LocalityStats"), server_it->first /*xds_server*/,
           load_report_it->first.first /*cluster_name*/,
           load_report_it->first.second /*eds_service_name*/,
           std::move(locality));
@@ -1895,14 +1888,12 @@ RefCountedPtr<XdsClusterLocalityStats> XdsClient::AddClusterLocalityStats(
 }
 
 void XdsClient::RemoveClusterLocalityStats(
-    const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
+    absl::string_view xds_server_key, absl::string_view cluster_name,
     absl::string_view eds_service_name,
     const RefCountedPtr<XdsLocalityName>& locality,
     XdsClusterLocalityStats* cluster_locality_stats) {
-  const auto* server = bootstrap_->FindXdsServer(xds_server);
-  if (server == nullptr) return;
   MutexLock lock(&mu_);
-  auto server_it = xds_load_report_server_map_.find(server);
+  auto server_it = xds_load_report_server_map_.find(xds_server_key);
   if (server_it == xds_load_report_server_map_.end()) return;
   auto load_report_it = server_it->second.load_report_map.find(
       std::make_pair(std::string(cluster_name), std::string(eds_service_name)));
@@ -1922,7 +1913,7 @@ void XdsClient::RemoveClusterLocalityStats(
 
 void XdsClient::ResetBackoff() {
   MutexLock lock(&mu_);
-  for (auto& p : xds_server_channel_map_) {
+  for (auto& p : xds_channel_map_) {
     p.second->ResetBackoff();
   }
 }
@@ -1969,7 +1960,7 @@ XdsApi::ClusterLoadReportMap XdsClient::BuildLoadReportSnapshotLocked(
     gpr_log(GPR_INFO, "[xds_client %p] start building load report", this);
   }
   XdsApi::ClusterLoadReportMap snapshot_map;
-  auto server_it = xds_load_report_server_map_.find(&xds_server);
+  auto server_it = xds_load_report_server_map_.find(xds_server.Key());
   if (server_it == xds_load_report_server_map_.end()) return snapshot_map;
   auto& load_report_map = server_it->second.load_report_map;
   for (auto load_report_it = load_report_map.begin();
@@ -2047,25 +2038,86 @@ XdsApi::ClusterLoadReportMap XdsClient::BuildLoadReportSnapshotLocked(
   return snapshot_map;
 }
 
-std::string XdsClient::DumpClientConfigBinary() {
-  MutexLock lock(&mu_);
-  XdsApi::ResourceTypeMetadataMap resource_type_metadata_map;
+namespace {
+
+google_protobuf_Timestamp* EncodeTimestamp(Timestamp value, upb_Arena* arena) {
+  google_protobuf_Timestamp* timestamp = google_protobuf_Timestamp_new(arena);
+  gpr_timespec timespec = value.as_timespec(GPR_CLOCK_REALTIME);
+  google_protobuf_Timestamp_set_seconds(timestamp, timespec.tv_sec);
+  google_protobuf_Timestamp_set_nanos(timestamp, timespec.tv_nsec);
+  return timestamp;
+}
+
+void FillGenericXdsConfig(
+    const XdsApi::ResourceMetadata& metadata, upb_StringView type_url,
+    upb_StringView resource_name, upb_Arena* arena,
+    envoy_service_status_v3_ClientConfig_GenericXdsConfig* entry) {
+  envoy_service_status_v3_ClientConfig_GenericXdsConfig_set_type_url(entry,
+                                                                     type_url);
+  envoy_service_status_v3_ClientConfig_GenericXdsConfig_set_name(entry,
+                                                                 resource_name);
+  envoy_service_status_v3_ClientConfig_GenericXdsConfig_set_client_status(
+      entry, metadata.client_status);
+  if (!metadata.serialized_proto.empty()) {
+    envoy_service_status_v3_ClientConfig_GenericXdsConfig_set_version_info(
+        entry, StdStringToUpbString(metadata.version));
+    envoy_service_status_v3_ClientConfig_GenericXdsConfig_set_last_updated(
+        entry, EncodeTimestamp(metadata.update_time, arena));
+    auto* any_field =
+        envoy_service_status_v3_ClientConfig_GenericXdsConfig_mutable_xds_config(
+            entry, arena);
+    google_protobuf_Any_set_type_url(any_field, type_url);
+    google_protobuf_Any_set_value(
+        any_field, StdStringToUpbString(metadata.serialized_proto));
+  }
+  if (metadata.client_status == XdsApi::ResourceMetadata::NACKED) {
+    auto* update_failure_state = envoy_admin_v3_UpdateFailureState_new(arena);
+    envoy_admin_v3_UpdateFailureState_set_details(
+        update_failure_state, StdStringToUpbString(metadata.failed_details));
+    envoy_admin_v3_UpdateFailureState_set_version_info(
+        update_failure_state, StdStringToUpbString(metadata.failed_version));
+    envoy_admin_v3_UpdateFailureState_set_last_update_attempt(
+        update_failure_state,
+        EncodeTimestamp(metadata.failed_update_time, arena));
+    envoy_service_status_v3_ClientConfig_GenericXdsConfig_set_error_state(
+        entry, update_failure_state);
+  }
+}
+
+}  // namespace
+
+void XdsClient::DumpClientConfig(
+    std::set<std::string>* string_pool, upb_Arena* arena,
+    envoy_service_status_v3_ClientConfig* client_config) {
+  // Assemble config dump messages
+  // Fill-in the node information
+  auto* node =
+      envoy_service_status_v3_ClientConfig_mutable_node(client_config, arena);
+  api_.PopulateNode(node, arena);
+  // Dump each resource.
   for (const auto& a : authority_state_map_) {  // authority
     const std::string& authority = a.first;
     for (const auto& t : a.second.resource_map) {  // type
       const XdsResourceType* type = t.first;
-      auto& resource_metadata_map =
-          resource_type_metadata_map[type->type_url()];
+      auto it =
+          string_pool
+              ->emplace(absl::StrCat("type.googleapis.com/", type->type_url()))
+              .first;
+      upb_StringView type_url = StdStringToUpbString(*it);
       for (const auto& r : t.second) {  // resource id
-        const XdsResourceKey& resource_key = r.first;
-        const ResourceState& resource_state = r.second;
-        resource_metadata_map[ConstructFullXdsResourceName(
-            authority, type->type_url(), resource_key)] = &resource_state.meta;
+        auto it2 = string_pool
+                       ->emplace(ConstructFullXdsResourceName(
+                           authority, type->type_url(), r.first))
+                       .first;
+        upb_StringView resource_name = StdStringToUpbString(*it2);
+        envoy_service_status_v3_ClientConfig_GenericXdsConfig* entry =
+            envoy_service_status_v3_ClientConfig_add_generic_xds_configs(
+                client_config, arena);
+        FillGenericXdsConfig(r.second.meta, type_url, resource_name, arena,
+                             entry);
       }
     }
   }
-  // Assemble config dump messages
-  return api_.AssembleClientConfig(resource_type_metadata_map);
 }
 
 }  // namespace grpc_core

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

@@ -51,6 +51,10 @@
 
 namespace grpc_core {
 
+namespace testing {
+class XdsClientTestPeer;
+}
+
 extern TraceFlag grpc_xds_client_trace;
 extern TraceFlag grpc_xds_client_refcount_trace;
 
@@ -127,7 +131,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
   RefCountedPtr<XdsClusterDropStats> AddClusterDropStats(
       const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
       absl::string_view eds_service_name);
-  void RemoveClusterDropStats(const XdsBootstrap::XdsServer& xds_server,
+  void RemoveClusterDropStats(absl::string_view xds_server,
                               absl::string_view cluster_name,
                               absl::string_view eds_service_name,
                               XdsClusterDropStats* cluster_drop_stats);
@@ -139,7 +143,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
       absl::string_view eds_service_name,
       RefCountedPtr<XdsLocalityName> locality);
   void RemoveClusterLocalityStats(
-      const XdsBootstrap::XdsServer& xds_server, absl::string_view cluster_name,
+      absl::string_view xds_server, absl::string_view cluster_name,
       absl::string_view eds_service_name,
       const RefCountedPtr<XdsLocalityName>& locality,
       XdsClusterLocalityStats* cluster_locality_stats);
@@ -147,20 +151,23 @@ class XdsClient : public DualRefCounted<XdsClient> {
   // Resets connection backoff state.
   void ResetBackoff();
 
-  // Dumps the active xDS config in JSON format.
-  // Individual xDS resource is encoded as envoy.admin.v3.*ConfigDump. Returns
-  // envoy.service.status.v3.ClientConfig which also includes the config
-  // status (e.g., CLIENT_REQUESTED, CLIENT_ACKED, CLIENT_NACKED).
-  //
-  // Expected to be invoked by wrapper languages in their CSDS service
-  // implementation.
-  std::string DumpClientConfigBinary();
-
   grpc_event_engine::experimental::EventEngine* engine() {
     return engine_.get();
   }
 
+ protected:
+  // Dumps the active xDS config to the provided
+  // envoy.service.status.v3.ClientConfig message including the config status
+  // (e.g., CLIENT_REQUESTED, CLIENT_ACKED, CLIENT_NACKED).
+  void DumpClientConfig(std::set<std::string>* string_pool, upb_Arena* arena,
+                        envoy_service_status_v3_ClientConfig* client_config)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
+
+  Mutex* mu() ABSL_LOCK_RETURNED(&mu_) { return &mu_; }
+
  private:
+  friend testing::XdsClientTestPeer;
+
   struct XdsResourceKey {
     std::string id;
     std::vector<URI::QueryParam> query_params;
@@ -329,15 +336,13 @@ class XdsClient : public DualRefCounted<XdsClient> {
   upb::DefPool def_pool_ ABSL_GUARDED_BY(mu_);
 
   // Map of existing xDS server channels.
-  // Key is owned by the bootstrap config.
-  std::map<const XdsBootstrap::XdsServer*, XdsChannel*> xds_server_channel_map_
+  std::map<std::string /*XdsServer key*/, XdsChannel*> xds_channel_map_
       ABSL_GUARDED_BY(mu_);
 
   std::map<std::string /*authority*/, AuthorityState> authority_state_map_
       ABSL_GUARDED_BY(mu_);
 
-  // Key is owned by the bootstrap config.
-  std::map<const XdsBootstrap::XdsServer*, LoadReportServer>
+  std::map<std::string /*XdsServer key*/, LoadReportServer, std::less<>>
       xds_load_report_server_map_ ABSL_GUARDED_BY(mu_);
 
   // Stores started watchers whose resource name was not parsed successfully,

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

@@ -19,15 +19,19 @@
 #include "src/core/ext/xds/xds_client_grpc.h"
 
 #include <algorithm>
+#include <cstddef>
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "envoy/service/status/v3/csds.upb.h"
+#include "upb/base/string_view.h"
 
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
@@ -36,9 +40,12 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/ext/xds/upb_utils.h"
+#include "src/core/ext/xds/xds_api.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_channel_args.h"
+#include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_transport.h"
 #include "src/core/ext/xds/xds_transport_grpc.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -46,13 +53,13 @@
 #include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/env.h"
+#include "src/core/lib/gprpp/load_file.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -102,13 +109,9 @@ absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
               "environment variable: %s",
               path->c_str());
     }
-    grpc_slice contents;
-    grpc_error_handle error =
-        grpc_load_file(path->c_str(), /*add_null_terminator=*/true, &contents);
-    if (!error.ok()) return grpc_error_to_absl_status(error);
-    std::string contents_str(StringViewFromSlice(contents));
-    CSliceUnref(contents);
-    return contents_str;
+    auto contents = LoadFile(*path, /*add_null_terminator=*/true);
+    if (!contents.ok()) return contents.status();
+    return std::string(contents->as_string_view());
   }
   // Next, try GRPC_XDS_BOOTSTRAP_CONFIG env var.
   auto env_config = GetEnv("GRPC_XDS_BOOTSTRAP_CONFIG");
@@ -133,6 +136,19 @@ absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
       "not defined");
 }
 
+std::vector<RefCountedPtr<GrpcXdsClient>> GetAllXdsClients() {
+  MutexLock lock(g_mu);
+  std::vector<RefCountedPtr<GrpcXdsClient>> xds_clients;
+  if (g_xds_client != nullptr) {
+    auto xds_client =
+        g_xds_client->RefIfNonZero(DEBUG_LOCATION, "DumpAllClientConfigs");
+    if (xds_client != nullptr) {
+      xds_clients.emplace_back(xds_client.TakeAsSubclass<GrpcXdsClient>());
+    }
+  }
+  return xds_clients;
+}
+
 }  // namespace
 
 absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
@@ -178,6 +194,34 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
   return xds_client;
 }
 
+// ABSL_NO_THREAD_SAFETY_ANALYSIS because we have to manually manage locks for
+// individual XdsClients and compiler struggles with checking the validity
+grpc_slice GrpcXdsClient::DumpAllClientConfigs()
+    ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  auto xds_clients = GetAllXdsClients();
+  upb::Arena arena;
+  // Contains strings that should survive till serialization
+  std::set<std::string> string_pool;
+  auto response = envoy_service_status_v3_ClientStatusResponse_new(arena.ptr());
+  // We lock each XdsClient mutex till we are done with the serialization to
+  // ensure that all data referenced from the UPB proto message stays alive.
+  for (const auto& xds_client : xds_clients) {
+    auto client_config =
+        envoy_service_status_v3_ClientStatusResponse_add_config(response,
+                                                                arena.ptr());
+    xds_client->mu()->Lock();
+    xds_client->DumpClientConfig(&string_pool, arena.ptr(), client_config);
+  }
+  // Serialize the upb message to bytes
+  size_t output_length;
+  char* output = envoy_service_status_v3_ClientStatusResponse_serialize(
+      response, arena.ptr(), &output_length);
+  for (const auto& xds_client : xds_clients) {
+    xds_client->mu()->Unlock();
+  }
+  return grpc_slice_from_cpp_string(std::string(output, output_length));
+}
+
 GrpcXdsClient::GrpcXdsClient(
     std::unique_ptr<GrpcXdsBootstrap> bootstrap, const ChannelArgs& args,
     OrphanablePtr<XdsTransportFactory> transport_factory)
@@ -233,11 +277,5 @@ void SetXdsFallbackBootstrapConfig(const char* config) {
 grpc_slice grpc_dump_xds_configs(void) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  auto xds_client = grpc_core::GrpcXdsClient::GetOrCreate(
-      grpc_core::ChannelArgs(), "grpc_dump_xds_configs()");
-  if (!xds_client.ok()) {
-    // If we aren't using xDS, just return an empty string.
-    return grpc_empty_slice();
-  }
-  return grpc_slice_from_cpp_string((*xds_client)->DumpClientConfigBinary());
+  return grpc_core::GrpcXdsClient::DumpAllClientConfigs();
 }

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

@@ -35,7 +35,7 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/resolver/endpoint_addresses.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
@@ -45,6 +45,9 @@ class GrpcXdsClient : public XdsClient {
   static absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GetOrCreate(
       const ChannelArgs& args, const char* reason);
 
+  // Builds ClientStatusResponse containing all resources from all XdsClients
+  static grpc_slice DumpAllClientConfigs();
+
   // Do not instantiate directly -- use GetOrCreate() instead.
   // TODO(roth): The transport factory is injectable here to support
   // tests that want to use a fake transport factory with code that

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

@@ -40,10 +40,10 @@ uint64_t GetAndResetCounter(std::atomic<uint64_t>* from) {
 // XdsClusterDropStats
 //
 
-XdsClusterDropStats::XdsClusterDropStats(
-    RefCountedPtr<XdsClient> xds_client,
-    const XdsBootstrap::XdsServer& lrs_server, absl::string_view cluster_name,
-    absl::string_view eds_service_name)
+XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
+                                         absl::string_view 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),
@@ -53,7 +53,7 @@ XdsClusterDropStats::XdsClusterDropStats(
       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, lrs_server_.server_uri().c_str(),
+            xds_client_.get(), this, std::string(lrs_server_).c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str());
   }
@@ -63,7 +63,7 @@ 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, lrs_server_.server_uri().c_str(),
+            xds_client_.get(), this, std::string(lrs_server_).c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str());
   }
@@ -94,9 +94,9 @@ void XdsClusterDropStats::AddCallDropped(const std::string& category) {
 //
 
 XdsClusterLocalityStats::XdsClusterLocalityStats(
-    RefCountedPtr<XdsClient> xds_client,
-    const XdsBootstrap::XdsServer& lrs_server, absl::string_view cluster_name,
-    absl::string_view eds_service_name, RefCountedPtr<XdsLocalityName> name)
+    RefCountedPtr<XdsClient> xds_client, absl::string_view 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),
@@ -108,7 +108,7 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
   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, lrs_server_.server_uri().c_str(),
+            xds_client_.get(), this, std::string(lrs_server_).c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str(),
             name_->AsHumanReadableString().c_str());
@@ -119,7 +119,7 @@ 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, lrs_server_.server_uri().c_str(),
+            xds_client_.get(), this, std::string(lrs_server_).c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str(),
             name_->AsHumanReadableString().c_str());