grpc 1.32.0 → 1.35.0

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

@@ -20,6 +20,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <set>
+#include <vector>
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -27,28 +28,36 @@
 #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"
-#include "src/core/lib/gprpp/map.h"
+#include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_core {
 
-extern TraceFlag xds_client_trace;
+extern TraceFlag grpc_xds_client_trace;
+extern TraceFlag grpc_xds_client_refcount_trace;
 
-class XdsClient : public InternallyRefCounted<XdsClient> {
+class XdsClient : public DualRefCounted<XdsClient> {
  public:
   // Listener data watcher interface.  Implemented by callers.
   class ListenerWatcherInterface {
    public:
     virtual ~ListenerWatcherInterface() = default;
-
-    virtual void OnListenerChanged(std::vector<XdsApi::Route> routes) = 0;
-
+    virtual void OnListenerChanged(XdsApi::LdsUpdate listener) = 0;
     virtual void OnError(grpc_error* error) = 0;
+    virtual void OnResourceDoesNotExist() = 0;
+  };
 
+  // RouteConfiguration data watcher interface.  Implemented by callers.
+  class RouteConfigWatcherInterface {
+   public:
+    virtual ~RouteConfigWatcherInterface() = default;
+    virtual void OnRouteConfigChanged(XdsApi::RdsUpdate route_config) = 0;
+    virtual void OnError(grpc_error* error) = 0;
     virtual void OnResourceDoesNotExist() = 0;
   };
 
@@ -56,11 +65,8 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   class ClusterWatcherInterface {
    public:
     virtual ~ClusterWatcherInterface() = default;
-
     virtual void OnClusterChanged(XdsApi::CdsUpdate cluster_data) = 0;
-
     virtual void OnError(grpc_error* error) = 0;
-
     virtual void OnResourceDoesNotExist() = 0;
   };
 
@@ -68,24 +74,67 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   class EndpointWatcherInterface {
    public:
     virtual ~EndpointWatcherInterface() = default;
-
     virtual void OnEndpointChanged(XdsApi::EdsUpdate update) = 0;
-
     virtual void OnError(grpc_error* error) = 0;
-
     virtual void OnResourceDoesNotExist() = 0;
   };
 
-  // If *error is not GRPC_ERROR_NONE after construction, then there was
+  // Factory function to get or create the global XdsClient instance.
+  // If *error is not GRPC_ERROR_NONE upon return, then there was
   // an error initializing the client.
-  XdsClient(std::shared_ptr<WorkSerializer> work_serializer,
-            grpc_pollset_set* interested_parties, absl::string_view server_name,
-            std::unique_ptr<ListenerWatcherInterface> watcher,
-            const grpc_channel_args& channel_args, grpc_error** error);
-  ~XdsClient();
+  static RefCountedPtr<XdsClient> GetOrCreate(grpc_error** error);
+
+  // Callers should not instantiate directly.  Use GetOrCreate() instead.
+  explicit XdsClient(grpc_error** error);
+  ~XdsClient() override;
+
+  CertificateProviderStore& certificate_provider_store() {
+    return *certificate_provider_store_;
+  }
+
+  grpc_pollset_set* interested_parties() const { return interested_parties_; }
+
+  // TODO(roth): When we add federation, there will be multiple channels
+  // inside the XdsClient, and the set of channels may change over time,
+  // but not every channel may use every one of the child channels, so
+  // this API will need to change.  At minumum, we will need to hold a
+  // ref to the parent channelz node so that we can update its list of
+  // children as the set of xDS channels changes.  However, we may also
+  // want to make this a bit more selective such that only those
+  // channels on which a given parent channel is actually requesting
+  // resources will actually be marked as its children.
+  void AddChannelzLinkage(channelz::ChannelNode* parent_channelz_node);
+  void RemoveChannelzLinkage(channelz::ChannelNode* parent_channelz_node);
 
   void Orphan() override;
 
+  // Start and cancel listener data watch for a listener.
+  // The XdsClient takes ownership of the watcher, but the caller may
+  // keep a raw pointer to the watcher, which may be used only for
+  // cancellation.  (Because the caller does not own the watcher, the
+  // pointer must not be used for any other purpose.)
+  // If the caller is going to start a new watch after cancelling the
+  // old one, it should set delay_unsubscription to true.
+  void WatchListenerData(absl::string_view listener_name,
+                         std::unique_ptr<ListenerWatcherInterface> watcher);
+  void CancelListenerDataWatch(absl::string_view listener_name,
+                               ListenerWatcherInterface* watcher,
+                               bool delay_unsubscription = false);
+
+  // Start and cancel route config data watch for a listener.
+  // The XdsClient takes ownership of the watcher, but the caller may
+  // keep a raw pointer to the watcher, which may be used only for
+  // cancellation.  (Because the caller does not own the watcher, the
+  // pointer must not be used for any other purpose.)
+  // If the caller is going to start a new watch after cancelling the
+  // old one, it should set delay_unsubscription to true.
+  void WatchRouteConfigData(
+      absl::string_view route_config_name,
+      std::unique_ptr<RouteConfigWatcherInterface> watcher);
+  void CancelRouteConfigDataWatch(absl::string_view route_config_name,
+                                  RouteConfigWatcherInterface* watcher,
+                                  bool delay_unsubscription = false);
+
   // Start and cancel cluster data watch for a cluster.
   // The XdsClient takes ownership of the watcher, but the caller may
   // keep a raw pointer to the watcher, which may be used only for
@@ -136,24 +185,14 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   // Resets connection backoff state.
   void ResetBackoff();
 
-  // Helpers for encoding the XdsClient object in channel args.
-  grpc_arg MakeChannelArg() const;
-  static RefCountedPtr<XdsClient> GetFromChannelArgs(
-      const grpc_channel_args& args);
-  static grpc_channel_args* RemoveFromChannelArgs(
-      const grpc_channel_args& args);
-
  private:
   // Contains a channel to the xds server and all the data related to the
   // channel.  Holds a ref to the xds client object.
-  // TODO(roth): This is separate from the XdsClient object because it was
-  // originally designed to be able to swap itself out in case the
-  // balancer name changed.  Now that the balancer name is going to be
-  // coming from the bootstrap file, we don't really need this level of
-  // indirection unless we decide to support watching the bootstrap file
-  // for changes.  At some point, if we decide that we're never going to
-  // need to do that, then we can eliminate this class and move its
-  // contents directly into the XdsClient class.
+  //
+  // Currently, there is only one ChannelState object per XdsClient
+  // object, and it has essentially the same lifetime.  But in the
+  // future, when we add federation support, a single XdsClient may have
+  // multiple underlying channels to talk to different xDS servers.
   class ChannelState : public InternallyRefCounted<ChannelState> {
    public:
     template <typename T>
@@ -162,8 +201,9 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     class AdsCallState;
     class LrsCallState;
 
-    ChannelState(RefCountedPtr<XdsClient> xds_client, grpc_channel* channel);
-    ~ChannelState();
+    ChannelState(WeakRefCountedPtr<XdsClient> xds_client,
+                 const XdsBootstrap::XdsServer& server);
+    ~ChannelState() override;
 
     void Orphan() override;
 
@@ -188,7 +228,9 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     class StateWatcher;
 
     // The owning xds client.
-    RefCountedPtr<XdsClient> xds_client_;
+    WeakRefCountedPtr<XdsClient> xds_client_;
+
+    const XdsBootstrap::XdsServer& server_;
 
     // The channel and its status.
     grpc_channel* channel_;
@@ -200,6 +242,22 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     OrphanablePtr<RetryableCall<LrsCallState>> lrs_calld_;
   };
 
+  struct ListenerState {
+    std::map<ListenerWatcherInterface*,
+             std::unique_ptr<ListenerWatcherInterface>>
+        watchers;
+    // The latest data seen from LDS.
+    absl::optional<XdsApi::LdsUpdate> update;
+  };
+
+  struct RouteConfigState {
+    std::map<RouteConfigWatcherInterface*,
+             std::unique_ptr<RouteConfigWatcherInterface>>
+        watchers;
+    // The latest data seen from RDS.
+    absl::optional<XdsApi::RdsUpdate> update;
+  };
+
   struct ClusterState {
     std::map<ClusterWatcherInterface*, std::unique_ptr<ClusterWatcherInterface>>
         watchers;
@@ -217,12 +275,12 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
 
   struct LoadReportState {
     struct LocalityState {
-      std::set<XdsClusterLocalityStats*> locality_stats;
-      std::vector<XdsClusterLocalityStats::Snapshot> deleted_locality_stats;
+      XdsClusterLocalityStats* locality_stats = nullptr;
+      XdsClusterLocalityStats::Snapshot deleted_locality_stats;
     };
 
-    std::set<XdsClusterDropStats*> drop_stats;
-    XdsClusterDropStats::DroppedRequestsMap deleted_drop_stats;
+    XdsClusterDropStats* drop_stats = nullptr;
+    XdsClusterDropStats::Snapshot deleted_drop_stats;
     std::map<RefCountedPtr<XdsLocalityName>, LocalityState,
              XdsLocalityName::Less>
         locality_stats;
@@ -230,47 +288,49 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   };
 
   // Sends an error notification to all watchers.
-  void NotifyOnError(grpc_error* error);
+  void NotifyOnErrorLocked(grpc_error* error);
 
-  XdsApi::ClusterLoadReportMap BuildLoadReportSnapshot(
+  XdsApi::ClusterLoadReportMap BuildLoadReportSnapshotLocked(
       bool send_all_clusters, const std::set<std::string>& clusters);
 
-  // Channel arg vtable functions.
-  static void* ChannelArgCopy(void* p);
-  static void ChannelArgDestroy(void* p);
-  static int ChannelArgCmp(void* p, void* q);
-
-  static const grpc_arg_pointer_vtable kXdsClientVtable;
-
   const grpc_millis request_timeout_;
-
-  std::shared_ptr<WorkSerializer> work_serializer_;
   grpc_pollset_set* interested_parties_;
-
   std::unique_ptr<XdsBootstrap> bootstrap_;
+  OrphanablePtr<CertificateProviderStore> certificate_provider_store_;
   XdsApi api_;
 
-  const std::string server_name_;
-  std::unique_ptr<ListenerWatcherInterface> listener_watcher_;
+  Mutex mu_;
 
   // The channel for communicating with the xds server.
   OrphanablePtr<ChannelState> chand_;
 
-  absl::optional<XdsApi::LdsUpdate> lds_result_;
-  absl::optional<XdsApi::RdsUpdate> rds_result_;
-
+  // One entry for each watched LDS resource.
+  std::map<std::string /*listener_name*/, ListenerState> listener_map_;
+  // One entry for each watched RDS resource.
+  std::map<std::string /*route_config_name*/, RouteConfigState>
+      route_config_map_;
   // One entry for each watched CDS resource.
   std::map<std::string /*cluster_name*/, ClusterState> cluster_map_;
   // One entry for each watched EDS resource.
   std::map<std::string /*eds_service_name*/, EndpointState> endpoint_map_;
+
+  // Load report data.
   std::map<
       std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
       LoadReportState>
       load_report_map_;
 
+  // Stores the most recent accepted resource version for each resource type.
+  std::map<std::string /*type*/, std::string /*version*/> resource_version_map_;
+
   bool shutting_down_ = false;
 };
 
+namespace internal {
+void SetXdsChannelArgsForTest(grpc_channel_args* args);
+void UnsetGlobalXdsClientForTest();
+}  // namespace internal
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_XDS_XDS_CLIENT_H */

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

@@ -29,6 +29,14 @@
 
 namespace grpc_core {
 
+namespace {
+
+uint64_t GetAndResetCounter(Atomic<uint64_t>* from) {
+  return from->Exchange(0, MemoryOrder::RELAXED);
+}
+
+}  // namespace
+
 //
 // XdsClusterDropStats
 //
@@ -37,26 +45,49 @@ XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
                                          absl::string_view lrs_server_name,
                                          absl::string_view cluster_name,
                                          absl::string_view eds_service_name)
-    : xds_client_(std::move(xds_client)),
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
+                     ? "XdsClusterDropStats"
+                     : nullptr),
+      xds_client_(std::move(xds_client)),
       lrs_server_name_(lrs_server_name),
       cluster_name_(cluster_name),
-      eds_service_name_(eds_service_name) {}
+      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, std::string(lrs_server_name_).c_str(),
+            std::string(cluster_name_).c_str(),
+            std::string(eds_service_name_).c_str());
+  }
+}
 
 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, std::string(lrs_server_name_).c_str(),
