grpc 1.28.0.pre2 → 1.31.0.pre1

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.
@@ -59,6 +62,8 @@ class XdsClient : public InternallyRefCounted {
     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.
@@ -69,12 +74,14 @@ class XdsClient : public InternallyRefCounted {
     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,38 +93,45 @@ 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);
+  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(
-      StringView lrs_server, StringView cluster_name,
-      StringView eds_service_name);
-  void RemoveClusterDropStats(StringView /*lrs_server*/,
-                              StringView cluster_name,
-                              StringView eds_service_name,
+      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(
-      StringView lrs_server, StringView cluster_name,
-      StringView eds_service_name, RefCountedPtr<XdsLocalityName> locality);
+      absl::string_view lrs_server, absl::string_view cluster_name,
+      absl::string_view eds_service_name,
+      RefCountedPtr<XdsLocalityName> locality);
   void RemoveClusterLocalityStats(
-      StringView /*lrs_server*/, StringView cluster_name,
-      StringView eds_service_name,
+      absl::string_view /*lrs_server*/, absl::string_view cluster_name,
+      absl::string_view eds_service_name,
       const RefCountedPtr<XdsLocalityName>& locality,
       XdsClusterLocalityStats* cluster_locality_stats);
 
@@ -128,6 +142,8 @@ 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:
   // Contains a channel to the xds server and all the data related to the
@@ -167,7 +183,8 @@ class XdsClient : public InternallyRefCounted {
     void CancelConnectivityWatchLocked();
 
     void Subscribe(const std::string& type_url, const std::string& name);
-    void Unsubscribe(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;
@@ -189,7 +206,7 @@ class XdsClient : public InternallyRefCounted {
     std::map<ClusterWatcherInterface*, std::unique_ptr<ClusterWatcherInterface>>
         watchers;
     // The latest data seen from CDS.
-    Optional<XdsApi::CdsUpdate> update;
+    absl::optional<XdsApi::CdsUpdate> update;
   };
 
   struct EndpointState {
@@ -197,12 +214,18 @@ class XdsClient : public InternallyRefCounted {
              std::unique_ptr<EndpointWatcherInterface>>
         watchers;
     // The latest data seen from EDS.
-    XdsApi::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;
-    std::map<RefCountedPtr<XdsLocalityName>, std::set<XdsClusterLocalityStats*>,
+    XdsClusterDropStats::DroppedRequestsMap deleted_drop_stats;
+    std::map<RefCountedPtr<XdsLocalityName>, LocalityState,
              XdsLocalityName::Less>
         locality_stats;
     grpc_millis last_report_time = ExecCtx::Get()->Now();
@@ -211,11 +234,22 @@ class XdsClient : public InternallyRefCounted {
   // Sends an error notification to all watchers.
   void NotifyOnError(grpc_error* error);
 
-  grpc_error* CreateServiceConfig(
-      const std::string& cluster_name,
-      RefCountedPtr<ServiceConfig>* service_config) const;
+  // 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);
 
-  XdsApi::ClusterLoadReportMap BuildLoadReportSnapshot();
+  // 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);
+
+  // Create the service config generated by the RdsUpdate.
+  grpc_error* CreateServiceConfig(const XdsApi::RdsUpdate& rds_update,
+                                  RefCountedPtr<ServiceConfig>* service_config);
+
+  XdsApi::ClusterLoadReportMap BuildLoadReportSnapshot(
+      bool send_all_clusters, const std::set<std::string>& clusters);
 
   // Channel arg vtable functions.
   static void* ChannelArgCopy(void* p);
@@ -226,7 +260,7 @@ class XdsClient : public InternallyRefCounted {
 
   const grpc_millis request_timeout_;
 
-  Combiner* combiner_;
+  std::shared_ptr<WorkSerializer> work_serializer_;
   grpc_pollset_set* interested_parties_;
 
   std::unique_ptr<XdsBootstrap> bootstrap_;
@@ -239,17 +273,34 @@ class XdsClient : public InternallyRefCounted {
   // The channel for communicating with the xds server.
   OrphanablePtr<ChannelState> chand_;
 
-  std::string route_config_name_;
-  std::string cluster_name_;
-  // All the received clusters are cached, no matter they are watched or not.
+  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_;
-  // Only the watched EDS service names are stored.
+  // 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

@@ -34,9 +34,9 @@ namespace grpc_core {
 //
 
 XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
-                                         StringView lrs_server_name,
-                                         StringView cluster_name,
-                                         StringView eds_service_name)
+                                         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),
@@ -64,8 +64,8 @@ void XdsClusterDropStats::AddCallDropped(const std::string& category) {
 //
 
 XdsClusterLocalityStats::XdsClusterLocalityStats(
-    RefCountedPtr<XdsClient> xds_client, StringView lrs_server_name,
-    StringView cluster_name, StringView eds_service_name,
+    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),
@@ -89,13 +89,12 @@ uint64_t GetAndResetCounter(Atomic* from) {
 
 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_)};
+  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;

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

@@ -21,11 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/string_util.h>
+#include <map>
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 #include "src/core/lib/gprpp/atomic.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
-#include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -42,11 +45,7 @@ class XdsLocalityName : public RefCounted {
   struct Less {
     bool operator()(const XdsLocalityName* lhs,
                     const XdsLocalityName* rhs) const {
-      int cmp_result = lhs->region_.compare(rhs->region_);
-      if (cmp_result != 0) return cmp_result < 0;
-      cmp_result = lhs->zone_.compare(rhs->zone_);
-      if (cmp_result != 0) return cmp_result < 0;
-      return lhs->sub_zone_.compare(rhs->sub_zone_) < 0;
+      return lhs->Compare(*rhs) < 0;
     }
 
     bool operator()(const RefCountedPtr<XdsLocalityName>& lhs,
@@ -65,25 +64,36 @@ class XdsLocalityName : public RefCounted {
            sub_zone_ == other.sub_zone_;
   }
 
+  bool operator!=(const XdsLocalityName& other) const {
+    return !(*this == other);
+  }
+
+  int Compare(const XdsLocalityName& other) const {
+    int cmp_result = region_.compare(other.region_);
+    if (cmp_result != 0) return cmp_result;
+    cmp_result = zone_.compare(other.zone_);
+    if (cmp_result != 0) return cmp_result;
+    return sub_zone_.compare(other.sub_zone_);
+  }
+
   const std::string& region() const { return region_; }
   const std::string& zone() const { return zone_; }
   const std::string& sub_zone() const { return sub_zone_; }
 
-  const char* AsHumanReadableString() {
-    if (human_readable_string_ == nullptr) {
-      char* tmp;
-      gpr_asprintf(&tmp, "{region=\"%s\", zone=\"%s\", sub_zone=\"%s\"}",
-                   region_.c_str(), zone_.c_str(), sub_zone_.c_str());
-      human_readable_string_.reset(tmp);
+  const std::string& AsHumanReadableString() {
+    if (human_readable_string_.empty()) {
+      human_readable_string_ =
+          absl::StrFormat("{region=\"%s\", zone=\"%s\", sub_zone=\"%s\"}",
+                          region_, zone_, sub_zone_);
     }
-    return human_readable_string_.get();
+    return human_readable_string_;
   }
 
  private:
   std::string region_;
   std::string zone_;
   std::string sub_zone_;
-  UniquePtr<char> human_readable_string_;
+  std::string human_readable_string_;
 };
 
 // Drop stats for an xds cluster.
@@ -92,8 +102,9 @@ class XdsClusterDropStats : public RefCounted {
   using DroppedRequestsMap = std::map<std::string /* category */, uint64_t>;
 
   XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
-                      StringView lrs_server_name, StringView cluster_name,
-                      StringView eds_service_name);
+                      absl::string_view lrs_server_name,
+                      absl::string_view cluster_name,
+                      absl::string_view eds_service_name);
   ~XdsClusterDropStats();
 
   // Returns a snapshot of this instance and resets all the counters.
@@ -103,9 +114,9 @@ class XdsClusterDropStats : public RefCounted {
 
  private:
   RefCountedPtr<XdsClient> xds_client_;
-  StringView lrs_server_name_;
-  StringView cluster_name_;
-  StringView eds_service_name_;
+  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
   // mutex) and the load reporting thread (from the control plane combiner).
@@ -163,8 +174,9 @@ class XdsClusterLocalityStats : public RefCounted {
   };
 
   XdsClusterLocalityStats(RefCountedPtr<XdsClient> xds_client,
-                          StringView lrs_server_name, StringView cluster_name,
-                          StringView eds_service_name,
+                          absl::string_view lrs_server_name,
+                          absl::string_view cluster_name,
+                          absl::string_view eds_service_name,
                           RefCountedPtr<XdsLocalityName> name);
   ~XdsClusterLocalityStats();
 
@@ -176,9 +188,9 @@ class XdsClusterLocalityStats : public RefCounted {
 
  private:
   RefCountedPtr<XdsClient> xds_client_;
-  StringView lrs_server_name_;
-  StringView cluster_name_;
-  StringView eds_service_name_;
+  absl::string_view lrs_server_name_;
+  absl::string_view cluster_name_;
+  absl::string_view eds_service_name_;
   RefCountedPtr<XdsLocalityName> name_;
 
   Atomic<uint64_t> total_successful_requests_{0};
@@ -188,8 +200,8 @@ class XdsClusterLocalityStats : public RefCounted {
 
   // Protects backend_metrics_. A mutex is necessary because the length of
   // backend_metrics_ can be accessed by both the callback intercepting the
-  // call's recv_trailing_metadata (not from the control plane combiner) and
-  // the load reporting thread (from the control plane combiner).
+  // call's recv_trailing_metadata (not from the control plane work serializer)
+  // and the load reporting thread (from the control plane work serializer).
   Mutex backend_metrics_mu_;
   std::map<std::string, BackendMetric> backend_metrics_;
 };

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -17,11 +17,19 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 #include <stdint.h>
 #include <string.h>
+
+#include <string>
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
@@ -31,6 +39,7 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/static_metadata.h"
+#include "src/core/lib/transport/status_conversion.h"
 #include "src/core/lib/transport/transport_impl.h"
 
 #define EXPECTED_CONTENT_TYPE "application/grpc"
@@ -112,18 +121,19 @@ static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
     } else {
       char* val = grpc_dump_slice(GRPC_MDVALUE(b->idx.named.status->md),
                                   GPR_DUMP_ASCII);
-      char* msg;
-      gpr_asprintf(&msg, "Received http2 header with status: %s", val);
+      std::string msg =
+          absl::StrCat("Received http2 header with status: ", val);
       grpc_error* e = grpc_error_set_str(
           grpc_error_set_int(
               grpc_error_set_str(
                   GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                       "Received http2 :status header with non-200 OK status"),
                   GRPC_ERROR_STR_VALUE, grpc_slice_from_copied_string(val)),
-              GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_CANCELLED),
-          GRPC_ERROR_STR_GRPC_MESSAGE, grpc_slice_from_copied_string(msg));
+              GRPC_ERROR_INT_GRPC_STATUS,
+              grpc_http2_status_to_grpc_status(atoi(val))),
+          GRPC_ERROR_STR_GRPC_MESSAGE,
+          grpc_slice_from_cpp_string(std::move(msg)));
       gpr_free(val);
-      gpr_free(msg);
       return e;
     }
   }
@@ -518,51 +528,36 @@ static size_t max_payload_size_from_args(const grpc_channel_args* args) {
 
 static grpc_core::ManagedMemorySlice user_agent_from_args(
     const grpc_channel_args* args, const char* transport_name) {
-  gpr_strvec v;
-  size_t i;
-  int is_first = 1;
-  char* tmp;
+  std::vector<std::string> user_agent_fields;
 
-  gpr_strvec_init(&v);
-
-  for (i = 0; args && i < args->num_args; i++) {
+  for (size_t i = 0; args && i < args->num_args; i++) {
     if (0 == strcmp(args->args[i].key, GRPC_ARG_PRIMARY_USER_AGENT_STRING)) {
       if (args->args[i].type != GRPC_ARG_STRING) {
         gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
                 GRPC_ARG_PRIMARY_USER_AGENT_STRING);
       } else {
-        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
-        is_first = 0;
-        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+        user_agent_fields.push_back(args->args[i].value.string);
       }
     }
   }
 
-  gpr_asprintf(&tmp, "%sgrpc-c/%s (%s; %s; %s)", is_first ? "" : " ",
-               grpc_version_string(), GPR_PLATFORM_STRING, transport_name,
-               grpc_g_stands_for());
-  is_first = 0;
-  gpr_strvec_add(&v, tmp);
+  user_agent_fields.push_back(
+      absl::StrFormat("grpc-c/%s (%s; %s)", grpc_version_string(),
+                      GPR_PLATFORM_STRING, transport_name));
 
-  for (i = 0; args && i < args->num_args; i++) {
+  for (size_t i = 0; args && i < args->num_args; i++) {
     if (0 == strcmp(args->args[i].key, GRPC_ARG_SECONDARY_USER_AGENT_STRING)) {
       if (args->args[i].type != GRPC_ARG_STRING) {
         gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
                 GRPC_ARG_SECONDARY_USER_AGENT_STRING);
       } else {
-        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
-        is_first = 0;
-        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+        user_agent_fields.push_back(args->args[i].value.string);
       }
     }
   }
 
-  tmp = gpr_strvec_flatten(&v, nullptr);
-  gpr_strvec_destroy(&v);
-  grpc_core::ManagedMemorySlice result(tmp);
-  gpr_free(tmp);
-
-  return result;
+  std::string user_agent_string = absl::StrJoin(user_agent_fields, " ");
+  return grpc_core::ManagedMemorySlice(user_agent_string.c_str());
 }
 
 /* Constructor for channel_data */