grpc 1.41.0.pre2 → 1.42.0

data/src/core/ext/xds/xds_api.h

@@ -27,6 +27,7 @@
 
 #include "absl/container/inlined_vector.h"
 #include "absl/types/optional.h"
+#include "absl/types/variant.h"
 #include "envoy/admin/v3/config_dump.upb.h"
 #include "re2/re2.h"
 #include "upb/def.hpp"
@@ -65,6 +66,29 @@ class XdsApi {
   using TypedPerFilterConfig =
       std::map<std::string, XdsHttpFilterImpl::FilterConfig>;
 
+  struct RetryPolicy {
+    internal::StatusCodeSet retry_on;
+    uint32_t num_retries;
+
+    struct RetryBackOff {
+      Duration base_interval;
+      Duration max_interval;
+
+      bool operator==(const RetryBackOff& other) const {
+        return base_interval == other.base_interval &&
+               max_interval == other.max_interval;
+      }
+      std::string ToString() const;
+    };
+    RetryBackOff retry_back_off;
+
+    bool operator==(const RetryPolicy& other) const {
+      return (retry_on == other.retry_on && num_retries == other.num_retries &&
+              retry_back_off == other.retry_back_off);
+    }
+    std::string ToString() const;
+  };
+
   // TODO(donnadionne): When we can use absl::variant<>, consider using that
   // for: PathMatcher, HeaderMatcher, cluster_name and weighted_clusters
   struct Route {
@@ -82,85 +106,83 @@ class XdsApi {
       std::string ToString() const;
     };
 
-    struct HashPolicy {
-      enum Type { HEADER, CHANNEL_ID };
-      Type type;
-      bool terminal = false;
-      // Fields used for type HEADER.
-      std::string header_name;
-      std::unique_ptr<RE2> regex = nullptr;
-      std::string regex_substitution;
+    Matchers matchers;
 
-      HashPolicy() {}
+    struct UnknownAction {
+      bool operator==(const UnknownAction& /* other */) const { return true; }
+    };
 
-      // Copyable.
-      HashPolicy(const HashPolicy& other);
-      HashPolicy& operator=(const HashPolicy& other);
+    struct RouteAction {
+      struct HashPolicy {
+        enum Type { HEADER, CHANNEL_ID };
+        Type type;
+        bool terminal = false;
+        // Fields used for type HEADER.
+        std::string header_name;
+        std::unique_ptr<RE2> regex = nullptr;
+        std::string regex_substitution;
 
-      // Moveable.
-      HashPolicy(HashPolicy&& other) noexcept;
-      HashPolicy& operator=(HashPolicy&& other) noexcept;
+        HashPolicy() {}
 
-      bool operator==(const HashPolicy& other) const;
-      std::string ToString() const;
-    };
-    Matchers matchers;
-    std::vector<HashPolicy> hash_policies;
+        // Copyable.
+        HashPolicy(const HashPolicy& other);
+        HashPolicy& operator=(const HashPolicy& other);
 
-    struct RetryPolicy {
-      internal::StatusCodeSet retry_on;
-      uint32_t num_retries;
+        // Moveable.
+        HashPolicy(HashPolicy&& other) noexcept;
+        HashPolicy& operator=(HashPolicy&& other) noexcept;
 
-      struct RetryBackOff {
-        Duration base_interval;
-        Duration max_interval;
+        bool operator==(const HashPolicy& other) const;
+        std::string ToString() const;
+      };
+
+      struct ClusterWeight {
+        std::string name;
+        uint32_t weight;
+        TypedPerFilterConfig typed_per_filter_config;
 
-        bool operator==(const RetryBackOff& other) const {
-          return base_interval == other.base_interval &&
-                 max_interval == other.max_interval;
+        bool operator==(const ClusterWeight& other) const {
+          return name == other.name && weight == other.weight &&
+                 typed_per_filter_config == other.typed_per_filter_config;
         }
         std::string ToString() const;
       };
-      RetryBackOff retry_back_off;
 
-      bool operator==(const RetryPolicy& other) const {
-        return (retry_on == other.retry_on &&
-                num_retries == other.num_retries &&
-                retry_back_off == other.retry_back_off);
+      std::vector<HashPolicy> hash_policies;
+      absl::optional<RetryPolicy> retry_policy;
+
+      // Action for this route.
+      // TODO(roth): When we can use absl::variant<>, consider using that
+      // here, to enforce the fact that only one of the two fields can be set.
+      std::string cluster_name;
+      std::vector<ClusterWeight> weighted_clusters;
+      // Storing the timeout duration from route action:
+      // RouteAction.max_stream_duration.grpc_timeout_header_max or
+      // RouteAction.max_stream_duration.max_stream_duration if the former is
+      // not set.
+      absl::optional<Duration> max_stream_duration;
+
+      bool operator==(const RouteAction& other) const {
+        return hash_policies == other.hash_policies &&
+               retry_policy == other.retry_policy &&
+               cluster_name == other.cluster_name &&
+               weighted_clusters == other.weighted_clusters &&
+               max_stream_duration == other.max_stream_duration;
       }
       std::string ToString() const;
     };
-    absl::optional<RetryPolicy> retry_policy;
-
-    // Action for this route.
-    // TODO(roth): When we can use absl::variant<>, consider using that
-    // here, to enforce the fact that only one of the two fields can be set.
-    std::string cluster_name;
-    struct ClusterWeight {
-      std::string name;
-      uint32_t weight;
-      TypedPerFilterConfig typed_per_filter_config;
 
-      bool operator==(const ClusterWeight& other) const {
-        return name == other.name && weight == other.weight &&
-               typed_per_filter_config == other.typed_per_filter_config;
+    struct NonForwardingAction {
+      bool operator==(const NonForwardingAction& /* other */) const {
+        return true;
       }
-      std::string ToString() const;
     };
-    std::vector<ClusterWeight> weighted_clusters;
-    // Storing the timeout duration from route action:
-    // RouteAction.max_stream_duration.grpc_timeout_header_max or
-    // RouteAction.max_stream_duration.max_stream_duration if the former is
-    // not set.
-    absl::optional<Duration> max_stream_duration;
 
+    absl::variant<UnknownAction, RouteAction, NonForwardingAction> action;
     TypedPerFilterConfig typed_per_filter_config;
 
     bool operator==(const Route& other) const {
-      return matchers == other.matchers && cluster_name == other.cluster_name &&
-             retry_policy == other.retry_policy &&
-             weighted_clusters == other.weighted_clusters &&
-             max_stream_duration == other.max_stream_duration &&
+      return matchers == other.matchers && action == other.action &&
              typed_per_filter_config == other.typed_per_filter_config;
     }
     std::string ToString() const;
@@ -301,7 +323,7 @@ class XdsApi {
       }
 
       std::string ToString() const;
-    } filter_chain_data;
+    };
 
     // A multi-level map used to determine which filter chain to use for a given
     // incoming connection. Determining the right filter chain for a given
@@ -386,20 +408,30 @@ class XdsApi {
     std::string ToString() const;
   };
 
+  struct ResourceName {
+    std::string authority;
+    std::string id;
+
+    bool operator<(const ResourceName& other) const {
+      if (authority < other.authority) return true;
+      if (id < other.id) return true;
+      return false;
+    }
+  };
+
   struct LdsResourceData {
     LdsUpdate resource;
     std::string serialized_proto;
   };
 
-  using LdsUpdateMap = std::map<std::string /*server_name*/, LdsResourceData>;
+  using LdsUpdateMap = std::map<ResourceName, LdsResourceData>;
 
   struct RdsResourceData {
     RdsUpdate resource;
     std::string serialized_proto;
   };
 
-  using RdsUpdateMap =
-      std::map<std::string /*route_config_name*/, RdsResourceData>;
+  using RdsUpdateMap = std::map<ResourceName, RdsResourceData>;
 
   struct CdsUpdate {
     enum ClusterType { EDS, LOGICAL_DNS, AGGREGATE };
@@ -455,7 +487,7 @@ class XdsApi {
     std::string serialized_proto;
   };
 
-  using CdsUpdateMap = std::map<std::string /*cluster_name*/, CdsResourceData>;
+  using CdsUpdateMap = std::map<ResourceName, CdsResourceData>;
 
   struct EdsUpdate {
     struct Priority {
@@ -544,8 +576,7 @@ class XdsApi {
     std::string serialized_proto;
   };
 
-  using EdsUpdateMap =
-      std::map<std::string /*eds_service_name*/, EdsResourceData>;
+  using EdsUpdateMap = std::map<ResourceName, EdsResourceData>;
 
   struct ClusterLoadReport {
     XdsClusterDropStats::Snapshot dropped_requests;
@@ -594,13 +625,9 @@ class XdsApi {
     grpc_millis failed_update_time = 0;
   };
   using ResourceMetadataMap =
-      std::map<absl::string_view /*resource_name*/, const ResourceMetadata*>;
-  struct ResourceTypeMetadata {
-    absl::string_view version;
-    ResourceMetadataMap resource_metadata_map;
-  };
+      std::map<std::string /*resource_name*/, const ResourceMetadata*>;
   using ResourceTypeMetadataMap =
-      std::map<absl::string_view /*type_url*/, ResourceTypeMetadata>;
+      std::map<absl::string_view /*type_url*/, ResourceMetadataMap>;
   static_assert(static_cast<ResourceMetadata::ClientResourceStatus>(
                     envoy_admin_v3_REQUESTED) ==
                     ResourceMetadata::ClientResourceStatus::REQUESTED,
@@ -634,28 +661,53 @@ class XdsApi {
     RdsUpdateMap rds_update_map;
     CdsUpdateMap cds_update_map;
     EdsUpdateMap eds_update_map;
-    std::set<std::string> resource_names_failed;
+    std::set<ResourceName> resource_names_failed;
   };
 
   XdsApi(XdsClient* client, TraceFlag* tracer, const XdsBootstrap::Node* node,
          const CertificateProviderStore::PluginDefinitionMap* map);
 
+  static bool IsLds(absl::string_view type_url);
+  static bool IsRds(absl::string_view type_url);
+  static bool IsCds(absl::string_view type_url);
+  static bool IsEds(absl::string_view type_url);
+
+  // A helper method to parse the resource name and return back a ResourceName
+  // struct.  Optionally the parser can check the resource type portion of the
+  // resource name.
+  static absl::StatusOr<ResourceName> ParseResourceName(
+      absl::string_view name,
+      bool (*is_expected_type)(absl::string_view) = nullptr);
+
+  // A helper method to construct the resource name from parts.
+  static std::string ConstructFullResourceName(absl::string_view authority,
+                                               absl::string_view resource_type,
+                                               absl::string_view name);
+
   // Creates an ADS request.
   // Takes ownership of \a error.
-  grpc_slice CreateAdsRequest(const XdsBootstrap::XdsServer& server,
-                              const std::string& type_url,
-                              const std::set<absl::string_view>& resource_names,
-                              const std::string& version,
-                              const std::string& nonce, grpc_error_handle error,
-                              bool populate_node);
+  grpc_slice CreateAdsRequest(
+      const XdsBootstrap::XdsServer& server, const std::string& type_url,
+      const std::map<absl::string_view /*authority*/,
+                     std::set<absl::string_view /*name*/>>& resource_names,
+      const std::string& version, const std::string& nonce,
+      grpc_error_handle error, bool populate_node);
 
   // Parses an ADS response.
   AdsParseResult ParseAdsResponse(
       const XdsBootstrap::XdsServer& server, const grpc_slice& encoded_response,
-      const std::set<absl::string_view>& expected_listener_names,
-      const std::set<absl::string_view>& expected_route_configuration_names,
-      const std::set<absl::string_view>& expected_cluster_names,
-      const std::set<absl::string_view>& expected_eds_service_names);
+      const std::map<absl::string_view /*authority*/,
+                     std::set<absl::string_view /*name*/>>&
+          subscribed_listener_names,
+      const std::map<absl::string_view /*authority*/,
+                     std::set<absl::string_view /*name*/>>&
+          subscribed_route_config_names,
+      const std::map<absl::string_view /*authority*/,
+                     std::set<absl::string_view /*name*/>>&
+          subscribed_cluster_names,
+      const std::map<absl::string_view /*authority*/,
+                     std::set<absl::string_view /*name*/>>&
+          subscribed_eds_service_names);
 
   // Creates an initial LRS request.
   grpc_slice CreateLrsInitialRequest(const XdsBootstrap::XdsServer& server);

data/src/core/ext/xds/xds_bootstrap.h

@@ -64,6 +64,16 @@ class XdsBootstrap {
     Json channel_creds_config;
     std::set<std::string> server_features;
 
+    bool operator<(const XdsServer& other) const {
+      if (server_uri < other.server_uri) return true;
+      if (channel_creds_type < other.channel_creds_type) return true;
+      if (channel_creds_config.Dump() < other.channel_creds_config.Dump()) {
+        return true;
+      }
+      if (server_features < other.server_features) return true;
+      return false;
+    }
+
     bool ShouldUseV3() const;
   };
 

data/src/core/ext/xds/xds_certificate_provider.cc

@@ -23,8 +23,6 @@
 #include "absl/functional/bind_front.h"
 #include "absl/strings/str_cat.h"
 
-#include "src/core/lib/gpr/useful.h"
-
 namespace grpc_core {
 
 namespace {
@@ -379,7 +377,9 @@ void XdsCertificateProviderArgDestroy(void* p) {
   xds_certificate_provider->Unref();
 }
 
-int XdsCertificateProviderArgCmp(void* p, void* q) { return GPR_ICMP(p, q); }
+int XdsCertificateProviderArgCmp(void* p, void* q) {
+  return QsortCompare(p, q);
+}
 
 const grpc_arg_pointer_vtable kChannelArgVtable = {
     XdsCertificateProviderArgCopy, XdsCertificateProviderArgDestroy,

data/src/core/ext/xds/xds_channel_stack_modifier.cc

@@ -0,0 +1,113 @@
+//
+//
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/xds/xds_channel_stack_modifier.h"
+
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/surface/channel_init.h"
+
+namespace grpc_core {
+namespace {
+
+void* XdsChannelStackModifierArgCopy(void* p) {
+  XdsChannelStackModifier* arg = static_cast<XdsChannelStackModifier*>(p);
+  return arg->Ref().release();
+}
+
+void XdsChannelStackModifierArgDestroy(void* p) {
+  XdsChannelStackModifier* arg = static_cast<XdsChannelStackModifier*>(p);
+  arg->Unref();
+}
+
+int XdsChannelStackModifierArgCmp(void* p, void* q) {
+  return QsortCompare(p, q);
+}
+
+const grpc_arg_pointer_vtable kChannelArgVtable = {
+    XdsChannelStackModifierArgCopy, XdsChannelStackModifierArgDestroy,
+    XdsChannelStackModifierArgCmp};
+
+const char* kXdsChannelStackModifierChannelArgName =
+    "grpc.internal.xds_channel_stack_modifier";
+
+}  // namespace
+
+bool XdsChannelStackModifier::ModifyChannelStack(
+    grpc_channel_stack_builder* builder) {
+  // Insert the filters after the census filter if present.
+  grpc_channel_stack_builder_iterator* it =
+      grpc_channel_stack_builder_create_iterator_at_first(builder);
+  while (grpc_channel_stack_builder_move_next(it)) {
+    if (grpc_channel_stack_builder_iterator_is_end(it)) break;
+    const char* filter_name_at_it =
+        grpc_channel_stack_builder_iterator_filter_name(it);
+    if (strcmp("census_server", filter_name_at_it) == 0 ||
+        strcmp("opencensus_server", filter_name_at_it) == 0) {
+      break;
+    }
+  }
+  if (grpc_channel_stack_builder_iterator_is_end(it)) {
+    // No census filter found. Reset iterator to the beginning. This will result
+    // in prepending the list of xDS HTTP filters to the current stack. Note
+    // that this stage is run before the stage that adds the top server filter,
+    // resulting in these filters being finally placed after the `server`
+    // filter.
+    grpc_channel_stack_builder_iterator_destroy(it);
+    it = grpc_channel_stack_builder_create_iterator_at_first(builder);
+  }
+  GPR_ASSERT(grpc_channel_stack_builder_move_next(it));
+  for (const grpc_channel_filter* filter : filters_) {
+    GPR_ASSERT(grpc_channel_stack_builder_add_filter_before(it, filter, nullptr,
+                                                            nullptr));
+  }
+  grpc_channel_stack_builder_iterator_destroy(it);
+  return true;
+}
+
+grpc_arg XdsChannelStackModifier::MakeChannelArg() const {
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(kXdsChannelStackModifierChannelArgName),
+      const_cast<XdsChannelStackModifier*>(this), &kChannelArgVtable);
+}
+
+RefCountedPtr<XdsChannelStackModifier>
+XdsChannelStackModifier::GetFromChannelArgs(const grpc_channel_args& args) {
+  XdsChannelStackModifier* config_selector_provider =
+      grpc_channel_args_find_pointer<XdsChannelStackModifier>(
+          &args, kXdsChannelStackModifierChannelArgName);
+  return config_selector_provider != nullptr ? config_selector_provider->Ref()
+                                             : nullptr;
+}
+
+void RegisterXdsChannelStackModifier(CoreConfiguration::Builder* builder) {
+  builder->channel_init()->RegisterStage(
+      GRPC_SERVER_CHANNEL, INT_MAX, [](grpc_channel_stack_builder* builder) {
+        grpc_core::RefCountedPtr<XdsChannelStackModifier>
+            channel_stack_modifier =
+                XdsChannelStackModifier::GetFromChannelArgs(
+                    *grpc_channel_stack_builder_get_channel_arguments(builder));
+        if (channel_stack_modifier != nullptr) {
+          return channel_stack_modifier->ModifyChannelStack(builder);
+        }
+        return true;
+      });
+}
+
+}  // namespace grpc_core

data/src/core/ext/xds/xds_channel_stack_modifier.h

@@ -0,0 +1,52 @@
+//
+//
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_CORE_EXT_XDS_XDS_CHANNEL_STACK_MODIFIER_H
+#define GRPC_CORE_EXT_XDS_XDS_CHANNEL_STACK_MODIFIER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <vector>
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+
+namespace grpc_core {
+
+// XdsChannelStackModifier allows for inserting xDS HTTP filters into the
+// channel stack. It is registered to mutate the `grpc_channel_stack_builder`
+// object via ChannelInit::Builder::RegisterStage.
+class XdsChannelStackModifier : public RefCounted<XdsChannelStackModifier> {
+ public:
+  explicit XdsChannelStackModifier(
+      std::vector<const grpc_channel_filter*> filters)
+      : filters_(std::move(filters)) {}
+  // Returns true on success, false otherwise.
+  bool ModifyChannelStack(grpc_channel_stack_builder* builder);
+  grpc_arg MakeChannelArg() const;
+  static RefCountedPtr<XdsChannelStackModifier> GetFromChannelArgs(
+      const grpc_channel_args& args);
+
+ private:
+  std::vector<const grpc_channel_filter*> filters_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_XDS_XDS_CHANNEL_STACK_MODIFIER_H */