+            std::string(cluster_name_).c_str(),
+            std::string(eds_service_name_).c_str());
+  }
   xds_client_->RemoveClusterDropStats(lrs_server_name_, cluster_name_,
                                       eds_service_name_, this);
   xds_client_.reset(DEBUG_LOCATION, "DropStats");
 }
 
-XdsClusterDropStats::DroppedRequestsMap
-XdsClusterDropStats::GetSnapshotAndReset() {
+XdsClusterDropStats::Snapshot XdsClusterDropStats::GetSnapshotAndReset() {
+  Snapshot snapshot;
+  snapshot.uncategorized_drops = GetAndResetCounter(&uncategorized_drops_);
   MutexLock lock(&mu_);
-  return std::move(dropped_requests_);
+  snapshot.categorized_drops = std::move(categorized_drops_);
+  return snapshot;
+}
+
+void XdsClusterDropStats::AddUncategorizedDrops() {
+  uncategorized_drops_.FetchAdd(1);
 }
 
 void XdsClusterDropStats::AddCallDropped(const std::string& category) {
   MutexLock lock(&mu_);
-  ++dropped_requests_[category];
+  ++categorized_drops_[category];
 }
 
 //
@@ -67,26 +98,38 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
     RefCountedPtr<XdsClient> xds_client, absl::string_view lrs_server_name,
     absl::string_view cluster_name, absl::string_view eds_service_name,
     RefCountedPtr<XdsLocalityName> name)
