grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

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

@@ -23,10 +23,8 @@
 
 #include <algorithm>
 
-#include "absl/memory/memory.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
@@ -58,7 +56,6 @@
 namespace grpc_core {
 
 using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::GetDefaultEventEngine;
 
 TraceFlag grpc_xds_client_trace(false, "xds_client");
 TraceFlag grpc_xds_client_refcount_trace(false, "xds_client_refcount");
@@ -180,10 +177,45 @@ class XdsClient::ChannelState::AdsCallState
       Unref(DEBUG_LOCATION, "Orphan");
     }
 
+    void MarkSubscriptionSendStarted()
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
+      subscription_sent_ = true;
+    }
+
+    void MaybeMarkSubscriptionSendComplete(
+        RefCountedPtr<AdsCallState> ads_calld)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
+      if (subscription_sent_) MaybeStartTimer(std::move(ads_calld));
+    }
+
+    void MarkSeen() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
+      resource_seen_ = true;
+      MaybeCancelTimer();
+    }
+
+    void MaybeCancelTimer() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
+      if (timer_handle_.has_value() &&
+          ads_calld_->xds_client()->engine()->Cancel(*timer_handle_)) {
+        timer_handle_.reset();
+      }
+    }
+
+   private:
     void MaybeStartTimer(RefCountedPtr<AdsCallState> ads_calld)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
-      if (!timer_start_needed_) return;
-      timer_start_needed_ = false;
+      // Don't start timer if we've already either seen the resource or
+      // marked it as non-existing.
+      // Note: There are edge cases where we can have seen the resource
+      // before we have sent the initial subscription request, such as
+      // when we unsubscribe and then resubscribe to a given resource
+      // and then get a response containing that resource, all while a
+      // send_message op is in flight.
+      if (resource_seen_) return;
+      // Don't start timer if we haven't yet sent the initial subscription
+      // request for the resource.
+      if (!subscription_sent_) return;
+      // Don't start timer if it's already running.
+      if (timer_handle_.has_value()) return;
       // Check if we already have a cached version of this resource
       // (i.e., if this is the initial request for the resource after an
       // ADS stream restart).  If so, we don't start the timer, because
@@ -195,7 +227,7 @@ class XdsClient::ChannelState::AdsCallState
       if (state.resource != nullptr) return;
       // Start timer.
       ads_calld_ = std::move(ads_calld);
-      timer_handle_ = GetDefaultEventEngine()->RunAfter(
+      timer_handle_ = ads_calld_->xds_client()->engine()->RunAfter(
           ads_calld_->xds_client()->request_timeout_,
           [self = Ref(DEBUG_LOCATION, "timer")]() {
             ApplicationCallbackExecCtx callback_exec_ctx;
@@ -204,49 +236,28 @@ class XdsClient::ChannelState::AdsCallState
           });
     }
 
