grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/util/memory_usage.h

@@ -28,6 +28,8 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/time.h"
 
 namespace grpc_core {
@@ -88,6 +90,10 @@ template <typename T>
 constexpr Category kMemoryUsageCategory<std::shared_ptr<T>> =
     Category::kOwnedPointer;
 
+template <typename T>
+constexpr Category kMemoryUsageCategory<absl::StatusOr<T>> =
+    Category::kAbslStatusOr;
+
 template <typename T>
 constexpr Category kMemoryUsageCategory<std::vector<T>> = Category::kVector;
 
@@ -135,6 +141,10 @@ size_t MemoryUsageOf(const T& x) {
     return sizeof(T);
   } else if constexpr (std::is_same_v<T, Duration>) {
     return sizeof(T);
+  } else if constexpr (std::is_same_v<T, Slice>) {
+    return sizeof(T) + x.size();  // may overestimate a bit
+  } else if constexpr (std::is_same_v<T, SliceBuffer>) {
+    return sizeof(T) + x.Length();  // may overestimate a bit
   } else if constexpr (category == Category::kSimple) {
     return sizeof(T);
   } else if constexpr (category == Category::kOwnedPointer) {
@@ -263,6 +273,12 @@ size_t MemoryUsageOf(const std::tuple<Args...>& t) {
       [](const auto&... args) { return (MemoryUsageOf(args) + ... + 0); }, t);
 }
 
+// This does not calculate the overhead of the variant itself.
+template <typename... T>
+size_t MemoryUsageOf(const std::variant<T...>& t) {
+  return std::visit([](const auto& x) { return MemoryUsageOf(x); }, t);
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_MEMORY_USAGE_H

data/src/core/util/posix/directory_reader.cc

@@ -25,7 +25,7 @@
 #include "absl/strings/string_view.h"
 
 #if defined(GPR_LINUX) || defined(GPR_ANDROID) || defined(GPR_FREEBSD) || \
-    defined(GPR_APPLE) || defined(GPR_NETBSD)
+    defined(GPR_APPLE) || defined(GPR_NETBSD) || defined(GPR_OPENBSD)
 
 #include <dirent.h>
 
@@ -79,4 +79,5 @@ absl::Status DirectoryReaderImpl::ForEach(
 }
 }  // namespace grpc_core
 
-#endif  // GPR_LINUX || GPR_ANDROID || GPR_FREEBSD || GPR_APPLE
+#endif  // GPR_LINUX || GPR_ANDROID || GPR_FREEBSD || GPR_APPLE ||
+        // GPR_NETBSD || GPR_OPENBSD

data/src/core/util/posix/sync.cc

@@ -27,40 +27,40 @@
 #include <grpc/support/time.h>
 #include <time.h>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 void gpr_mu_init(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_mutex_init(&mu->mutex, nullptr), 0);
+  GRPC_CHECK_EQ(pthread_mutex_init(&mu->mutex, nullptr), 0);
   mu->leak_checker = static_cast<int*>(malloc(sizeof(*mu->leak_checker)));
-  CHECK_NE(mu->leak_checker, nullptr);
+  GRPC_CHECK_NE(mu->leak_checker, nullptr);
 #else
-  CHECK_EQ(pthread_mutex_init(mu, nullptr), 0);
+  GRPC_CHECK_EQ(pthread_mutex_init(mu, nullptr), 0);
 #endif
 }
 
 void gpr_mu_destroy(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_mutex_destroy(&mu->mutex), 0);
+  GRPC_CHECK_EQ(pthread_mutex_destroy(&mu->mutex), 0);
   free(mu->leak_checker);
 #else
-  CHECK_EQ(pthread_mutex_destroy(mu), 0);
+  GRPC_CHECK_EQ(pthread_mutex_destroy(mu), 0);
 #endif
 }
 
 void gpr_mu_lock(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_mutex_lock(&mu->mutex), 0);
+  GRPC_CHECK_EQ(pthread_mutex_lock(&mu->mutex), 0);
 #else
-  CHECK_EQ(pthread_mutex_lock(mu), 0);
+  GRPC_CHECK_EQ(pthread_mutex_lock(mu), 0);
 #endif
 }
 
 void gpr_mu_unlock(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_mutex_unlock(&mu->mutex), 0);