-    : xds_client_(std::move(xds_client)),
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
+                     ? "XdsClusterLocalityStats"
+                     : nullptr),
+      xds_client_(std::move(xds_client)),
       lrs_server_name_(lrs_server_name),
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name),
-      name_(std::move(name)) {}
+      name_(std::move(name)) {
+  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, std::string(lrs_server_name_).c_str(),
+            std::string(cluster_name_).c_str(),
+            std::string(eds_service_name_).c_str(),
+            name_->AsHumanReadableString().c_str());
+  }
+}
 
 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, std::string(lrs_server_name_).c_str(),
+            std::string(cluster_name_).c_str(),
+            std::string(eds_service_name_).c_str(),
+            name_->AsHumanReadableString().c_str());
+  }
   xds_client_->RemoveClusterLocalityStats(lrs_server_name_, cluster_name_,
                                           eds_service_name_, name_, this);
   xds_client_.reset(DEBUG_LOCATION, "LocalityStats");
 }
 
-namespace {
-
-uint64_t GetAndResetCounter(Atomic<uint64_t>* from) {
-  return from->Exchange(0, MemoryOrder::RELAXED);
-}
-
-}  // namespace
-
 XdsClusterLocalityStats::Snapshot
 XdsClusterLocalityStats::GetSnapshotAndReset() {
   Snapshot snapshot = {GetAndResetCounter(&total_successful_requests_),

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

@@ -28,6 +28,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -45,6 +46,7 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
   struct Less {
     bool operator()(const XdsLocalityName* lhs,
                     const XdsLocalityName* rhs) const {
+      if (lhs == nullptr || rhs == nullptr) return GPR_ICMP(lhs, rhs);
       return lhs->Compare(*rhs) < 0;
     }
 
@@ -99,17 +101,42 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
 // Drop stats for an xds cluster.
 class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
  public:
-  using DroppedRequestsMap = std::map<std::string /* category */, uint64_t>;
+  // The total number of requests dropped for any reason is the sum of
+  // uncategorized_drops, and dropped_requests map.
+  using CategorizedDropsMap = std::map<std::string /* category */, uint64_t>;
+  struct Snapshot {
+    uint64_t uncategorized_drops = 0;
+    // The number of requests dropped for the specific drop categories
+    // outlined in the drop_overloads field in the EDS response.
+    CategorizedDropsMap categorized_drops;
+
+    Snapshot& operator+=(const Snapshot& other) {
+      uncategorized_drops += other.uncategorized_drops;
+      for (const auto& p : other.categorized_drops) {
+        categorized_drops[p.first] += p.second;
+      }
+      return *this;
+    }
+
+    bool IsZero() const {
+      if (uncategorized_drops != 0) return false;
+      for (const auto& p : categorized_drops) {
+        if (p.second != 0) return false;
+      }
+      return true;
+    }
+  };
 
   XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
                       absl::string_view lrs_server_name,
                       absl::string_view cluster_name,
                       absl::string_view eds_service_name);
-  ~XdsClusterDropStats();
+  ~XdsClusterDropStats() override;
 
   // Returns a snapshot of this instance and resets all the counters.
-  DroppedRequestsMap GetSnapshotAndReset();
+  Snapshot GetSnapshotAndReset();
 
+  void AddUncategorizedDrops();
   void AddCallDropped(const std::string& category);
 
  private:
@@ -117,11 +144,12 @@ class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
   absl::string_view lrs_server_name_;
   absl::string_view cluster_name_;
   absl::string_view eds_service_name_;
-  // Protects dropped_requests_. A mutex is necessary because the length of
-  // dropped_requests_ can be accessed by both the picker (from data plane
+  Atomic<uint64_t> uncategorized_drops_{0};
+  // Protects categorized_drops_. A mutex is necessary because the length of
+  // dropped_requests can be accessed by both the picker (from data plane
   // mutex) and the load reporting thread (from the control plane combiner).
   Mutex mu_;
-  DroppedRequestsMap dropped_requests_;
+  CategorizedDropsMap categorized_drops_;
 };
 
 // Locality stats for an xds cluster.
@@ -178,7 +206,7 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
                           absl::string_view cluster_name,
                           absl::string_view eds_service_name,
                           RefCountedPtr<XdsLocalityName> name);
-  ~XdsClusterLocalityStats();
+  ~XdsClusterLocalityStats() override;
 
   // Returns a snapshot of this instance and resets all the counters.
   Snapshot GetSnapshotAndReset();