grpc 1.27.0 → 1.30.2

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

@@ -21,18 +21,19 @@
 
 #include <set>
 
+#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/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/optional.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/gprpp/string_view.h"
-#include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 
 namespace grpc_core {
 
@@ -49,6 +50,8 @@ class XdsClient : public InternallyRefCounted {
         RefCountedPtr<ServiceConfig> service_config) = 0;
 
     virtual void OnError(grpc_error* error) = 0;
+
+    virtual void OnResourceDoesNotExist() = 0;
   };
 
   // Cluster data watcher interface.  Implemented by callers.
@@ -56,9 +59,11 @@ class XdsClient : public InternallyRefCounted {
    public:
     virtual ~ClusterWatcherInterface() = default;
 
-    virtual void OnClusterChanged(CdsUpdate cluster_data) = 0;
+    virtual void OnClusterChanged(XdsApi::CdsUpdate cluster_data) = 0;
 
     virtual void OnError(grpc_error* error) = 0;
+
+    virtual void OnResourceDoesNotExist() = 0;
   };
 
   // Endpoint data watcher interface.  Implemented by callers.
@@ -66,15 +71,17 @@ class XdsClient : public InternallyRefCounted {
    public:
     virtual ~EndpointWatcherInterface() = default;
 
-    virtual void OnEndpointChanged(EdsUpdate update) = 0;
+    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
   // an error initializing the client.
-  XdsClient(Combiner* combiner, grpc_pollset_set* interested_parties,
-            StringView server_name,
+  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);
   ~XdsClient();
@@ -86,26 +93,47 @@ class XdsClient : public InternallyRefCounted {
   // 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.)
-  void WatchClusterData(StringView cluster_name,
+  // If the caller is going to start a new watch after cancelling the
+  // old one, it should set delay_unsubscription to true.
+  void WatchClusterData(absl::string_view cluster_name,
                         std::unique_ptr<ClusterWatcherInterface> watcher);
-  void CancelClusterDataWatch(StringView cluster_name,
-                              ClusterWatcherInterface* watcher);
+  void CancelClusterDataWatch(absl::string_view cluster_name,
+                              ClusterWatcherInterface* watcher,
+                              bool delay_unsubscription = false);
 
   // Start and cancel endpoint 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
   // cancellation.  (Because the caller does not own the watcher, the
   // pointer must not be used for any other purpose.)
-  void WatchEndpointData(StringView eds_service_name,
+  // If the caller is going to start a new watch after cancelling the
+  // old one, it should set delay_unsubscription to true.
+  void WatchEndpointData(absl::string_view eds_service_name,
                          std::unique_ptr<EndpointWatcherInterface> watcher);
-  void CancelEndpointDataWatch(StringView eds_service_name,
-                               EndpointWatcherInterface* watcher);
-
-  // Adds and removes client stats for \a cluster_name.
-  void AddClientStats(StringView /*lrs_server*/, StringView cluster_name,
-                      XdsClientStats* client_stats);
-  void RemoveClientStats(StringView /*lrs_server*/, StringView cluster_name,
-                         XdsClientStats* client_stats);
+  void CancelEndpointDataWatch(absl::string_view eds_service_name,
+                               EndpointWatcherInterface* watcher,
+                               bool delay_unsubscription = false);
+
+  // Adds and removes drop stats for cluster_name and eds_service_name.
+  RefCountedPtr<XdsClusterDropStats> AddClusterDropStats(
+      absl::string_view lrs_server, absl::string_view cluster_name,
+      absl::string_view eds_service_name);
+  void RemoveClusterDropStats(absl::string_view /*lrs_server*/,
+                              absl::string_view cluster_name,
+                              absl::string_view eds_service_name,
+                              XdsClusterDropStats* cluster_drop_stats);
+
+  // Adds and removes locality stats for cluster_name and eds_service_name
+  // for the specified locality.
+  RefCountedPtr<XdsClusterLocalityStats> AddClusterLocalityStats(
+      absl::string_view lrs_server, absl::string_view cluster_name,
+      absl::string_view eds_service_name,
+      RefCountedPtr<XdsLocalityName> locality);
+  void RemoveClusterLocalityStats(
+      absl::string_view /*lrs_server*/, absl::string_view cluster_name,
+      absl::string_view eds_service_name,
+      const RefCountedPtr<XdsLocalityName>& locality,
+      XdsClusterLocalityStats* cluster_locality_stats);
 
   // Resets connection backoff state.
   void ResetBackoff();
@@ -114,10 +142,10 @@ class XdsClient : public InternallyRefCounted {
   grpc_arg MakeChannelArg() const;
   static RefCountedPtr<XdsClient> GetFromChannelArgs(
       const grpc_channel_args& args);
+  static grpc_channel_args* RemoveFromChannelArgs(
+      const grpc_channel_args& args);
 
  private:
-  static const grpc_arg_pointer_vtable kXdsClientVtable;
-
   // 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
@@ -136,8 +164,7 @@ class XdsClient : public InternallyRefCounted {
     class AdsCallState;
     class LrsCallState;
 
-    ChannelState(RefCountedPtr<XdsClient> xds_client,
-                 const grpc_channel_args& args);
+    ChannelState(RefCountedPtr<XdsClient> xds_client, grpc_channel* channel);
     ~ChannelState();
 
     void Orphan() override;
@@ -155,8 +182,9 @@ class XdsClient : public InternallyRefCounted {
     void StartConnectivityWatchLocked();
     void CancelConnectivityWatchLocked();
 
-    void OnResourceNamesChanged(const std::string& type_url);
-    void OnWatcherRemoved();
+    void Subscribe(const std::string& type_url, const std::string& name);
+    void Unsubscribe(const std::string& type_url, const std::string& name,
+                     bool delay_unsubscription);
 
    private:
     class StateWatcher;
@@ -178,58 +206,101 @@ class XdsClient : public InternallyRefCounted {
     std::map<ClusterWatcherInterface*, std::unique_ptr<ClusterWatcherInterface>>
         watchers;
     // The latest data seen from CDS.
-    Optional<CdsUpdate> update;
+    absl::optional<XdsApi::CdsUpdate> update;
   };
 
   struct EndpointState {
     std::map<EndpointWatcherInterface*,
              std::unique_ptr<EndpointWatcherInterface>>
         watchers;
-    std::set<XdsClientStats*> client_stats;
     // The latest data seen from EDS.
-    EdsUpdate update;
+    absl::optional<XdsApi::EdsUpdate> update;
+  };
+
+  struct LoadReportState {
+    struct LocalityState {
+      std::set<XdsClusterLocalityStats*> locality_stats;
+      std::vector<XdsClusterLocalityStats::Snapshot> deleted_locality_stats;
+    };
+
+    std::set<XdsClusterDropStats*> drop_stats;
+    XdsClusterDropStats::DroppedRequestsMap deleted_drop_stats;
+    std::map<RefCountedPtr<XdsLocalityName>, LocalityState,
+             XdsLocalityName::Less>
+        locality_stats;
+    grpc_millis last_report_time = ExecCtx::Get()->Now();
   };
 
   // Sends an error notification to all watchers.
   void NotifyOnError(grpc_error* error);
 
-  // TODO(juanlishen): Once we implement LDS support, this can be a
-  // normal method instead of a closure callback.
-  static void NotifyOnServiceConfig(void* arg, 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);
 
-  std::set<StringView> WatchedClusterNames() const;
+  // 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);
 
-  std::set<StringView> EdsServiceNames() const;
+  // Create the service config generated by the RdsUpdate.
+  grpc_error* CreateServiceConfig(const XdsApi::RdsUpdate& rds_update,
+                                  RefCountedPtr<ServiceConfig>* service_config);
 
-  std::map<StringView, std::set<XdsClientStats*>> ClientStatsMap() const;
+  XdsApi::ClusterLoadReportMap BuildLoadReportSnapshot(
+      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);
 
-  // All the received clusters are cached, no matter they are watched or not.
-  std::map<StringView /*cluster_name*/, ClusterState, StringLess> cluster_map_;
-  // Only the watched EDS service names are stored.
-  std::map<StringView /*eds_service_name*/, EndpointState, StringLess>
-      endpoint_map_;
+  static const grpc_arg_pointer_vtable kXdsClientVtable;
 
-  grpc_core::UniquePtr<char> build_version_;
+  const grpc_millis request_timeout_;
 
-  Combiner* combiner_;
+  std::shared_ptr<WorkSerializer> work_serializer_;
   grpc_pollset_set* interested_parties_;
 
   std::unique_ptr<XdsBootstrap> bootstrap_;
+  XdsApi api_;
+
+  const std::string server_name_;
 
-  std::string server_name_;
   std::unique_ptr<ServiceConfigWatcherInterface> service_config_watcher_;
-  // TODO(juanlishen): Once we implement LDS support, this will no
-  // longer be needed.
-  grpc_closure service_config_notify_;
 
   // 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 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_;
+  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;
 };
 

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

@@ -20,172 +20,96 @@
 
 #include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
 
+#include <string.h>
+
 #include <grpc/support/atm.h>
 #include <grpc/support/string_util.h>
-#include <string.h>
+
+#include "src/core/ext/filters/client_channel/xds/xds_client.h"
 
 namespace grpc_core {
 
-namespace {
+//
+// XdsClusterDropStats
+//
 
-template <typename T>
-T GetAndResetCounter(Atomic<T>* from) {
-  return from->Exchange(0, MemoryOrder::RELAXED);
+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)),
+      lrs_server_name_(lrs_server_name),
+      cluster_name_(cluster_name),
+      eds_service_name_(eds_service_name) {}
+
+XdsClusterDropStats::~XdsClusterDropStats() {
+  xds_client_->RemoveClusterDropStats(lrs_server_name_, cluster_name_,
+                                      eds_service_name_, this);
+  xds_client_.reset(DEBUG_LOCATION, "DropStats");
 }
 
-}  // namespace
-
-//
-// XdsClientStats::LocalityStats::LoadMetric::Snapshot
-//
+XdsClusterDropStats::DroppedRequestsMap
+XdsClusterDropStats::GetSnapshotAndReset() {
+  MutexLock lock(&mu_);
+  return std::move(dropped_requests_);
+}
 
-bool XdsClientStats::LocalityStats::LoadMetric::Snapshot::IsAllZero() const {
-  return total_metric_value == 0 && num_requests_finished_with_metric == 0;
+void XdsClusterDropStats::AddCallDropped(const std::string& category) {
+  MutexLock lock(&mu_);
+  ++dropped_requests_[category];
 }
 
 //
-// XdsClientStats::LocalityStats::LoadMetric
+// XdsClusterLocalityStats
 //
 
-XdsClientStats::LocalityStats::LoadMetric::Snapshot
-XdsClientStats::LocalityStats::LoadMetric::GetSnapshotAndReset() {
-  Snapshot metric = {num_requests_finished_with_metric_, total_metric_value_};
-  num_requests_finished_with_metric_ = 0;
-  total_metric_value_ = 0;
-  return metric;
+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)),
+      lrs_server_name_(lrs_server_name),
+      cluster_name_(cluster_name),
+      eds_service_name_(eds_service_name),
+      name_(std::move(name)) {}
+
+XdsClusterLocalityStats::~XdsClusterLocalityStats() {
+  xds_client_->RemoveClusterLocalityStats(lrs_server_name_, cluster_name_,
+                                          eds_service_name_, name_, this);
+  xds_client_.reset(DEBUG_LOCATION, "LocalityStats");
 }
 
-//
-// XdsClientStats::LocalityStats::Snapshot
-//
+namespace {
 
-bool XdsClientStats::LocalityStats::Snapshot::IsAllZero() {
-  if (total_successful_requests != 0 || total_requests_in_progress != 0 ||
-      total_error_requests != 0 || total_issued_requests != 0) {
-    return false;
-  }
-  for (auto& p : load_metric_stats) {
-    const LoadMetric::Snapshot& metric_value = p.second;
-    if (!metric_value.IsAllZero()) return false;
-  }
-  return true;
+uint64_t GetAndResetCounter(Atomic<uint64_t>* from) {
+  return from->Exchange(0, MemoryOrder::RELAXED);
 }
 
-//
-// XdsClientStats::LocalityStats
-//
+}  // namespace
 
-XdsClientStats::LocalityStats::Snapshot
-XdsClientStats::LocalityStats::GetSnapshotAndReset() {
-  Snapshot snapshot = {
-      GetAndResetCounter(&total_successful_requests_),
-      // Don't reset total_requests_in_progress because it's not
-      // related to a single reporting interval.
-      total_requests_in_progress_.Load(MemoryOrder::RELAXED),
-      GetAndResetCounter(&total_error_requests_),
-      GetAndResetCounter(&total_issued_requests_)};
-  {
-    MutexLock lock(&load_metric_stats_mu_);
-    for (auto& p : load_metric_stats_) {
-      const std::string& metric_name = p.first;
-      LoadMetric& metric_value = p.second;
-      snapshot.load_metric_stats.emplace(metric_name,
-                                         metric_value.GetSnapshotAndReset());
-    }
-  }
+XdsClusterLocalityStats::Snapshot
+XdsClusterLocalityStats::GetSnapshotAndReset() {
+  Snapshot snapshot = {GetAndResetCounter(&total_successful_requests_),
+                       // Don't reset total_requests_in_progress because it's
+                       // not related to a single reporting interval.
+                       total_requests_in_progress_.Load(MemoryOrder::RELAXED),
+                       GetAndResetCounter(&total_error_requests_),
+                       GetAndResetCounter(&total_issued_requests_)};
+  MutexLock lock(&backend_metrics_mu_);
+  snapshot.backend_metrics = std::move(backend_metrics_);
   return snapshot;
 }
 
-void XdsClientStats::LocalityStats::AddCallStarted() {
+void XdsClusterLocalityStats::AddCallStarted() {
   total_issued_requests_.FetchAdd(1, MemoryOrder::RELAXED);
   total_requests_in_progress_.FetchAdd(1, MemoryOrder::RELAXED);
 }
 
-void XdsClientStats::LocalityStats::AddCallFinished(bool fail) {
+void XdsClusterLocalityStats::AddCallFinished(bool fail) {
   Atomic<uint64_t>& to_increment =
       fail ? total_error_requests_ : total_successful_requests_;
   to_increment.FetchAdd(1, MemoryOrder::RELAXED);
   total_requests_in_progress_.FetchAdd(-1, MemoryOrder::ACQ_REL);
 }
 
-//
-// XdsClientStats::Snapshot
-//
-
-bool XdsClientStats::Snapshot::IsAllZero() {
-  for (auto& p : upstream_locality_stats) {
-    if (!p.second.IsAllZero()) return false;
-  }
-  for (auto& p : dropped_requests) {
-    if (p.second != 0) return false;
-  }
-  return total_dropped_requests == 0;
-}
-
-//
-// XdsClientStats
-//
-
-XdsClientStats::Snapshot XdsClientStats::GetSnapshotAndReset() {
-  grpc_millis now = ExecCtx::Get()->Now();
-  // Record total_dropped_requests and reporting interval in the snapshot.
-  Snapshot snapshot;
-  snapshot.total_dropped_requests =
-      GetAndResetCounter(&total_dropped_requests_);
-  snapshot.load_report_interval = now - last_report_time_;
-  // Update last report time.
-  last_report_time_ = now;
-  // Snapshot all the other stats.
-  for (auto& p : upstream_locality_stats_) {
-    snapshot.upstream_locality_stats.emplace(p.first,
-                                             p.second->GetSnapshotAndReset());
-  }
-  {
-    MutexLock lock(&dropped_requests_mu_);
-    // This is a workaround for the case where some compilers cannot build
-    // move-assignment of map with non-copyable but movable key.
-    // https://stackoverflow.com/questions/36475497
-    std::swap(snapshot.dropped_requests, dropped_requests_);
-    dropped_requests_.clear();
-  }
-  return snapshot;
-}
-
-void XdsClientStats::MaybeInitLastReportTime() {
-  if (last_report_time_ == -1) last_report_time_ = ExecCtx::Get()->Now();
-}
-
-RefCountedPtr<XdsClientStats::LocalityStats> XdsClientStats::FindLocalityStats(
-    const RefCountedPtr<XdsLocalityName>& locality_name) {
-  auto iter = upstream_locality_stats_.find(locality_name);
-  if (iter == upstream_locality_stats_.end()) {
-    iter = upstream_locality_stats_
-               .emplace(locality_name, MakeRefCounted<LocalityStats>())
-               .first;
-  }
-  return iter->second;
-}
-
-void XdsClientStats::PruneLocalityStats() {
-  auto iter = upstream_locality_stats_.begin();
-  while (iter != upstream_locality_stats_.end()) {
-    if (iter->second->IsSafeToDelete()) {
-      iter = upstream_locality_stats_.erase(iter);
-    } else {
-      ++iter;
-    }
-  }
-}
-
-void XdsClientStats::AddCallDropped(const std::string& category) {
-  total_dropped_requests_.FetchAdd(1, MemoryOrder::RELAXED);
-  MutexLock lock(&dropped_requests_mu_);
-  auto iter = dropped_requests_.find(category);
-  if (iter == dropped_requests_.end()) {
-    dropped_requests_.emplace(category, 1);
-  } else {
-    ++iter->second;
-  }
-}
-
 }  // namespace grpc_core