-    void MaybeCancelTimer() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
-      // If the timer hasn't been started yet, make sure we don't start
-      // it later.  This can happen if the last watch for an LDS or CDS
-      // resource is cancelled and then restarted, both while an ADS
-      // request for a different resource type is being sent (causing
-      // the unsubscription and then resubscription requests to be
-      // queued), and then we get a response for the LDS or CDS resource.
-      // In that case, we would call MaybeCancelTimer() when we receive the
-      // response and then MaybeStartTimer() when we finally send the new
-      // LDS or CDS request, thus causing the timer to fire when it shouldn't.
-      // For details, see https://github.com/grpc/grpc/issues/29583.
-      // TODO(roth): Find a way to write a test for this case.
-      timer_start_needed_ = false;
-      if (timer_handle_.has_value()) {
-        GetDefaultEventEngine()->Cancel(*timer_handle_);
-        timer_handle_.reset();
-      }
-    }
-
-   private:
     void OnTimer() {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+        gpr_log(GPR_INFO,
+                "[xds_client %p] xds server %s: timeout obtaining resource "
+                "{type=%s name=%s} from xds server",
+                ads_calld_->xds_client(),
+                ads_calld_->chand()->server_.server_uri().c_str(),
+                std::string(type_->type_url()).c_str(),
+                XdsClient::ConstructFullXdsResourceName(
+                    name_.authority, type_->type_url(), name_.key)
+                    .c_str());
+      }
       {
         MutexLock lock(&ads_calld_->xds_client()->mu_);
-        if (timer_handle_.has_value()) {
-          timer_handle_.reset();
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-            gpr_log(GPR_INFO,
-                    "[xds_client %p] xds server %s: timeout obtaining resource "
-                    "{type=%s name=%s} from xds server",
-                    ads_calld_->xds_client(),
-                    ads_calld_->chand()->server_.server_uri().c_str(),
-                    std::string(type_->type_url()).c_str(),
-                    XdsClient::ConstructFullXdsResourceName(
-                        name_.authority, type_->type_url(), name_.key)
-                        .c_str());
-          }
-          auto& authority_state =
-              ads_calld_->xds_client()->authority_state_map_[name_.authority];
-          ResourceState& state = authority_state.resource_map[type_][name_.key];
-          state.meta.client_status = XdsApi::ResourceMetadata::DOES_NOT_EXIST;
-          ads_calld_->xds_client()->NotifyWatchersOnResourceDoesNotExist(
-              state.watchers);
-        }
+        timer_handle_.reset();
+        resource_seen_ = true;
+        auto& authority_state =
+            ads_calld_->xds_client()->authority_state_map_[name_.authority];
+        ResourceState& state = authority_state.resource_map[type_][name_.key];
+        state.meta.client_status = XdsApi::ResourceMetadata::DOES_NOT_EXIST;
+        ads_calld_->xds_client()->NotifyWatchersOnResourceDoesNotExist(
+            state.watchers);
       }
       ads_calld_->xds_client()->work_serializer_.DrainQueue();
       ads_calld_.reset();
@@ -256,7 +267,13 @@ class XdsClient::ChannelState::AdsCallState
     const XdsResourceName name_;
 
     RefCountedPtr<AdsCallState> ads_calld_;
-    bool timer_start_needed_ ABSL_GUARDED_BY(&XdsClient::mu_) = true;
+    // True if we have sent the initial subscription request for this
+    // resource on this ADS stream.
+    bool subscription_sent_ ABSL_GUARDED_BY(&XdsClient::mu_) = false;
+    // True if we have either (a) seen the resource in a response on this
+    // stream or (b) declared the resource to not exist due to the timer
+    // firing.
+    bool resource_seen_ ABSL_GUARDED_BY(&XdsClient::mu_) = false;
     absl::optional<EventEngine::TaskHandle> timer_handle_
         ABSL_GUARDED_BY(&XdsClient::mu_);
   };
@@ -311,7 +328,9 @@ class XdsClient::ChannelState::AdsCallState
 
   bool sent_initial_message_ = false;
   bool seen_response_ = false;
-  bool send_message_pending_ ABSL_GUARDED_BY(&XdsClient::mu_) = false;
+
+  const XdsResourceType* send_message_pending_
+      ABSL_GUARDED_BY(&XdsClient::mu_) = nullptr;
 
   // Resource types for which requests need to be sent.
   std::set<const XdsResourceType*> buffered_requests_;
@@ -592,7 +611,7 @@ void XdsClient::ChannelState::RetryableCall<T>::Orphan() {
   shutting_down_ = true;
   calld_.reset();
   if (timer_handle_.has_value()) {
-    GetDefaultEventEngine()->Cancel(*timer_handle_);
+    chand()->xds_client()->engine()->Cancel(*timer_handle_);
     timer_handle_.reset();
   }
   this->Unref(DEBUG_LOCATION, "RetryableCall+orphaned");
@@ -635,7 +654,7 @@ void XdsClient::ChannelState::RetryableCall<T>::StartRetryTimerLocked() {
             chand()->xds_client(), chand()->server_.server_uri().c_str(),
             timeout.millis());
   }