+  GRPC_CHECK_EQ(pthread_mutex_unlock(&mu->mutex), 0);
 #else
-  CHECK_EQ(pthread_mutex_unlock(mu), 0);
+  GRPC_CHECK_EQ(pthread_mutex_unlock(mu), 0);
 #endif
 }
 
@@ -71,7 +71,7 @@ int gpr_mu_trylock(gpr_mu* mu) {
 #else
   err = pthread_mutex_trylock(mu);
 #endif
-  CHECK(err == 0 || err == EBUSY);
+  GRPC_CHECK(err == 0 || err == EBUSY);
   return err == 0;
 }
 
@@ -79,26 +79,26 @@ int gpr_mu_trylock(gpr_mu* mu) {
 
 void gpr_cv_init(gpr_cv* cv) {
   pthread_condattr_t attr;
-  CHECK_EQ(pthread_condattr_init(&attr), 0);
+  GRPC_CHECK_EQ(pthread_condattr_init(&attr), 0);
 #if GPR_LINUX
-  CHECK_EQ(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC), 0);
+  GRPC_CHECK_EQ(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC), 0);
 #endif  // GPR_LINUX
 
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_cond_init(&cv->cond_var, &attr), 0);
+  GRPC_CHECK_EQ(pthread_cond_init(&cv->cond_var, &attr), 0);
   cv->leak_checker = static_cast<int*>(malloc(sizeof(*cv->leak_checker)));
-  CHECK_NE(cv->leak_checker, nullptr);
+  GRPC_CHECK_NE(cv->leak_checker, nullptr);
 #else
-  CHECK_EQ(pthread_cond_init(cv, &attr), 0);
+  GRPC_CHECK_EQ(pthread_cond_init(cv, &attr), 0);
 #endif
 }
 
 void gpr_cv_destroy(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_cond_destroy(&cv->cond_var), 0);
+  GRPC_CHECK_EQ(pthread_cond_destroy(&cv->cond_var), 0);
   free(cv->leak_checker);
 #else
-  CHECK_EQ(pthread_cond_destroy(cv), 0);
+  GRPC_CHECK_EQ(pthread_cond_destroy(cv), 0);
 #endif
 }
 
@@ -127,30 +127,30 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
     err = pthread_cond_timedwait(cv, mu, &abs_deadline_ts);
 #endif
   }
-  CHECK(err == 0 || err == ETIMEDOUT || err == EAGAIN);
+  GRPC_CHECK(err == 0 || err == ETIMEDOUT || err == EAGAIN);
   return err == ETIMEDOUT;
 }
 
 void gpr_cv_signal(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_cond_signal(&cv->cond_var), 0);
+  GRPC_CHECK_EQ(pthread_cond_signal(&cv->cond_var), 0);
 #else
-  CHECK_EQ(pthread_cond_signal(cv), 0);
+  GRPC_CHECK_EQ(pthread_cond_signal(cv), 0);
 #endif
 }
 
 void gpr_cv_broadcast(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_cond_broadcast(&cv->cond_var), 0);
+  GRPC_CHECK_EQ(pthread_cond_broadcast(&cv->cond_var), 0);
 #else
-  CHECK_EQ(pthread_cond_broadcast(cv), 0);
+  GRPC_CHECK_EQ(pthread_cond_broadcast(cv), 0);
 #endif
 }
 
 //----------------------------------------
 
 void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
-  CHECK_EQ(pthread_once(once, init_function), 0);
+  GRPC_CHECK_EQ(pthread_once(once, init_function), 0);
 }
 
 #endif  // defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) &&

data/src/core/util/postmortem_emit.cc

