grpc 1.32.0 → 1.33.0.pre1

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/channel/channelz.h"
+#include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/map.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;
 
-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,63 @@ 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);
+  static RefCountedPtr<XdsClient> GetOrCreate(grpc_error** error);
+
+  // Callers should not instantiate directly.  Use GetOrCreate() instead.
+  explicit XdsClient(grpc_error** error);
   ~XdsClient();
 
+  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 +181,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,7 +197,8 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     class AdsCallState;
     class LrsCallState;
 
-    ChannelState(RefCountedPtr<XdsClient> xds_client, grpc_channel* channel);
+    ChannelState(WeakRefCountedPtr<XdsClient> xds_client,
+                 grpc_channel* channel);
     ~ChannelState();
 
     void Orphan() override;
@@ -188,7 +224,7 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     class StateWatcher;
 
     // The owning xds client.
-    RefCountedPtr<XdsClient> xds_client_;
+    WeakRefCountedPtr<XdsClient> xds_client_;
 
     // The channel and its status.
     grpc_channel* channel_;
@@ -200,6 +236,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;
@@ -215,6 +267,10 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     absl::optional<XdsApi::EdsUpdate> update;
   };
 
+  // TODO(roth): Change this to store exactly one instance of
+  // XdsClusterDropStats and exactly one instance of
+  // XdsClusterLocalityStats per locality.  We can return multiple refs
+  // to the same object instead of registering multiple objects.
   struct LoadReportState {
     struct LocalityState {
       std::set<XdsClusterLocalityStats*> locality_stats;
@@ -222,7 +278,7 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     };
 
     std::set<XdsClusterDropStats*> drop_stats;
-    XdsClusterDropStats::DroppedRequestsMap deleted_drop_stats;
+    XdsClusterDropStats::Snapshot deleted_drop_stats;
     std::map<RefCountedPtr<XdsLocalityName>, LocalityState,
              XdsLocalityName::Less>
         locality_stats;
@@ -230,39 +286,32 @@ 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_;
   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>
@@ -271,6 +320,11 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   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
 //
@@ -48,15 +56,21 @@ XdsClusterDropStats::~XdsClusterDropStats() {
   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];
 }
 
 //
@@ -79,14 +93,6 @@ XdsClusterLocalityStats::~XdsClusterLocalityStats() {
   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,7 +101,31 @@ 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,
@@ -108,8 +134,9 @@ class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
   ~XdsClusterDropStats();
 
   // 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.

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

@@ -117,7 +117,6 @@ grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
                                          const grpc_arg_pointer_vtable* vtable);
 
 // Returns a string representing channel args in human-readable form.
-// Callers takes ownership of result.
 std::string grpc_channel_args_string(const grpc_channel_args* args);
 
 // Takes ownership of the old_args

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

@@ -48,40 +48,6 @@
 namespace grpc_core {
 namespace channelz {
 
-//
-// channel arg code
-//
-
-namespace {
-
-void* parent_uuid_copy(void* p) { return p; }
-void parent_uuid_destroy(void* /*p*/) {}
-int parent_uuid_cmp(void* p1, void* p2) { return GPR_ICMP(p1, p2); }
-const grpc_arg_pointer_vtable parent_uuid_vtable = {
-    parent_uuid_copy, parent_uuid_destroy, parent_uuid_cmp};
-
-}  // namespace
-
-grpc_arg MakeParentUuidArg(intptr_t parent_uuid) {
-  // We would ideally like to store the uuid in an integer argument.
-  // Unfortunately, that won't work, because intptr_t (the type used for
-  // uuids) doesn't fit in an int (the type used for integer args).
-  // So instead, we use a hack to store it as a pointer, because
-  // intptr_t should be the same size as void*.
-  static_assert(sizeof(intptr_t) <= sizeof(void*),
-                "can't fit intptr_t inside of void*");
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_CHANNELZ_PARENT_UUID),
-      reinterpret_cast<void*>(parent_uuid), &parent_uuid_vtable);
-}
-
-intptr_t GetParentUuidFromArgs(const grpc_channel_args& args) {
-  const grpc_arg* arg =
-      grpc_channel_args_find(&args, GRPC_ARG_CHANNELZ_PARENT_UUID);
-  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return 0;
-  return reinterpret_cast<intptr_t>(arg->value.pointer.p);
-}
-
 //
 // BaseNode
 //
@@ -171,13 +137,12 @@ void CallCountingHelper::PopulateCallCounts(Json::Object* object) {
 //
 
 ChannelNode::ChannelNode(std::string target, size_t channel_tracer_max_nodes,
-                         intptr_t parent_uuid)
-    : BaseNode(parent_uuid == 0 ? EntityType::kTopLevelChannel
-                                : EntityType::kInternalChannel,
+                         bool is_internal_channel)
+    : BaseNode(is_internal_channel ? EntityType::kInternalChannel
+                                   : EntityType::kTopLevelChannel,
                target),
       target_(std::move(target)),
-      trace_(channel_tracer_max_nodes),
-      parent_uuid_(parent_uuid) {}
+      trace_(channel_tracer_max_nodes) {}
 
 const char* ChannelNode::GetChannelConnectivityStateChangeString(
     grpc_connectivity_state state) {
@@ -235,18 +200,18 @@ void ChannelNode::PopulateChildRefs(Json::Object* json) {
   MutexLock lock(&child_mu_);
   if (!child_subchannels_.empty()) {
     Json::Array array;
-    for (const auto& p : child_subchannels_) {
+    for (intptr_t subchannel_uuid : child_subchannels_) {
       array.emplace_back(Json::Object{
-          {"subchannelId", std::to_string(p.first)},
+          {"subchannelId", std::to_string(subchannel_uuid)},
       });
     }
     (*json)["subchannelRef"] = std::move(array);
   }
   if (!child_channels_.empty()) {
     Json::Array array;
-    for (const auto& p : child_channels_) {
+    for (intptr_t channel_uuid : child_channels_) {
       array.emplace_back(Json::Object{
-          {"channelId", std::to_string(p.first)},
+          {"channelId", std::to_string(channel_uuid)},
       });
     }
     (*json)["channelRef"] = std::move(array);
@@ -261,7 +226,7 @@ void ChannelNode::SetConnectivityState(grpc_connectivity_state state) {
 
 void ChannelNode::AddChildChannel(intptr_t child_uuid) {
   MutexLock lock(&child_mu_);
-  child_channels_.insert(std::make_pair(child_uuid, true));
+  child_channels_.insert(child_uuid);
 }
 
 void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
@@ -271,7 +236,7 @@ void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
 
 void ChannelNode::AddChildSubchannel(intptr_t child_uuid) {
   MutexLock lock(&child_mu_);
-  child_subchannels_.insert(std::make_pair(child_uuid, true));
+  child_subchannels_.insert(child_uuid);
 }
 
 void ChannelNode::RemoveChildSubchannel(intptr_t child_uuid) {