grpc 1.24.0 → 1.25.0.pre1

data/src/core/ext/filters/client_channel/subchannel.h

@@ -77,9 +77,9 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
       RefCountedPtr<channelz::SubchannelNode> channelz_subchannel);
   ~ConnectedSubchannel();
 
-  void NotifyOnStateChange(grpc_pollset_set* interested_parties,
-                           grpc_connectivity_state* state,
-                           grpc_closure* closure);
+  void StartWatch(grpc_pollset_set* interested_parties,
+                  OrphanablePtr<ConnectivityStateWatcherInterface> watcher);
+
   void Ping(grpc_closure* on_initiate, grpc_closure* on_ack);
 
   grpc_channel_stack* channel_stack() const { return channel_stack_; }
@@ -192,11 +192,9 @@ class Subchannel {
     virtual void OnConnectivityStateChange(
         grpc_connectivity_state new_state,
         RefCountedPtr<ConnectedSubchannel> connected_subchannel)  // NOLINT
-        GRPC_ABSTRACT;
-
-    virtual grpc_pollset_set* interested_parties() GRPC_ABSTRACT;
+        = 0;
 
-    GRPC_ABSTRACT_BASE_CLASS
+    virtual grpc_pollset_set* interested_parties() = 0;
   };
 
   // The ctor and dtor are not intended to use directly.
