grpc 1.31.0.pre1 → 1.33.0.pre1

data/src/core/ext/{filters/client_channel/xds → xds}/xds_client.h

@@ -14,43 +14,50 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_H
+#ifndef GRPC_CORE_EXT_XDS_XDS_CLIENT_H
+#define GRPC_CORE_EXT_XDS_XDS_CLIENT_H
 
 #include <grpc/support/port_platform.h>
 
 #include <set>
+#include <vector>
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include "src/core/ext/filters/client_channel/service_config.h"
-#include "src/core/ext/filters/client_channel/xds/xds_api.h"
-#include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
-#include "src/core/ext/filters/client_channel/xds/xds_client_stats.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"
+#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:
-  // Service config watcher interface.  Implemented by callers.
-  class ServiceConfigWatcherInterface {
+  // Listener data watcher interface.  Implemented by callers.
+  class ListenerWatcherInterface {
    public:
-    virtual ~ServiceConfigWatcherInterface() = default;
-
-    virtual void OnServiceConfigChanged(
-        RefCountedPtr<ServiceConfig> service_config) = 0;
-
+    virtual ~ListenerWatcherInterface() = default;
+    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;
   };
 
@@ -58,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;
   };
 
@@ -70,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<ServiceConfigWatcherInterface> 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
@@ -138,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>
@@ -164,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;
@@ -190,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_;
@@ -202,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;
@@ -217,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;
@@ -224,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;
@@ -232,78 +286,45 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   };
 
   // Sends an error notification to all watchers.
-  void NotifyOnError(grpc_error* error);
-
-  // Returns the weighted_clusters action name to use from
-  // weighted_cluster_index_map_ for a WeightedClusters route action.
-  std::string WeightedClustersActionName(
-      const std::vector<XdsApi::RdsUpdate::RdsRoute::ClusterWeight>&
-          weighted_clusters);
-
-  // Updates weighted_cluster_index_map_ that will
-  // determine the names of the WeightedCluster actions for the current update.
-  void UpdateWeightedClusterIndexMap(const XdsApi::RdsUpdate& rds_update);
+  void NotifyOnErrorLocked(grpc_error* error);
 
-  // Create the service config generated by the RdsUpdate.
-  grpc_error* CreateServiceConfig(const XdsApi::RdsUpdate& rds_update,
-                                  RefCountedPtr<ServiceConfig>* service_config);
-
-  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<ServiceConfigWatcherInterface> service_config_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_;
 
-  // 2-level map to store WeightedCluster action names.
-  // Top level map is keyed by cluster names without weight like a_b_c; bottom
-  // level map is keyed by cluster names + weights like a10_b50_c40.
-  struct ClusterNamesInfo {
-    uint64_t next_index = 0;
-    std::map<std::string /*cluster names + weights*/,
-             uint64_t /*policy index number*/>
-        cluster_weights_map;
-  };
-  using WeightedClusterIndexMap =
-      std::map<std::string /*cluster names*/, ClusterNamesInfo>;
-
-  // Cache of action names for WeightedCluster targets in the current
-  // service config.
-  WeightedClusterIndexMap weighted_cluster_index_map_;
-
   bool shutting_down_ = false;
 };
 
+namespace internal {
+void SetXdsChannelArgsForTest(grpc_channel_args* args);
+void UnsetGlobalXdsClientForTest();
+}  // namespace internal
+
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_H */
+#endif /* GRPC_CORE_EXT_XDS_XDS_CLIENT_H */

data/src/core/ext/{filters/client_channel/xds → xds}/xds_client_stats.cc

@@ -18,17 +18,25 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
+#include "src/core/ext/xds/xds_client_stats.h"
 
 #include <string.h>
 
 #include <grpc/support/atm.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/xds/xds_client.h"
+#include "src/core/ext/xds/xds_client.h"
 
 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/{filters/client_channel/xds → xds}/xds_client_stats.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_STATS_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_STATS_H
+#ifndef GRPC_CORE_EXT_XDS_XDS_CLIENT_STATS_H
+#define GRPC_CORE_EXT_XDS_XDS_CLIENT_STATS_H
 
 #include <grpc/support/port_platform.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.
@@ -208,4 +236,4 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_STATS_H */
+#endif /* GRPC_CORE_EXT_XDS_XDS_CLIENT_STATS_H */