@@ -0,0 +1,52 @@
+// Copyright 2025 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 "src/core/util/postmortem_emit.h"
+
+#include <iostream>
+#include <sstream>
+
+#include "src/core/channelz/channelz_registry.h"
+#include "src/core/telemetry/stats.h"
+
+namespace grpc_core {
+
+namespace {
+
+void RunPostMortem(std::ostream& out) {
+  out << "===========================================================\n";
+  out << "🛑 gRPC Test Postmortem Analysis 🛑\n";
+  out << "===========================================================\n";
+
+  out << "❗ gRPC Statistics:\n"
+      << StatsAsJson(global_stats().Collect().get()) << "\n";
+
+  out << "❗ channelz entities:\n";
+  for (const auto& node : channelz::ChannelzRegistry::GetAllEntities()) {
+    out << "  🔴 [" << node->uuid() << ":"
+        << channelz::BaseNode::EntityTypeString(node->type())
+        << "]: " << node->RenderJsonString() << "\n";
+  }
+}
+
+}  // namespace
+
+void PostMortemEmit() { RunPostMortem(std::cerr); }
+
+void SilentPostMortemEmit() {
+  std::ostringstream out;
+  RunPostMortem(out);
+}
+
+}  // namespace grpc_core

data/src/core/util/postmortem_emit.h

@@ -0,0 +1,30 @@
+// Copyright 2025 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_SRC_CORE_UTIL_POSTMORTEM_EMIT_H
+#define GRPC_SRC_CORE_UTIL_POSTMORTEM_EMIT_H
+
+namespace grpc_core {
+
+// Emit useful post mortem analysis from whatever in-process data we have.
+void PostMortemEmit();
+
+// Does all the work of PostMortemEmit, but doesn't emit anything.
+// This is useful for verifying that PostMortemEmit *would* succeed...
+// which means especially that channelz is working.
+void SilentPostMortemEmit();
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_POSTMORTEM_EMIT_H

data/src/core/util/ref_counted_ptr.h

@@ -464,6 +464,11 @@ struct WeakRefCountedPtrEq {
   }
 };
 