@@ -294,8 +292,8 @@ class Subchannel {
     bool empty() const { return watchers_.empty(); }
 
    private:
-    // TODO(roth): This could be a set instead of a map if we had a set
-    // implementation.
+    // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
+    // be a set instead of a map.
     Map<ConnectivityStateWatcherInterface*,
         OrphanablePtr<ConnectivityStateWatcherInterface>>
         watchers_;

data/src/core/ext/filters/client_channel/subchannel_interface.h

@@ -36,14 +36,12 @@ class SubchannelInterface : public RefCounted<SubchannelInterface> {
     // Will be invoked whenever the subchannel's connectivity state
     // changes.  There will be only one invocation of this method on a
     // given watcher instance at any given time.
-    virtual void OnConnectivityStateChange(grpc_connectivity_state new_state)
-        GRPC_ABSTRACT;
+    virtual void OnConnectivityStateChange(
+        grpc_connectivity_state new_state) = 0;
 
     // TODO(roth): Remove this as soon as we move to EventManager-based
     // polling.
-    virtual grpc_pollset_set* interested_parties() GRPC_ABSTRACT;
-
-    GRPC_ABSTRACT_BASE_CLASS
+    virtual grpc_pollset_set* interested_parties() = 0;
   };
 
   template <typename TraceFlagT = TraceFlag>
@@ -53,7 +51,7 @@ class SubchannelInterface : public RefCounted<SubchannelInterface> {
   virtual ~SubchannelInterface() = default;
 
   // Returns the current connectivity state of the subchannel.
-  virtual grpc_connectivity_state CheckConnectivityState() GRPC_ABSTRACT;
+  virtual grpc_connectivity_state CheckConnectivityState() = 0;
 
   // Starts watching the subchannel's connectivity state.
   // The first callback to the watcher will be delivered when the
@@ -68,29 +66,27 @@ class SubchannelInterface : public RefCounted<SubchannelInterface> {
   // the previous watcher using CancelConnectivityStateWatch().
   virtual void WatchConnectivityState(
       grpc_connectivity_state initial_state,
-      UniquePtr<ConnectivityStateWatcherInterface> watcher) GRPC_ABSTRACT;
+      UniquePtr<ConnectivityStateWatcherInterface> watcher) = 0;
 
   // Cancels a connectivity state watch.
   // If the watcher has already been destroyed, this is a no-op.
   virtual void CancelConnectivityStateWatch(
-      ConnectivityStateWatcherInterface* watcher) GRPC_ABSTRACT;
+      ConnectivityStateWatcherInterface* watcher) = 0;
 
   // Attempt to connect to the backend.  Has no effect if already connected.
   // If the subchannel is currently in backoff delay due to a previously
   // failed attempt, the new connection attempt will not start until the
   // backoff delay has elapsed.
-  virtual void AttemptToConnect() GRPC_ABSTRACT;
+  virtual void AttemptToConnect() = 0;
 
   // Resets the subchannel's connection backoff state.  If AttemptToConnect()
   // has been called since the subchannel entered TRANSIENT_FAILURE state,
   // starts a new connection attempt immediately; otherwise, a new connection
   // attempt will be started as soon as AttemptToConnect() is called.
-  virtual void ResetBackoff() GRPC_ABSTRACT;
+  virtual void ResetBackoff() = 0;
 
   // TODO(roth): Need a better non-grpc-specific abstraction here.
-  virtual const grpc_channel_args* channel_args() GRPC_ABSTRACT;
-
-  GRPC_ABSTRACT_BASE_CLASS
+  virtual const grpc_channel_args* channel_args() = 0;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/subchannel_pool_interface.h

@@ -23,7 +23,6 @@
 
 #include "src/core/lib/avl/avl.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 
 namespace grpc_core {
@@ -70,14 +69,14 @@ class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
   // with \a key, which may be different from \a constructed because we reuse
   // (instead of update) any existing subchannel already registered with \a key.
   virtual Subchannel* RegisterSubchannel(SubchannelKey* key,
-                                         Subchannel* constructed) GRPC_ABSTRACT;
+                                         Subchannel* constructed) = 0;
 
   // Removes the registered subchannel found by \a key.
-  virtual void UnregisterSubchannel(SubchannelKey* key) GRPC_ABSTRACT;
+  virtual void UnregisterSubchannel(SubchannelKey* key) = 0;
 
   // Finds the subchannel registered for the given subchannel key. Returns NULL
   // if no such channel exists. Thread-safe.
-  virtual Subchannel* FindSubchannel(SubchannelKey* key) GRPC_ABSTRACT;
+  virtual Subchannel* FindSubchannel(SubchannelKey* key) = 0;
 
   // Creates a channel arg from \a subchannel pool.
   static grpc_arg CreateChannelArg(SubchannelPoolInterface* subchannel_pool);
@@ -85,8 +84,6 @@ class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
   // Gets the subchannel pool from the channel args.
   static SubchannelPoolInterface* GetSubchannelPoolFromChannelArgs(
       const grpc_channel_args* args);
-
-  GRPC_ABSTRACT_BASE_CLASS
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/{lb_policy/xds/xds_load_balancer_api.cc → xds/xds_api.cc}

@@ -24,7 +24,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_load_balancer_api.h"
+#include "src/core/ext/filters/client_channel/xds/xds_api.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 
@@ -49,15 +49,49 @@ namespace {
 
 constexpr char kEdsTypeUrl[] =
     "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment";
-constexpr char kEndpointRequired[] = "endpointRequired";
 
 }  // namespace
 
+bool XdsPriorityListUpdate::operator==(
+    const XdsPriorityListUpdate& other) const {
+  if (priorities_.size() != other.priorities_.size()) return false;
+  for (size_t i = 0; i < priorities_.size(); ++i) {
+    if (priorities_[i].localities != other.priorities_[i].localities) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void XdsPriorityListUpdate::Add(
+    XdsPriorityListUpdate::LocalityMap::Locality locality) {
+  // Pad the missing priorities in case the localities are not ordered by
+  // priority.
+  if (!Contains(locality.priority)) priorities_.resize(locality.priority + 1);
+  LocalityMap& locality_map = priorities_[locality.priority];
+  locality_map.localities.emplace(locality.name, std::move(locality));
+}
+
+const XdsPriorityListUpdate::LocalityMap* XdsPriorityListUpdate::Find(
+    uint32_t priority) const {
+  if (!Contains(priority)) return nullptr;
+  return &priorities_[priority];
+}
+
+bool XdsPriorityListUpdate::Contains(
+    const RefCountedPtr<XdsLocalityName>& name) {
+  for (size_t i = 0; i < priorities_.size(); ++i) {
+    const LocalityMap& locality_map = priorities_[i];
+    if (locality_map.Contains(name)) return true;
+  }
+  return false;
+}
+
 bool XdsDropConfig::ShouldDrop(const UniquePtr<char>** category_name) const {
   for (size_t i = 0; i < drop_category_list_.size(); ++i) {
     const auto& drop_category = drop_category_list_[i];
     // Generate a random number in [0, 1000000).
-    const int random = rand() % 1000000;
+    const uint32_t random = static_cast<uint32_t>(rand()) % 1000000;
     if (random < drop_category.parts_per_million) {
       *category_name = &drop_category.name;
       return true;
@@ -66,24 +100,115 @@ bool XdsDropConfig::ShouldDrop(const UniquePtr<char>** category_name) const {
   return false;
 }
 
-grpc_slice XdsEdsRequestCreateAndEncode(const char* service_name) {
+namespace {
+
+void PopulateMetadataValue(upb_arena* arena, google_protobuf_Value* value_pb,
+                           const XdsBootstrap::MetadataValue& value);
+
+void PopulateListValue(upb_arena* arena, google_protobuf_ListValue* list_value,
+                       const std::vector<XdsBootstrap::MetadataValue>& values) {
+  for (const auto& value : values) {
+    auto* value_pb = google_protobuf_ListValue_add_values(list_value, arena);
+    PopulateMetadataValue(arena, value_pb, value);
+  }
+}
+
+void PopulateMetadata(
+    upb_arena* arena, google_protobuf_Struct* metadata_pb,
+    const Map<const char*, XdsBootstrap::MetadataValue, StringLess>& metadata) {
+  for (const auto& p : metadata) {
+    google_protobuf_Struct_FieldsEntry* field =
+        google_protobuf_Struct_add_fields(metadata_pb, arena);
+    google_protobuf_Struct_FieldsEntry_set_key(field,
+                                               upb_strview_makez(p.first));
+    google_protobuf_Value* value =
+        google_protobuf_Struct_FieldsEntry_mutable_value(field, arena);
+    PopulateMetadataValue(arena, value, p.second);
+  }
+}
+
+void PopulateMetadataValue(upb_arena* arena, google_protobuf_Value* value_pb,
+                           const XdsBootstrap::MetadataValue& value) {
+  switch (value.type) {
+    case XdsBootstrap::MetadataValue::Type::MD_NULL:
+      google_protobuf_Value_set_null_value(value_pb, 0);
+      break;
+    case XdsBootstrap::MetadataValue::Type::DOUBLE:
+      google_protobuf_Value_set_number_value(value_pb, value.double_value);
+      break;
+    case XdsBootstrap::MetadataValue::Type::STRING:
+      google_protobuf_Value_set_string_value(
+          value_pb, upb_strview_makez(value.string_value));
+      break;
+    case XdsBootstrap::MetadataValue::Type::BOOL:
+      google_protobuf_Value_set_bool_value(value_pb, value.bool_value);
+      break;
+    case XdsBootstrap::MetadataValue::Type::STRUCT: {
+      google_protobuf_Struct* struct_value =
+          google_protobuf_Value_mutable_struct_value(value_pb, arena);
+      PopulateMetadata(arena, struct_value, value.struct_value);
+      break;
+    }
+    case XdsBootstrap::MetadataValue::Type::LIST: {
+      google_protobuf_ListValue* list_value =
+          google_protobuf_Value_mutable_list_value(value_pb, arena);
+      PopulateListValue(arena, list_value, value.list_value);
+      break;
+    }
+  }
+}
+
+void PopulateNode(upb_arena* arena, const XdsBootstrap::Node* node,
+                  const char* build_version, envoy_api_v2_core_Node* node_msg) {
+  if (node != nullptr) {
+    if (node->id != nullptr) {
+      envoy_api_v2_core_Node_set_id(node_msg, upb_strview_makez(node->id));
+    }
+    if (node->cluster != nullptr) {
+      envoy_api_v2_core_Node_set_cluster(node_msg,
+                                         upb_strview_makez(node->cluster));
+    }
+    if (!node->metadata.empty()) {
+      google_protobuf_Struct* metadata =
+          envoy_api_v2_core_Node_mutable_metadata(node_msg, arena);
+      PopulateMetadata(arena, metadata, node->metadata);
+    }
+    if (node->locality_region != nullptr || node->locality_zone != nullptr ||
+        node->locality_subzone != nullptr) {
+      envoy_api_v2_core_Locality* locality =
+          envoy_api_v2_core_Node_mutable_locality(node_msg, arena);
+      if (node->locality_region != nullptr) {
+        envoy_api_v2_core_Locality_set_region(
+            locality, upb_strview_makez(node->locality_region));
+      }
+      if (node->locality_zone != nullptr) {
+        envoy_api_v2_core_Locality_set_zone(
+            locality, upb_strview_makez(node->locality_zone));
+      }
+      if (node->locality_subzone != nullptr) {
+        envoy_api_v2_core_Locality_set_sub_zone(
+            locality, upb_strview_makez(node->locality_subzone));
+      }
+    }
+  }
+  envoy_api_v2_core_Node_set_build_version(node_msg,
+                                           upb_strview_makez(build_version));
+}
+
+}  // namespace
+
+grpc_slice XdsEdsRequestCreateAndEncode(const char* server_name,
+                                        const XdsBootstrap::Node* node,
+                                        const char* build_version) {
   upb::Arena arena;
   // Create a request.
   envoy_api_v2_DiscoveryRequest* request =
       envoy_api_v2_DiscoveryRequest_new(arena.ptr());
-  envoy_api_v2_core_Node* node =
+  envoy_api_v2_core_Node* node_msg =
       envoy_api_v2_DiscoveryRequest_mutable_node(request, arena.ptr());
-  google_protobuf_Struct* metadata =
-      envoy_api_v2_core_Node_mutable_metadata(node, arena.ptr());
-  google_protobuf_Struct_FieldsEntry* field =
-      google_protobuf_Struct_add_fields(metadata, arena.ptr());
-  google_protobuf_Struct_FieldsEntry_set_key(
-      field, upb_strview_makez(kEndpointRequired));
-  google_protobuf_Value* value =
-      google_protobuf_Struct_FieldsEntry_mutable_value(field, arena.ptr());
-  google_protobuf_Value_set_bool_value(value, true);
+  PopulateNode(arena.ptr(), node, build_version, node_msg);
   envoy_api_v2_DiscoveryRequest_add_resource_names(
-      request, upb_strview_makez(service_name), arena.ptr());
+      request, upb_strview_makez(server_name), arena.ptr());
   envoy_api_v2_DiscoveryRequest_set_type_url(request,
                                              upb_strview_makez(kEdsTypeUrl));
   // Encode the request.
@@ -136,7 +261,7 @@ UniquePtr<char> StringCopy(const upb_strview& strview) {
 
 grpc_error* LocalityParse(
     const envoy_api_v2_endpoint_LocalityLbEndpoints* locality_lb_endpoints,
-    XdsLocalityInfo* locality_info) {
+    XdsPriorityListUpdate::LocalityMap::Locality* output_locality) {
   // Parse LB weight.
   const google_protobuf_UInt32Value* lb_weight =
       envoy_api_v2_endpoint_LocalityLbEndpoints_load_balancing_weight(
@@ -144,13 +269,13 @@ grpc_error* LocalityParse(
   // If LB weight is not specified, it means this locality is assigned no load.
   // TODO(juanlishen): When we support CDS to configure the inter-locality
   // policy, we should change the LB weight handling.
-  locality_info->lb_weight =
+  output_locality->lb_weight =
       lb_weight != nullptr ? google_protobuf_UInt32Value_value(lb_weight) : 0;
-  if (locality_info->lb_weight == 0) return GRPC_ERROR_NONE;
+  if (output_locality->lb_weight == 0) return GRPC_ERROR_NONE;
   // Parse locality name.
   const envoy_api_v2_core_Locality* locality =
       envoy_api_v2_endpoint_LocalityLbEndpoints_locality(locality_lb_endpoints);
-  locality_info->locality_name = MakeRefCounted<XdsLocalityName>(
+  output_locality->name = MakeRefCounted<XdsLocalityName>(
       StringCopy(envoy_api_v2_core_Locality_region(locality)),
       StringCopy(envoy_api_v2_core_Locality_zone(locality)),
       StringCopy(envoy_api_v2_core_Locality_sub_zone(locality)));
@@ -160,12 +285,12 @@ grpc_error* LocalityParse(
       envoy_api_v2_endpoint_LocalityLbEndpoints_lb_endpoints(
           locality_lb_endpoints, &size);
   for (size_t i = 0; i < size; ++i) {
-    grpc_error* error = ServerAddressParseAndAppend(lb_endpoints[i],
-                                                    &locality_info->serverlist);
+    grpc_error* error = ServerAddressParseAndAppend(
+        lb_endpoints[i], &output_locality->serverlist);
     if (error != GRPC_ERROR_NONE) return error;
   }
   // Parse the priority.
-  locality_info->priority =
+  output_locality->priority =
       envoy_api_v2_endpoint_LocalityLbEndpoints_priority(locality_lb_endpoints);
   return GRPC_ERROR_NONE;
 }
@@ -211,7 +336,7 @@ grpc_error* DropParseAndAppend(
 }  // namespace
 
 grpc_error* XdsEdsResponseDecodeAndParse(const grpc_slice& encoded_response,
-                                         XdsUpdate* update) {
+                                         EdsUpdate* update) {
   upb::Arena arena;
   // Decode the response.
   const envoy_api_v2_DiscoveryResponse* response =
@@ -253,18 +378,13 @@ grpc_error* XdsEdsResponseDecodeAndParse(const grpc_slice& encoded_response,
       envoy_api_v2_ClusterLoadAssignment_endpoints(cluster_load_assignment,
                                                    &size);
   for (size_t i = 0; i < size; ++i) {
-    XdsLocalityInfo locality_info;
-    grpc_error* error = LocalityParse(endpoints[i], &locality_info);
+    XdsPriorityListUpdate::LocalityMap::Locality locality;
+    grpc_error* error = LocalityParse(endpoints[i], &locality);
     if (error != GRPC_ERROR_NONE) return error;
     // Filter out locality with weight 0.
-    if (locality_info.lb_weight == 0) continue;
-    update->locality_list.push_back(std::move(locality_info));
+    if (locality.lb_weight == 0) continue;
+    update->priority_list_update.Add(locality);
   }
-  // The locality list is sorted here into deterministic order so that it's
-  // easier to check if two locality lists contain the same set of localities.
-  std::sort(update->locality_list.data(),
-            update->locality_list.data() + update->locality_list.size(),
-            XdsLocalityInfo::Less());
   // Get the drop config.
   update->drop_config = MakeRefCounted<XdsDropConfig>();
   const envoy_api_v2_ClusterLoadAssignment_Policy* policy =
@@ -296,11 +416,18 @@ grpc_slice LrsRequestEncode(
 
 }  // namespace
 
-grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name) {
+grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
+                                        const XdsBootstrap::Node* node,
+                                        const char* build_version) {
   upb::Arena arena;
   // Create a request.
   envoy_service_load_stats_v2_LoadStatsRequest* request =
       envoy_service_load_stats_v2_LoadStatsRequest_new(arena.ptr());
+  // Populate node.
+  envoy_api_v2_core_Node* node_msg =
+      envoy_service_load_stats_v2_LoadStatsRequest_mutable_node(request,
+                                                                arena.ptr());
+  PopulateNode(arena.ptr(), node, build_version, node_msg);
   // Add cluster stats. There is only one because we only use one server name in
   // one channel.
   envoy_api_v2_endpoint_ClusterStats* cluster_stats =
@@ -314,18 +441,11 @@ grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name) {
 
 namespace {
 
-void LocalityStatsPopulate(envoy_api_v2_endpoint_UpstreamLocalityStats* output,
-#if GRPC_USE_CPP_STD_LIB
-                           // TODO(veblush): Clean up this
-                           // This is to address the difference between
-                           // std::map and Map. #else block will be gone
-                           // once using stdlib is enabled by default.
-                           Pair<const RefCountedPtr<XdsLocalityName>,
-#else
-                           Pair<RefCountedPtr<XdsLocalityName>,
-#endif
-                                XdsClientStats::LocalityStats::Snapshot>& input,
-                           upb_arena* arena) {
+void LocalityStatsPopulate(
+    envoy_api_v2_endpoint_UpstreamLocalityStats* output,
+    std::pair<const RefCountedPtr<XdsLocalityName>,
+              XdsClientStats::LocalityStats::Snapshot>& input,
+    upb_arena* arena) {
   // Set sub_zone.
   envoy_api_v2_core_Locality* locality =
       envoy_api_v2_endpoint_UpstreamLocalityStats_mutable_locality(output,
@@ -414,8 +534,8 @@ grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
 }
 
 grpc_error* XdsLrsResponseDecodeAndParse(const grpc_slice& encoded_response,
-                                         grpc_millis* load_reporting_interval,
-                                         const char* expected_server_name) {
+                                         UniquePtr<char>* cluster_name,
+                                         grpc_millis* load_reporting_interval) {
   upb::Arena arena;
   // Decode the response.
   const envoy_service_load_stats_v2_LoadStatsResponse* decoded_response =
@@ -435,11 +555,8 @@ grpc_error* XdsLrsResponseDecodeAndParse(const grpc_slice& encoded_response,
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "The number of clusters (server names) is not 1.");
   }
-  // Check the cluster name in the response
-  if (strncmp(expected_server_name, clusters[0].data, clusters[0].size) != 0) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Unexpected cluster (server name).");
-  }
+  // Get the cluster name for reporting loads.
+  *cluster_name = StringCopy(clusters[0]);
   // Get the load report interval.
   const google_protobuf_Duration* load_reporting_interval_duration =
       envoy_service_load_stats_v2_LoadStatsResponse_load_reporting_interval(