grpc 1.58.3 → 1.59.0

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

@@ -150,7 +150,8 @@ class XdsServerConfigFetcher::ListenerWatcher
     xds_client_.reset(DEBUG_LOCATION, "ListenerWatcher");
   }
 
-  void OnResourceChanged(XdsListenerResource listener) override;
+  void OnResourceChanged(
+      std::shared_ptr<const XdsListenerResource> listener) override;
 
   void OnError(absl::Status status) override;
 
@@ -236,7 +237,9 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
   class RouteConfigWatcher;
   struct RdsUpdateState {
     RouteConfigWatcher* watcher;
-    absl::optional<absl::StatusOr<XdsRouteConfigResource>> rds_update;
+    absl::optional<
+        absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>>
+        rds_update;
   };
 
   class XdsServerConfigSelector;
@@ -249,8 +252,9 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
 
   // Helper functions invoked by RouteConfigWatcher when there are updates to
   // RDS resources.
-  void OnRouteConfigChanged(const std::string& resource_name,
-                            XdsRouteConfigResource route_config);
+  void OnRouteConfigChanged(
+      const std::string& resource_name,
+      std::shared_ptr<const XdsRouteConfigResource> route_config);
   void OnError(const std::string& resource_name, absl::Status status);
   void OnResourceDoesNotExist(const std::string& resource_name);
 
@@ -258,6 +262,9 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
   // This ref is only kept around till the FilterChainMatchManager becomes
   // ready.
   RefCountedPtr<ListenerWatcher> listener_watcher_;
+  // TODO(roth): Consider holding a ref to the LDS resource and storing
+  // a pointer to the filter chain data within that LDS resource, rather
+  // than copying the filter chain data here.
   XdsListenerResource::FilterChainMap filter_chain_map_;
   absl::optional<XdsListenerResource::FilterChainData> default_filter_chain_;
   Mutex mu_;
@@ -284,7 +291,8 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       : resource_name_(std::move(resource_name)),
         filter_chain_match_manager_(std::move(filter_chain_match_manager)) {}
 
-  void OnResourceChanged(XdsRouteConfigResource route_config) override {
+  void OnResourceChanged(
+      std::shared_ptr<const XdsRouteConfigResource> route_config) override {
     filter_chain_match_manager_->OnRouteConfigChanged(resource_name_,
                                                       std::move(route_config));
   }
@@ -311,7 +319,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
  public:
   static absl::StatusOr<RefCountedPtr<XdsServerConfigSelector>> Create(
       const XdsHttpFilterRegistry& http_filter_registry,
-      XdsRouteConfigResource rds_update,
+      std::shared_ptr<const XdsRouteConfigResource> rds_update,
       const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
           http_filters);
   ~XdsServerConfigSelector() override = default;
@@ -324,6 +332,9 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     struct Route {
       // true if an action other than kNonForwardingAction is configured.
       bool unsupported_action;
+      // TODO(roth): Consider holding a ref to the RDS resource and storing
+      // a pointer to the matchers within that RDS resource, rather than
+      // copying the matchers here.
       XdsRouteConfigResource::Route::Matchers matchers;
       RefCountedPtr<ServiceConfig> method_config;
     };
@@ -376,7 +387,8 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
  public:
   StaticXdsServerConfigSelectorProvider(
       RefCountedPtr<GrpcXdsClient> xds_client,
-      absl::StatusOr<XdsRouteConfigResource> static_resource,
+      absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+          static_resource,
       std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>
           http_filters)
       : xds_client_(std::move(xds_client)),
@@ -407,7 +419,11 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 
  private:
   RefCountedPtr<GrpcXdsClient> xds_client_;
-  absl::StatusOr<XdsRouteConfigResource> static_resource_;
+  absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+      static_resource_;
+  // TODO(roth): Consider holding a ref to the LDS resource and storing
+  // a pointer to the HTTP filters within that LDS resource, rather than
+  // copying the HTTP filters here.
   std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>
       http_filters_;
   std::unique_ptr<ServerConfigSelectorProvider::ServerConfigSelectorWatcher>
@@ -422,7 +438,8 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
  public:
   DynamicXdsServerConfigSelectorProvider(
       RefCountedPtr<GrpcXdsClient> xds_client, std::string resource_name,
-      absl::StatusOr<XdsRouteConfigResource> initial_resource,
+      absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+          initial_resource,
       std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>
           http_filters);
 
@@ -440,19 +457,24 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
  private:
   class RouteConfigWatcher;
 
-  void OnRouteConfigChanged(XdsRouteConfigResource rds_update);
+  void OnRouteConfigChanged(
+      std::shared_ptr<const XdsRouteConfigResource> rds_update);
   void OnError(absl::Status status);
   void OnResourceDoesNotExist();
 
   RefCountedPtr<GrpcXdsClient> xds_client_;
   std::string resource_name_;
+  // TODO(roth): Consider holding a ref to the LDS resource and storing
+  // a pointer to the HTTP filters within that LDS resource, rather than
+  // copying the HTTP filters here.
   std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>
       http_filters_;
   RouteConfigWatcher* route_config_watcher_ = nullptr;
   Mutex mu_;
   std::unique_ptr<ServerConfigSelectorProvider::ServerConfigSelectorWatcher>
       watcher_ ABSL_GUARDED_BY(mu_);
-  absl::StatusOr<XdsRouteConfigResource> resource_ ABSL_GUARDED_BY(mu_);
+  absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>> resource_
+      ABSL_GUARDED_BY(mu_);
 };
 
 // A watcher implementation for updating the RDS resource used by