-  timer_handle_ = GetDefaultEventEngine()->RunAfter(
+  timer_handle_ = chand()->xds_client()->engine()->RunAfter(
       timeout,
       [self = this->Ref(DEBUG_LOCATION, "RetryableCall+retry_timer_start")]() {
         ApplicationCallbackExecCtx callback_exec_ctx;
@@ -722,8 +741,7 @@ void XdsClient::ChannelState::AdsCallState::AdsResponseParser::ParseResource(
       "resource index ", idx, ": ",
       resource_name.empty() ? "" : absl::StrCat(resource_name, ": "));
   // Check the type_url of the resource.
-  bool is_v2 = false;
-  if (!result_.type->IsType(type_url, &is_v2)) {
+  if (result_.type_url != type_url) {
     result_.errors.emplace_back(
         absl::StrCat(error_prefix, "incorrect resource type ", type_url,
                      " (should be ", result_.type_url, ")"));
@@ -734,7 +752,7 @@ void XdsClient::ChannelState::AdsCallState::AdsResponseParser::ParseResource(
       xds_client(), ads_call_state_->chand()->server_, &grpc_xds_client_trace,
       xds_client()->symtab_.ptr(), arena};
   XdsResourceType::DecodeResult decode_result =
-      result_.type->Decode(context, serialized_resource, is_v2);
+      result_.type->Decode(context, serialized_resource);
   // If we didn't already have the resource name from the Resource
   // wrapper, try to get it from the decoding result.
   if (resource_name.empty()) {
@@ -772,7 +790,7 @@ void XdsClient::ChannelState::AdsCallState::AdsResponseParser::ParseResource(
     if (it != timer_it->second.subscribed_resources.end()) {
       auto res_it = it->second.find(parsed_resource_name->key);
       if (res_it != it->second.end()) {
-        res_it->second->MaybeCancelTimer();
+        res_it->second->MarkSeen();
       }
     }
   }
@@ -875,13 +893,10 @@ XdsClient::ChannelState::AdsCallState::AdsCallState(
   GPR_ASSERT(xds_client() != nullptr);
   // Init the ADS call.
   const char* method =
-      chand()->server_.ShouldUseV3()
-          ? "/envoy.service.discovery.v3.AggregatedDiscoveryService/"
-            "StreamAggregatedResources"
-          : "/envoy.service.discovery.v2.AggregatedDiscoveryService/"
-            "StreamAggregatedResources";
+      "/envoy.service.discovery.v3.AggregatedDiscoveryService/"
+      "StreamAggregatedResources";
   call_ = chand()->transport_->CreateStreamingCall(
-      method, absl::make_unique<StreamEventHandler>(
+      method, std::make_unique<StreamEventHandler>(
                   // Passing the initial ref here.  This ref will go away when
                   // the StreamEventHandler is destroyed.
                   RefCountedPtr<AdsCallState>(this)));
@@ -926,15 +941,13 @@ void XdsClient::ChannelState::AdsCallState::SendMessageLocked(
     const XdsResourceType* type)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
   // Buffer message sending if an existing message is in flight.
-  if (send_message_pending_) {
+  if (send_message_pending_ != nullptr) {
     buffered_requests_.insert(type);
     return;
   }
   auto& state = state_map_[type];
   std::string serialized_message = xds_client()->api_.CreateAdsRequest(
-      chand()->server_,
-      chand()->server_.ShouldUseV3() ? type->type_url() : type->v2_type_url(),
-      chand()->resource_type_version_map_[type], state.nonce,
+      type->type_url(), chand()->resource_type_version_map_[type], state.nonce,
       ResourceNamesForRequest(type), state.status, !sent_initial_message_);
   sent_initial_message_ = true;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
@@ -948,7 +961,7 @@ void XdsClient::ChannelState::AdsCallState::SendMessageLocked(
   }
   state.status = absl::OkStatus();
   call_->SendMessage(std::move(serialized_message));
-  send_message_pending_ = true;
+  send_message_pending_ = type;
 }
 
 void XdsClient::ChannelState::AdsCallState::SubscribeLocked(
@@ -981,7 +994,18 @@ bool XdsClient::ChannelState::AdsCallState::HasSubscribedResources() const {
 
 void XdsClient::ChannelState::AdsCallState::OnRequestSent(bool ok) {
   MutexLock lock(&xds_client()->mu_);
-  send_message_pending_ = false;
+  // For each resource that was in the message we just sent, start the
+  // resource timer if needed.
+  if (ok) {
+    auto& resource_type_state = state_map_[send_message_pending_];
+    for (const auto& p : resource_type_state.subscribed_resources) {
+      for (auto& q : p.second) {
+        q.second->MaybeMarkSubscriptionSendComplete(
+            Ref(DEBUG_LOCATION, "ResourceTimer"));
+      }
+    }
+  }
+  send_message_pending_ = nullptr;
   if (ok && IsCurrentCallOnChannel()) {
     // Continue to send another pending message if any.
     // TODO(roth): The current code to handle buffered messages has the
@@ -1007,8 +1031,7 @@ void XdsClient::ChannelState::AdsCallState::OnRecvMessage(
     if (!IsCurrentCallOnChannel()) return;
     // Parse and validate the response.
     AdsResponseParser parser(this);
-    absl::Status status =
-        xds_client()->api_.ParseAdsResponse(chand()->server_, payload, &parser);
+    absl::Status status = xds_client()->api_.ParseAdsResponse(payload, &parser);
     if (!status.ok()) {
       // Ignore unparsable response.
       gpr_log(GPR_ERROR,
@@ -1076,6 +1099,8 @@ void XdsClient::ChannelState::AdsCallState::OnRecvMessage(
                 }
               } else {
                 resource_state.resource.reset();
+                resource_state.meta.client_status =
+                    XdsApi::ResourceMetadata::DOES_NOT_EXIST;
                 xds_client()->NotifyWatchersOnResourceDoesNotExist(
                     resource_state.watchers);
               }
@@ -1083,8 +1108,8 @@ void XdsClient::ChannelState::AdsCallState::OnRecvMessage(
           }
         }
       }
-      // If we had valid resources, update the version.
-      if (result.have_valid_resources) {
+      // If we had valid resources or the update was empty, update the version.
+      if (result.have_valid_resources || result.errors.empty()) {
         chand()->resource_type_version_map_[result.type] =
             std::move(result.version);
         // Start load reporting if needed.
@@ -1112,13 +1137,26 @@ void XdsClient::ChannelState::AdsCallState::OnStatusReceived(
               xds_client(), chand()->server_.server_uri().c_str(), chand(),
               this, call_.get(), status.ToString().c_str());
     }
+    // Cancel any does-not-exist timers that may be pending.
+    for (const auto& p : state_map_) {
+      for (const auto& q : p.second.subscribed_resources) {
+        for (auto& r : q.second) {
+          r.second->MaybeCancelTimer();
+        }
+      }
+    }
     // Ignore status from a stale call.
     if (IsCurrentCallOnChannel()) {
       // Try to restart the call.
       parent_->OnCallFinishedLocked();
-      // Send error to all watchers for the channel.
-      chand()->SetChannelStatusLocked(absl::UnavailableError(absl::StrFormat(
-          "xDS call failed; status: %s", status.ToString().c_str())));
+      // If we didn't receive a response on the stream, report the
+      // stream failure as a connectivity failure, which will report the
+      // error to all watchers of resources on this channel.
+      if (!seen_response_) {
+        chand()->SetChannelStatusLocked(absl::UnavailableError(
+            absl::StrCat("xDS call failed with no responses received; status: ",
+                         status.ToString())));
+      }
     }
   }
   xds_client()->work_serializer_.DrainQueue();
@@ -1144,7 +1182,7 @@ XdsClient::ChannelState::AdsCallState::ResourceNamesForRequest(
         resource_names.emplace_back(XdsClient::ConstructFullXdsResourceName(
             authority, type->type_url(), resource_key));
         OrphanablePtr<ResourceTimer>& resource_timer = p.second;
-        resource_timer->MaybeStartTimer(Ref(DEBUG_LOCATION, "ResourceTimer"));
+        resource_timer->MarkSubscriptionSendStarted();
       }
     }
   }
@@ -1157,7 +1195,7 @@ XdsClient::ChannelState::AdsCallState::ResourceNamesForRequest(
 
 void XdsClient::ChannelState::LrsCallState::Reporter::Orphan() {
   if (timer_handle_.has_value() &&
-      GetDefaultEventEngine()->Cancel(*timer_handle_)) {
+      xds_client()->engine()->Cancel(*timer_handle_)) {
     timer_handle_.reset();
     Unref(DEBUG_LOCATION, "Orphan");
   }
@@ -1165,7 +1203,7 @@ void XdsClient::ChannelState::LrsCallState::Reporter::Orphan() {
 
 void XdsClient::ChannelState::LrsCallState::Reporter::
     ScheduleNextReportLocked() {
-  timer_handle_ = GetDefaultEventEngine()->RunAfter(report_interval_, [this]() {
+  timer_handle_ = xds_client()->engine()->RunAfter(report_interval_, [this]() {
     ApplicationCallbackExecCtx callback_exec_ctx;
     ExecCtx exec_ctx;
     if (OnNextReportTimer()) {
@@ -1264,13 +1302,10 @@ XdsClient::ChannelState::LrsCallState::LrsCallState(
   // activity in xds_client()->interested_parties_, which is comprised of
   // the polling entities from client_channel.
   GPR_ASSERT(xds_client() != nullptr);
-  const char* method = chand()->server_.ShouldUseV3()
-                           ? "/envoy.service.load_stats.v3."
-                             "LoadReportingService/StreamLoadStats"
-                           : "/envoy.service.load_stats.v2."
-                             "LoadReportingService/StreamLoadStats";
+  const char* method =
+      "/envoy.service.load_stats.v3.LoadReportingService/StreamLoadStats";
   call_ = chand()->transport_->CreateStreamingCall(
-      method, absl::make_unique<StreamEventHandler>(
+      method, std::make_unique<StreamEventHandler>(
                   // Passing the initial ref here.  This ref will go away when
                   // the StreamEventHandler is destroyed.
                   RefCountedPtr<LrsCallState>(this)));
@@ -1284,8 +1319,7 @@ XdsClient::ChannelState::LrsCallState::LrsCallState(
             call_.get());
   }
   // Send the initial request.
-  std::string serialized_payload =
-      xds_client()->api_.CreateLrsInitialRequest(chand()->server_);
+  std::string serialized_payload = xds_client()->api_.CreateLrsInitialRequest();
   call_->SendMessage(std::move(serialized_payload));
   send_message_pending_ = true;
 }
@@ -1436,7 +1470,8 @@ XdsClient::XdsClient(std::unique_ptr<XdsBootstrap> bootstrap,
       transport_factory_(std::move(transport_factory)),
       request_timeout_(resource_request_timeout),
       xds_federation_enabled_(XdsFederationEnabled()),
-      api_(this, &grpc_xds_client_trace, bootstrap_->node(), &symtab_) {
+      api_(this, &grpc_xds_client_trace, bootstrap_->node(), &symtab_),
+      engine_(grpc_event_engine::experimental::GetDefaultEventEngine()) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO, "[xds_client %p] creating xds client", this);
   }
@@ -1654,16 +1689,13 @@ void XdsClient::MaybeRegisterResourceTypeLocked(
     return;
   }
   resource_types_.emplace(resource_type->type_url(), resource_type);
-  v2_resource_types_.emplace(resource_type->v2_type_url(), resource_type);
-  resource_type->InitUpbSymtab(symtab_.ptr());
+  resource_type->InitUpbSymtab(this, symtab_.ptr());
 }
 
 const XdsResourceType* XdsClient::GetResourceTypeLocked(
     absl::string_view resource_type) {
   auto it = resource_types_.find(resource_type);
   if (it != resource_types_.end()) return it->second;
-  auto it2 = v2_resource_types_.find(resource_type);
-  if (it2 != v2_resource_types_.end()) return it2->second;
   return nullptr;
 }
 
@@ -1681,7 +1713,7 @@ absl::StatusOr<XdsClient::XdsResourceName> XdsClient::ParseXdsResourceName(
   // Split the resource type off of the path to get the id.
   std::pair<absl::string_view, absl::string_view> path_parts = absl::StrSplit(
       absl::StripPrefix(uri->path(), "/"), absl::MaxSplits('/', 1));
-  if (!type->IsType(path_parts.first, nullptr)) {
+  if (type->type_url() != path_parts.first) {
     return absl::InvalidArgumentError(
         "xdstp URI path must indicate valid xDS resource type");
   }

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

@@ -32,6 +32,8 @@
 #include "absl/strings/string_view.h"
 #include "upb/def.hpp"
 
+#include <grpc/event_engine/event_engine.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"
@@ -143,6 +145,10 @@ class XdsClient : public DualRefCounted<XdsClient> {
   // implementation.
   std::string DumpClientConfigBinary();
 
+  grpc_event_engine::experimental::EventEngine* engine() {
+    return engine_.get();
+  }
+
  private:
   struct XdsResourceKey {
     std::string id;
@@ -301,14 +307,13 @@ class XdsClient : public DualRefCounted<XdsClient> {
   const bool xds_federation_enabled_;
   XdsApi api_;
   WorkSerializer work_serializer_;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> engine_;
 
   Mutex mu_;
 
   // Stores resource type objects seen by type URL.
   std::map<absl::string_view /*resource_type*/, const XdsResourceType*>
       resource_types_ ABSL_GUARDED_BY(mu_);
-  std::map<absl::string_view /*v2_resource_type*/, const XdsResourceType*>
-      v2_resource_types_ ABSL_GUARDED_BY(mu_);
   upb::SymbolTable symtab_ ABSL_GUARDED_BY(mu_);
 
   // Map of existing xDS server channels.

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

@@ -37,8 +37,6 @@
 #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_cluster_specifier_plugin.h"
-#include "src/core/ext/xds/xds_http_filters.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"
@@ -52,8 +50,8 @@
 #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/slice/slice_refcount.h"
 #include "src/core/lib/transport/error_utils.h"
 
 namespace grpc_core {
@@ -64,30 +62,13 @@ namespace grpc_core {
 
 namespace {
 
-Mutex* g_mu = nullptr;
+Mutex* g_mu = new Mutex;
 const grpc_channel_args* g_channel_args ABSL_GUARDED_BY(*g_mu) = nullptr;
 GrpcXdsClient* g_xds_client ABSL_GUARDED_BY(*g_mu) = nullptr;
 char* g_fallback_bootstrap_config ABSL_GUARDED_BY(*g_mu) = nullptr;
 
 }  // namespace
 
-void XdsClientGlobalInit() {
-  g_mu = new Mutex;
-  XdsHttpFilterRegistry::Init();
-  XdsClusterSpecifierPluginRegistry::Init();
-}
-
-// TODO(roth): Find a better way to clear the fallback config that does
-// not require using ABSL_NO_THREAD_SAFETY_ANALYSIS.
-void XdsClientGlobalShutdown() ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  gpr_free(g_fallback_bootstrap_config);
-  g_fallback_bootstrap_config = nullptr;
-  delete g_mu;
-  g_mu = nullptr;
-  XdsHttpFilterRegistry::Shutdown();
-  XdsClusterSpecifierPluginRegistry::Shutdown();
-}
-
 namespace {
 
 absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
@@ -103,9 +84,9 @@ absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
     grpc_slice contents;
     grpc_error_handle error =
         grpc_load_file(path->c_str(), /*add_null_terminator=*/true, &contents);
-    if (!GRPC_ERROR_IS_NONE(error)) return grpc_error_to_absl_status(error);
+    if (!error.ok()) return grpc_error_to_absl_status(error);
     std::string contents_str(StringViewFromSlice(contents));
-    grpc_slice_unref_internal(contents);
+    CSliceUnref(contents);
     return contents_str;
   }
   // Next, try GRPC_XDS_BOOTSTRAP_CONFIG env var.
@@ -218,7 +199,7 @@ void SetXdsFallbackBootstrapConfig(const char* config) {
 grpc_slice grpc_dump_xds_configs(void) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   auto xds_client = grpc_core::GrpcXdsClient::GetOrCreate(
       grpc_core::ChannelArgs(), "grpc_dump_xds_configs()");
   if (!xds_client.ok()) {