+template <typename To, typename From>
+RefCountedPtr<To> DownCastRefCountedPtr(RefCountedPtr<From> ptr) {
+  return RefCountedPtr<To>(DownCast<To*>(ptr.release()));
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_REF_COUNTED_PTR_H

data/src/core/util/trie_lookup.h

@@ -0,0 +1,170 @@
+//
+// Copyright 2025 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_SRC_CORE_UTIL_TRIE_LOOKUP_H
+#define GRPC_SRC_CORE_UTIL_TRIE_LOOKUP_H
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+
+template <typename Value>
+class TrieLookupTree {
+ public:
+  TrieLookupTree() : root_(std::make_unique<TrieNode>()) {}
+
+  // Takes value by r-value reference to consume it.
+  bool AddNode(absl::string_view key, Value value) {
+    auto* node = root_.get();
+    for (auto c : key) {
+      auto& child = node->child[c];
+      if (child == nullptr) {
+        child = std::make_unique<TrieNode>();
+      }
+      node = child.get();
+    }
+    node->value = std::move(value);
+    return true;
+  }
+
+  // Returns a const pointer to the value.
+  const Value* Lookup(absl::string_view key) const {
+    const auto* node = root_.get();
+    for (auto c : key) {
+      auto it = node->child.find(c);
+      if (it == node->child.end()) {
+        return nullptr;
+      }
+      node = it->second.get();
+    }
+    if (node->value.has_value()) {
+      return &*node->value;
+    }
+    return nullptr;
+  }
+
+  // Return longest matching prefix
+  const Value* LookupLongestPrefix(absl::string_view key) const {
+    const auto* node = root_.get();
+    const Value* matched_value = nullptr;
+    if (node->value.has_value()) {
+      matched_value = &*node->value;
+    }
+    for (auto c : key) {
+      auto it = node->child.find(c);
+      if (it == node->child.end()) {
+        return matched_value;
+      }
+      node = it->second.get();
+      if (node->value.has_value()) {
+        matched_value = &*node->value;
+      }
+    }
+    return matched_value;
+  }
+
+  // Invokes cb for least to most matching prefix
+  void ForEachPrefixMatch(absl::string_view key,
+                          absl::FunctionRef<void(const Value&)> cb) const {
+    const auto* node = root_.get();
+    for (auto c : key) {
+      auto it = node->child.find(c);
+      if (it == node->child.end()) {
+        return;
+      }
+      node = it->second.get();
+      if (node->value.has_value()) {
+        cb(*node->value);
+      }
+    }
+  }
+
+  // invokes cb for every value present in trie
+  // Useful for ToString Method to dump Trie
+  // Format of cb "void(key, value)"
+  void ForEach(
+      absl::FunctionRef<void(absl::string_view, const Value&)> cb) const {
+    if (root_ == nullptr) return;
+    std::string key;
+    ForEachRecursive(root_.get(), key, cb);
+  }
+
+  // Check for equality
+  bool operator==(const TrieLookupTree& other) const {
+    if (this == &other) return true;
+    if (root_ == nullptr || other.root_ == nullptr) {
+      return root_ == other.root_;
+    }
+    std::vector<std::pair<const TrieNode*, const TrieNode*>> nodes_to_compare;
+    nodes_to_compare.emplace_back(root_.get(), other.root_.get());
+    while (!nodes_to_compare.empty()) {
+      auto [node1, node2] = nodes_to_compare.back();
+      nodes_to_compare.pop_back();
+      if (node1->value.has_value() != node2->value.has_value()) {
+        return false;
+      }
+      if (node1->value.has_value()) {
+        if (!(*node1->value == *node2->value)) return false;
+      }
+      if (node1->child.size() != node2->child.size()) {
+        return false;
+      }
+      for (const auto& [key, child1_ptr] : node1->child) {
+        auto it = node2->child.find(key);
+        if (it == node2->child.end()) {
+          return false;
+        }
+        nodes_to_compare.emplace_back(child1_ptr.get(), it->second.get());
+      }
+    }
+    return true;
+  }
+  bool operator!=(const TrieLookupTree& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  struct TrieNode {
+    absl::flat_hash_map<uint8_t, std::unique_ptr<TrieNode>> child;
+    std::optional<Value> value;
+  };
+
+  void ForEachRecursive(
+      const TrieNode* node, std::string& current_key,
+      absl::FunctionRef<void(absl::string_view, const Value&)> cb) const {
+    // check for value and invoke cb
+    if (node->value.has_value()) {
+      cb(current_key, *node->value);
+    }
+    // Recurse on childeren
+    for (const auto& [character, child_node] : node->child) {
+      current_key.push_back(character);
+      ForEachRecursive(child_node.get(), current_key, cb);
+      current_key.pop_back();
+    }
+  }
+
+  std::unique_ptr<TrieNode> root_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_TRIE_LOOKUP_H

data/src/core/util/unique_ptr_with_bitset.h

@@ -18,8 +18,8 @@
 #include <memory>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/numeric/bits.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -36,7 +36,7 @@ class UniquePtrWithBitset {
   UniquePtrWithBitset(std::unique_ptr<T>&& p)
       : UniquePtrWithBitset(p.release()) {}
   ~UniquePtrWithBitset() {
-    DCHECK_LE(kBits, static_cast<size_t>(absl::countr_zero(alignof(T))));
+    GRPC_DCHECK_LE(kBits, static_cast<size_t>(absl::countr_zero(alignof(T))));
     delete get();
   }
   UniquePtrWithBitset(const UniquePtrWithBitset&) = delete;
@@ -59,15 +59,15 @@ class UniquePtrWithBitset {
   }
 
   void SetBit(size_t bit) {
-    DCHECK_LT(bit, kBits);
+    GRPC_DCHECK_LT(bit, kBits);
     p_ |= 1 << bit;
   }
   void ClearBit(size_t bit) {
-    DCHECK_LT(bit, kBits);
+    GRPC_DCHECK_LT(bit, kBits);
     p_ &= ~(1 << bit);
   }
   bool TestBit(size_t bit) const {
-    DCHECK_LT(bit, kBits);
+    GRPC_DCHECK_LT(bit, kBits);
     return p_ & (1 << bit);
   }
 

data/src/core/xds/grpc/xds_bootstrap_grpc.h

@@ -30,13 +30,13 @@
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/json/json_object_loader.h"
-#include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/certificate_provider_store.h"
 #include "src/core/xds/grpc/xds_audit_logger_registry.h"
 #include "src/core/xds/grpc/xds_cluster_specifier_plugin.h"
 #include "src/core/xds/grpc/xds_http_filter_registry.h"
 #include "src/core/xds/grpc/xds_lb_policy_registry.h"
+#include "src/core/xds/grpc/xds_matcher_input.h"
 #include "src/core/xds/grpc/xds_server_grpc.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
 
@@ -148,6 +148,10 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
   const XdsAuditLoggerRegistry& audit_logger_registry() const {
     return audit_logger_registry_;
   }
+  const XdsMatcherInputRegistry<absl::string_view>&
+  matcher_string_input_registry() const {
+    return matcher_string_input_registry_;
+  }
 
   // Exposed for testing purposes only.
   const std::map<std::string, GrpcAuthority>& authorities() const {
@@ -165,6 +169,7 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
   XdsClusterSpecifierPluginRegistry cluster_specifier_plugin_registry_;
   XdsLbPolicyRegistry lb_policy_registry_;
   XdsAuditLoggerRegistry audit_logger_registry_;
+  XdsMatcherInputRegistry<absl::string_view> matcher_string_input_registry_;
 };
 
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_certificate_provider.cc

@@ -24,10 +24,10 @@
 #include <utility>
 
 #include "absl/functional/bind_front.h"
-#include "absl/log/check.h"
 #include "src/core/credentials/transport/tls/ssl_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -185,7 +185,7 @@ void XdsCertificateProvider::WatchStatusCallback(std::string cert_name,
     }
   } else if (!root_being_watched && root_cert_watcher_ != nullptr) {
     // Cancel root cert watch.
-    CHECK(root_cert_provider_ != nullptr);
+    GRPC_CHECK(root_cert_provider_ != nullptr);
     root_cert_provider_->distributor()->CancelTlsCertificatesWatch(
         root_cert_watcher_);
     root_cert_watcher_ = nullptr;
@@ -205,7 +205,7 @@ void XdsCertificateProvider::WatchStatusCallback(std::string cert_name,
           std::move(watcher), std::nullopt, identity_cert_name_);
     }
   } else if (!identity_being_watched && identity_cert_watcher_ != nullptr) {
-    CHECK(identity_cert_provider_ != nullptr);
+    GRPC_CHECK(identity_cert_provider_ != nullptr);
     identity_cert_provider_->distributor()->CancelTlsCertificatesWatch(
         identity_cert_watcher_);
     identity_cert_watcher_ = nullptr;

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

@@ -192,8 +192,11 @@ const grpc_channel_args* g_channel_args ABSL_GUARDED_BY(*g_mu) = nullptr;
 NoDestruct<std::map<absl::string_view, GrpcXdsClient*>> g_xds_client_map
     ABSL_GUARDED_BY(*g_mu);
 char* g_fallback_bootstrap_config ABSL_GUARDED_BY(*g_mu) = nullptr;
+NoDestruct<std::shared_ptr<GrpcXdsBootstrap>> g_parsed_bootstrap
+    ABSL_GUARDED_BY(*g_mu);
 
-absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
+absl::StatusOr<std::string> FindBootstrapContents()
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(*g_mu) {
   // First, try GRPC_XDS_BOOTSTRAP env var.
   auto path = GetEnv("GRPC_XDS_BOOTSTRAP");
   if (path.has_value()) {
@@ -214,10 +217,10 @@ absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
     return std::move(*env_config);
   }
   // Finally, try fallback config.
-  if (fallback_config != nullptr) {
+  if (g_fallback_bootstrap_config != nullptr) {
     GRPC_TRACE_LOG(xds_client, INFO)
         << "Got bootstrap contents from fallback config";
-    return fallback_config;
+    return g_fallback_bootstrap_config;
   }
   // No bootstrap config found.
   return absl::FailedPreconditionError(
@@ -225,6 +228,22 @@ absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
       "not defined");
 }
 
+absl::StatusOr<std::shared_ptr<GrpcXdsBootstrap>> GetOrCreateGlobalBootstrap()
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(*g_mu) {
+  if (*g_parsed_bootstrap == nullptr) {
+    // First, find bootstrap contents.
+    auto bootstrap_contents = FindBootstrapContents();
+    if (!bootstrap_contents.ok()) return bootstrap_contents.status();
+    GRPC_TRACE_LOG(xds_client, INFO)
+        << "xDS bootstrap contents: " << *bootstrap_contents;
+    // Parse bootstrap.
+    auto bootstrap = GrpcXdsBootstrap::Create(*bootstrap_contents);
+    if (!bootstrap.ok()) return bootstrap.status();
+    *g_parsed_bootstrap = std::move(*bootstrap);
+  }
+  return *g_parsed_bootstrap;
+}
+
 std::shared_ptr<GlobalStatsPluginRegistry::StatsPluginGroup>
 GetStatsPluginGroupForKeyAndChannelArgs(absl::string_view key,
                                         const ChannelArgs& channel_args) {
@@ -245,7 +264,8 @@ GetStatsPluginGroupForKeyAndChannelArgs(absl::string_view key,
 }  // namespace
 
 absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
-    absl::string_view key, const ChannelArgs& args, const char* reason) {
+    absl::string_view key, const ChannelArgs& args, const char* reason,
+    std::shared_ptr<GrpcXdsBootstrap> bootstrap_override) {
   // If getting bootstrap from channel args, create a local XdsClient
   // instance for the channel or server instead of using the global instance.
   std::optional<absl::string_view> bootstrap_config = args.GetString(
@@ -273,19 +293,16 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
       return xds_client.TakeAsSubclass<GrpcXdsClient>();
     }
   }
-  // It doesn't exist, so we'll create it.
-  // First, find bootstrap contents.
-  auto bootstrap_contents = GetBootstrapContents(g_fallback_bootstrap_config);
-  if (!bootstrap_contents.ok()) return bootstrap_contents.status();
-  GRPC_TRACE_LOG(xds_client, INFO)
-      << "xDS bootstrap contents: " << *bootstrap_contents;
-  // Parse bootstrap.
-  auto bootstrap = GrpcXdsBootstrap::Create(*bootstrap_contents);
-  if (!bootstrap.ok()) return bootstrap.status();
-  // Instantiate XdsClient.
+  // The XdsClient doesn't exist, so we'll create it.
+  std::shared_ptr<GrpcXdsBootstrap> bootstrap = std::move(bootstrap_override);
+  if (bootstrap == nullptr) {
+    auto global_bootstrap = GetOrCreateGlobalBootstrap();
+    if (!global_bootstrap.ok()) return global_bootstrap.status();
+    bootstrap = std::move(*global_bootstrap);
+  }
   auto channel_args = ChannelArgs::FromC(g_channel_args);
   auto xds_client = MakeRefCounted<GrpcXdsClient>(
-      key, std::move(*bootstrap), channel_args,
+      key, std::move(bootstrap), channel_args,
       MakeRefCounted<GrpcXdsTransportFactory>(channel_args),
       GetStatsPluginGroupForKeyAndChannelArgs(key, args));
   g_xds_client_map->emplace(xds_client->key(), xds_client.get());
@@ -347,6 +364,7 @@ void GrpcXdsClient::Orphaned() {
   auto it = g_xds_client_map->find(key_);
   if (it != g_xds_client_map->end() && it->second == this) {
     g_xds_client_map->erase(it);
+    if (g_xds_client_map->empty()) g_parsed_bootstrap->reset();
   }
 }
 
@@ -430,6 +448,7 @@ void SetXdsChannelArgsForTest(grpc_channel_args* args) {
 void UnsetGlobalXdsClientsForTest() {
   MutexLock lock(g_mu);
   g_xds_client_map->clear();
+  g_parsed_bootstrap->reset();
 }
 
 void SetXdsFallbackBootstrapConfig(const char* config) {

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

@@ -45,8 +45,11 @@ class GrpcXdsClient final : public XdsClient {
   static constexpr absl::string_view kServerKey = "#server";
 
   // Factory function to get or create the global XdsClient instance.
+  // If bootstrap_override is null, the default bootstrap is used based
+  // on environment variables, channel args, etc.
   static absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GetOrCreate(
-      absl::string_view key, const ChannelArgs& args, const char* reason);
+      absl::string_view key, const ChannelArgs& args, const char* reason,
+      std::shared_ptr<GrpcXdsBootstrap> bootstrap_override = nullptr);
 
   // Do not instantiate directly -- use GetOrCreate() instead.
   // TODO(roth): The transport factory is injectable here to support