@@ -465,7 +487,8 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       WeakRefCountedPtr<DynamicXdsServerConfigSelectorProvider> parent)
       : parent_(std::move(parent)) {}
 
-  void OnResourceChanged(XdsRouteConfigResource route_config) override {
+  void OnResourceChanged(
+      std::shared_ptr<const XdsRouteConfigResource> route_config) override {
     parent_->OnRouteConfigChanged(std::move(route_config));
   }
 
@@ -551,14 +574,14 @@ XdsServerConfigFetcher::ListenerWatcher::ListenerWatcher(
       listening_address_(std::move(listening_address)) {}
 
 void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
-    XdsListenerResource listener) {
+    std::shared_ptr<const XdsListenerResource> listener) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_server_config_fetcher_trace)) {
     gpr_log(GPR_INFO,
             "[ListenerWatcher %p] Received LDS update from xds client %p: %s",
-            this, xds_client_.get(), listener.ToString().c_str());
+            this, xds_client_.get(), listener->ToString().c_str());
   }
   auto* tcp_listener =
-      absl::get_if<XdsListenerResource::TcpListener>(&listener.listener);
+      absl::get_if<XdsListenerResource::TcpListener>(&listener->listener);
   if (tcp_listener == nullptr) {
     MutexLock lock(&mu_);
     OnFatalError(
@@ -573,8 +596,7 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
   }
   auto new_filter_chain_match_manager = MakeRefCounted<FilterChainMatchManager>(
       xds_client_->Ref(DEBUG_LOCATION, "FilterChainMatchManager"),
-      std::move(tcp_listener->filter_chain_map),
-      std::move(tcp_listener->default_filter_chain));
+      tcp_listener->filter_chain_map, tcp_listener->default_filter_chain);
   MutexLock lock(&mu_);
   if (filter_chain_match_manager_ == nullptr ||
       !(new_filter_chain_match_manager->filter_chain_map() ==
@@ -824,8 +846,9 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    OnRouteConfigChanged(const std::string& resource_name,
-                         XdsRouteConfigResource route_config) {
+    OnRouteConfigChanged(
+        const std::string& resource_name,
+        std::shared_ptr<const XdsRouteConfigResource> route_config) {
   RefCountedPtr<ListenerWatcher> listener_watcher;
   {
     MutexLock lock(&mu_);
@@ -1091,7 +1114,8 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
       filter_chain->http_connection_manager.route_config,
       // RDS resource name
       [&](const std::string& rds_name) {
-        absl::StatusOr<XdsRouteConfigResource> initial_resource;
+        absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+            initial_resource;
         {
           MutexLock lock(&mu_);
           initial_resource = rds_map_[rds_name].rds_update.value();
@@ -1104,7 +1128,7 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
                 filter_chain->http_connection_manager.http_filters);
       },
       // inline RouteConfig
-      [&](const XdsRouteConfigResource& route_config) {
+      [&](const std::shared_ptr<const XdsRouteConfigResource>& route_config) {
         server_config_selector_provider =
             MakeRefCounted<StaticXdsServerConfigSelectorProvider>(
                 xds_client_->Ref(DEBUG_LOCATION,
@@ -1140,19 +1164,19 @@ absl::StatusOr<
 XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     XdsServerConfigSelector::Create(
         const XdsHttpFilterRegistry& http_filter_registry,
-        XdsRouteConfigResource rds_update,
+        std::shared_ptr<const XdsRouteConfigResource> rds_update,
         const std::vector<
             XdsListenerResource::HttpConnectionManager::HttpFilter>&
             http_filters) {
   auto config_selector = MakeRefCounted<XdsServerConfigSelector>();
-  for (auto& vhost : rds_update.virtual_hosts) {
+  for (auto& vhost : rds_update->virtual_hosts) {
     config_selector->virtual_hosts_.emplace_back();
     auto& virtual_host = config_selector->virtual_hosts_.back();
-    virtual_host.domains = std::move(vhost.domains);
+    virtual_host.domains = vhost.domains;
     for (auto& route : vhost.routes) {
       virtual_host.routes.emplace_back();
       auto& config_selector_route = virtual_host.routes.back();
-      config_selector_route.matchers = std::move(route.matchers);
+      config_selector_route.matchers = route.matchers;
       config_selector_route.unsupported_action =
           absl::get_if<XdsRouteConfigResource::Route::NonForwardingAction>(
               &route.action) == nullptr;
@@ -1234,7 +1258,8 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     DynamicXdsServerConfigSelectorProvider::
         DynamicXdsServerConfigSelectorProvider(
             RefCountedPtr<GrpcXdsClient> xds_client, std::string resource_name,
-            absl::StatusOr<XdsRouteConfigResource> initial_resource,
+            absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+                initial_resource,
             std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>
                 http_filters)
     : xds_client_(std::move(xds_client)),
@@ -1264,7 +1289,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
         std::unique_ptr<
             ServerConfigSelectorProvider::ServerConfigSelectorWatcher>
             watcher) {
-  absl::StatusOr<XdsRouteConfigResource> resource;
+  absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>> resource;
   {
     MutexLock lock(&mu_);
     GPR_ASSERT(watcher_ == nullptr);
@@ -1288,7 +1313,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     DynamicXdsServerConfigSelectorProvider::OnRouteConfigChanged(
-        XdsRouteConfigResource rds_update) {
+        std::shared_ptr<const XdsRouteConfigResource> rds_update) {
   MutexLock lock(&mu_);
   resource_ = std::move(rds_update);
   if (watcher_ == nullptr) {

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

@@ -28,6 +28,7 @@
 
 #include <grpc/byte_buffer.h>
 #include <grpc/byte_buffer_reader.h>
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
@@ -42,11 +43,13 @@
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -302,7 +305,14 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::Orphan() {
     GPR_ASSERT(client_channel != nullptr);
     client_channel->RemoveConnectivityWatcher(watcher_);
   }
-  Unref();
+  // Do an async hop before unreffing.  This avoids a deadlock upon
+  // shutdown in the case where the xDS channel is itself an xDS channel
+  // (e.g., when using one control plane to find another control plane).
+  grpc_event_engine::experimental::GetDefaultEventEngine()->Run([this]() {
+    ApplicationCallbackExecCtx application_exec_ctx;
+    ExecCtx exec_ctx;
+    Unref();
+  });
 }
 
 OrphanablePtr<XdsTransportFactory::XdsTransport::StreamingCall>

data/src/core/lib/backoff/random_early_detection.cc

@@ -16,12 +16,14 @@
 
 #include "src/core/lib/backoff/random_early_detection.h"
 
+#include "absl/random/distributions.h"
+
 namespace grpc_core {
 
-bool RandomEarlyDetection::Reject(uint64_t size) {
+bool RandomEarlyDetection::Reject(uint64_t size, absl::BitGenRef bitsrc) const {
   if (size <= soft_limit_) return false;
   if (size < hard_limit_) {
-    return absl::Bernoulli(bitgen_,
+    return absl::Bernoulli(bitsrc,
                            static_cast<double>(size - soft_limit_) /
                                static_cast<double>(hard_limit_ - soft_limit_));
   }

data/src/core/lib/backoff/random_early_detection.h

@@ -21,7 +21,7 @@
 
 #include <cstdint>
 
-#include "absl/random/random.h"
+#include "absl/random/bit_gen_ref.h"
 
 namespace grpc_core {
 
@@ -38,7 +38,7 @@ class RandomEarlyDetection {
   bool MustReject(uint64_t size) { return size >= hard_limit_; }
 
   // Returns true if the item should be rejected.
-  bool Reject(uint64_t size);
+  bool Reject(uint64_t size, absl::BitGenRef bitsrc) const;
 
   uint64_t soft_limit() const { return soft_limit_; }
   uint64_t hard_limit() const { return hard_limit_; }
@@ -55,8 +55,6 @@ class RandomEarlyDetection {
   uint64_t soft_limit_;
   // The hard limit is the size at which we reject all items.
   uint64_t hard_limit_;
-  // The bit generator used to generate random numbers.
-  absl::InsecureBitGen bitgen_;
 };
 
 }  // namespace grpc_core

data/src/core/lib/channel/call_tracer.cc

@@ -46,7 +46,13 @@ ServerCallTracerFactory* ServerCallTracerFactory::Get(
     const ChannelArgs& channel_args) {
   ServerCallTracerFactory* factory =
       channel_args.GetObject<ServerCallTracerFactory>();
-  return factory != nullptr ? factory : g_server_call_tracer_factory_;
+  if (factory == nullptr) {
+    factory = g_server_call_tracer_factory_;
+  }
+  if (factory && factory->IsServerTraced(channel_args)) {
+    return factory;
+  }
+  return nullptr;
 }
 
 void ServerCallTracerFactory::RegisterGlobal(ServerCallTracerFactory* factory) {

data/src/core/lib/channel/call_tracer.h

@@ -139,7 +139,7 @@ class ClientCallTracer : public CallTracerAnnotationInterface {
 
   // Records a new attempt for the associated call. \a transparent denotes
   // whether the attempt is being made as a transparent retry or as a
-  // non-transparent retry/heding attempt. (There will be at least one attempt
+  // non-transparent retry/hedging attempt. (There will be at least one attempt
   // even if the call is not being retried.) The `ClientCallTracer` object
   // retains ownership to the newly created `CallAttemptTracer` object.
   // RecordEnd() serves as an indication that the call stack is done with all
@@ -170,6 +170,9 @@ class ServerCallTracerFactory {
 
   virtual ServerCallTracer* CreateNewServerCallTracer(Arena* arena) = 0;
 
+  // Returns true if a server is to be traced, false otherwise.
+  virtual bool IsServerTraced(const ChannelArgs& /*args*/) { return true; }
+
   // Use this method to get the server call tracer factory from channel args,
   // instead of directly fetching it with `GetObject`.
   static ServerCallTracerFactory* Get(const ChannelArgs& channel_args);

data/src/core/lib/channel/channelz_registry.h

@@ -25,6 +25,8 @@
 #include <map>
 #include <string>
 
+#include "absl/base/thread_annotations.h"
+
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -90,8 +92,8 @@ class ChannelzRegistry {
 
   // protects members
   Mutex mu_;
-  std::map<intptr_t, BaseNode*> node_map_;
-  intptr_t uuid_generator_ = 0;
+  std::map<intptr_t, BaseNode*> node_map_ ABSL_GUARDED_BY(mu_);
+  intptr_t uuid_generator_ ABSL_GUARDED_BY(mu_) = 0;
 };
 
 }  // namespace channelz

data/src/core/lib/channel/connected_channel.cc

@@ -548,7 +548,7 @@ ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(
         }
         if (!done_recv_messages) {
           auto p = recv_messages();
-          if (auto* r = p.value_if_ready()) {
+          if (p.ready()) {
             // NOTE: ignore errors here, they'll be collected in the
             // recv_trailing_metadata.
             done_recv_messages = true;

data/src/core/lib/config/config_vars.h

@@ -31,7 +31,7 @@
 
 namespace grpc_core {
 
-class ConfigVars {
+class GPR_DLL ConfigVars {
  public:
   struct Overrides {
     absl::optional<int32_t> client_channel_backup_poll_interval_ms;

data/src/core/lib/config/core_configuration.cc

@@ -49,7 +49,8 @@ CoreConfiguration::CoreConfiguration(Builder* builder)
       certificate_provider_registry_(
           builder->certificate_provider_registry_.Build()) {}
 
-void CoreConfiguration::RegisterBuilder(std::function<void(Builder*)> builder) {
+void CoreConfiguration::RegisterBuilder(
+    absl::AnyInvocable<void(Builder*)> builder) {
   GPR_ASSERT(config_.load(std::memory_order_relaxed) == nullptr &&
              "CoreConfiguration was already instantiated before builder "
              "registration was completed");

data/src/core/lib/config/core_configuration.h

@@ -18,7 +18,8 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
-#include <functional>
+
+#include "absl/functional/any_invocable.h"
 
 #include <grpc/support/log.h>
 
@@ -36,7 +37,7 @@ namespace grpc_core {
 
 // Global singleton that stores library configuration - factories, etc...
 // that plugins might choose to extend.
-class CoreConfiguration {
+class GRPC_DLL CoreConfiguration {
  public:
   CoreConfiguration(const CoreConfiguration&) = delete;
   CoreConfiguration& operator=(const CoreConfiguration&) = delete;
@@ -98,7 +99,7 @@ class CoreConfiguration {
 
   // Stores a builder for RegisterBuilder
   struct RegisteredBuilder {
-    std::function<void(Builder*)> builder;
+    absl::AnyInvocable<void(Builder*)> builder;
     RegisteredBuilder* next;
   };
 
@@ -154,7 +155,7 @@ class CoreConfiguration {
   // Attach a registration function globally.
   // Each registration function is called *in addition to*
   // BuildCoreConfiguration for the default core configuration.
-  static void RegisterBuilder(std::function<void(Builder*)> builder);
+  static void RegisterBuilder(absl::AnyInvocable<void(Builder*)> builder);
 
   // Drop the core configuration. Users must ensure no other threads are
   // accessing the configuration.