grpc 1.36.0 → 1.38.0

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -19,6 +19,7 @@
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
@@ -47,15 +48,15 @@ class GoogleCloud2ProdResolver : public Resolver {
     void Orphan() override;
 
    private:
-    static void OnHttpRequestDone(void* arg, grpc_error* error);
+    static void OnHttpRequestDone(void* arg, grpc_error_handle error);
 
     // Calls OnDone() if not already called.  Releases a ref.
-    void MaybeCallOnDone(grpc_error* error);
+    void MaybeCallOnDone(grpc_error_handle error);
 
     // If error is not GRPC_ERROR_NONE, then it's not safe to look at response.
     virtual void OnDone(GoogleCloud2ProdResolver* resolver,
                         const grpc_http_response* response,
-                        grpc_error* error) = 0;
+                        grpc_error_handle error) = 0;
 
     RefCountedPtr<GoogleCloud2ProdResolver> resolver_;
     grpc_httpcli_context context_;
@@ -72,7 +73,8 @@ class GoogleCloud2ProdResolver : public Resolver {
 
    private:
     void OnDone(GoogleCloud2ProdResolver* resolver,
-                const grpc_http_response* response, grpc_error* error) override;
+                const grpc_http_response* response,
+                grpc_error_handle error) override;
   };
 
   // A metadata server query to get the IPv6 address.
@@ -83,7 +85,8 @@ class GoogleCloud2ProdResolver : public Resolver {
 
    private:
     void OnDone(GoogleCloud2ProdResolver* resolver,
-                const grpc_http_response* response, grpc_error* error) override;
+                const grpc_http_response* response,
+                grpc_error_handle error) override;
   };
 
   void ZoneQueryDone(std::string zone);
@@ -142,13 +145,13 @@ void GoogleCloud2ProdResolver::MetadataQuery::Orphan() {
 }
 
 void GoogleCloud2ProdResolver::MetadataQuery::OnHttpRequestDone(
-    void* arg, grpc_error* error) {
+    void* arg, grpc_error_handle error) {
   auto* self = static_cast<MetadataQuery*>(arg);
   self->MaybeCallOnDone(GRPC_ERROR_REF(error));
 }
 
 void GoogleCloud2ProdResolver::MetadataQuery::MaybeCallOnDone(
-    grpc_error* error) {
+    grpc_error_handle error) {
   bool expected = false;
   if (!on_done_called_.CompareExchangeStrong(
           &expected, true, MemoryOrder::RELAXED, MemoryOrder::RELAXED)) {
@@ -179,10 +182,10 @@ GoogleCloud2ProdResolver::ZoneQuery::ZoneQuery(
 
 void GoogleCloud2ProdResolver::ZoneQuery::OnDone(
     GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
-    grpc_error* error) {
+    grpc_error_handle error) {
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "error fetching zone from metadata server: %s",
-            grpc_error_string(error));
+            grpc_error_std_string(error).c_str());
   }
   std::string zone;
   if (error == GRPC_ERROR_NONE && response->status == 200) {
@@ -212,10 +215,10 @@ GoogleCloud2ProdResolver::IPv6Query::IPv6Query(
 
 void GoogleCloud2ProdResolver::IPv6Query::OnDone(
     GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
-    grpc_error* error) {
+    grpc_error_handle error) {
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "error fetching IPv6 address from metadata server: %s",
-            grpc_error_string(error));
+            grpc_error_std_string(error).c_str());
   }
   resolver->IPv6QueryDone(error == GRPC_ERROR_NONE && response->status == 200);
   GRPC_ERROR_UNREF(error);
@@ -307,17 +310,25 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
         {"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", true},
     };
   }
+  // Allow the TD server uri to be overridden for testing purposes.
+  UniquePtr<char> override_server(
+      gpr_getenv("GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI"));
+  const char* server_uri =
+      override_server != nullptr && strlen(override_server.get()) > 0
+          ? override_server.get()
+          : "directpath-trafficdirector.googleapis.com";
   Json bootstrap = Json::Object{
       {"xds_servers",
        Json::Array{
            Json::Object{
-               {"server_uri", "directpath-trafficdirector.googleapis.com"},
+               {"server_uri", server_uri},
                {"channel_creds",
                 Json::Array{
                     Json::Object{
                         {"type", "google_default"},
                     },
                 }},
+               {"server_features", Json::Array{"xds_v3"}},
            },
        }},
       {"node", std::move(node)},
@@ -353,8 +364,14 @@ class GoogleCloud2ProdResolverFactory : public ResolverFactory {
 }  // namespace
 
 void GoogleCloud2ProdResolverInit() {
-  ResolverRegistry::Builder::RegisterResolverFactory(
-      absl::make_unique<GoogleCloud2ProdResolverFactory>());
+  // TODO(roth): Remove env var protection once this code is proven stable.
+  UniquePtr<char> value(gpr_getenv("GRPC_EXPERIMENTAL_GOOGLE_C2P_RESOLVER"));
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value.get(), &parsed_value);
+  if (parse_succeeded && parsed_value) {
+    ResolverRegistry::Builder::RegisterResolverFactory(
+        absl::make_unique<GoogleCloud2ProdResolverFactory>());
+  }
 }
 
 void GoogleCloud2ProdResolverShutdown() {}

data/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc

@@ -30,9 +30,9 @@
 
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/filters/client_channel/server_address.h"
+#include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/parse_address.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/slice/slice_internal.h"

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -22,13 +22,19 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "re2/re2.h"
+#define XXH_INLINE_ALL
+#include "xxhash.h"
 
 #include "src/core/ext/filters/client_channel/config_selector.h"
+#include "src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
+#include "src/core/ext/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/surface/lame_client.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 
 namespace grpc_core {
@@ -68,19 +74,23 @@ class XdsResolver : public Resolver {
 
   void ShutdownLocked() override;
 
+  void ResetBackoffLocked() override {
+    if (xds_client_ != nullptr) xds_client_->ResetBackoff();
+  }
+
  private:
   class Notifier {
    public:
     Notifier(RefCountedPtr<XdsResolver> resolver, XdsApi::LdsUpdate update);
     Notifier(RefCountedPtr<XdsResolver> resolver, XdsApi::RdsUpdate update);
-    Notifier(RefCountedPtr<XdsResolver> resolver, grpc_error* error);
+    Notifier(RefCountedPtr<XdsResolver> resolver, grpc_error_handle error);
     explicit Notifier(RefCountedPtr<XdsResolver> resolver);
 
    private:
     enum Type { kLdsUpdate, kRdsUpdate, kError, kDoesNotExist };
 
-    static void RunInExecCtx(void* arg, grpc_error* error);
-    void RunInWorkSerializer(grpc_error* error);
+    static void RunInExecCtx(void* arg, grpc_error_handle error);
+    void RunInWorkSerializer(grpc_error_handle error);
 
     RefCountedPtr<XdsResolver> resolver_;
     grpc_closure closure_;
@@ -95,7 +105,9 @@ class XdsResolver : public Resolver {
     void OnListenerChanged(XdsApi::LdsUpdate listener) override {
       new Notifier(resolver_, std::move(listener));
     }
-    void OnError(grpc_error* error) override { new Notifier(resolver_, error); }
+    void OnError(grpc_error_handle error) override {
+      new Notifier(resolver_, error);
+    }
     void OnResourceDoesNotExist() override { new Notifier(resolver_); }
 
    private:
@@ -109,7 +121,9 @@ class XdsResolver : public Resolver {
     void OnRouteConfigChanged(XdsApi::RdsUpdate route_config) override {
       new Notifier(resolver_, std::move(route_config));
     }
-    void OnError(grpc_error* error) override { new Notifier(resolver_, error); }
+    void OnError(grpc_error_handle error) override {
+      new Notifier(resolver_, error);
+    }
     void OnResourceDoesNotExist() override { new Notifier(resolver_); }
 
    private:
@@ -117,7 +131,7 @@ class XdsResolver : public Resolver {
   };
 
   class ClusterState
-      : public RefCounted<ClusterState, PolymorphicRefCount, false> {
+      : public RefCounted<ClusterState, PolymorphicRefCount, kUnrefNoDelete> {
    public:
     using ClusterStateMap =
         std::map<std::string, std::unique_ptr<ClusterState>>;
@@ -136,8 +150,7 @@ class XdsResolver : public Resolver {
   class XdsConfigSelector : public ConfigSelector {
    public:
     XdsConfigSelector(RefCountedPtr<XdsResolver> resolver,
-                      const std::vector<XdsApi::Route>& routes,
-                      grpc_error* error);
+                      grpc_error_handle* error);
     ~XdsConfigSelector() override;
 
     const char* name() const override { return "XdsConfigSelector"; }
@@ -151,34 +164,50 @@ class XdsResolver : public Resolver {
 
     CallConfig GetCallConfig(GetCallConfigArgs args) override;
 
+    std::vector<const grpc_channel_filter*> GetFilters() override {
+      return filters_;
+    }
+
+    grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) override;
+
    private:
     struct Route {
+      struct ClusterWeightState {
+        uint32_t range_end;
+        absl::string_view cluster;
+        RefCountedPtr<ServiceConfig> method_config;
+
+        bool operator==(const ClusterWeightState& other) const;
+      };
+
       XdsApi::Route route;
-      absl::InlinedVector<std::pair<uint32_t, absl::string_view>, 2>
-          weighted_cluster_state;
       RefCountedPtr<ServiceConfig> method_config;
-      bool operator==(const Route& other) const {
-        return route == other.route &&
-               weighted_cluster_state == other.weighted_cluster_state;
-      }
+      absl::InlinedVector<ClusterWeightState, 2> weighted_cluster_state;
+
+      bool operator==(const Route& other) const;
     };
     using RouteTable = std::vector<Route>;
 
     void MaybeAddCluster(const std::string& name);
-    grpc_error* CreateMethodConfig(RefCountedPtr<ServiceConfig>* method_config,
-                                   const XdsApi::Route& route);
+    grpc_error_handle CreateMethodConfig(
+        const XdsApi::Route& route,
+        const XdsApi::Route::ClusterWeight* cluster_weight,
+        RefCountedPtr<ServiceConfig>* method_config);
 
     RefCountedPtr<XdsResolver> resolver_;
     RouteTable route_table_;
     std::map<absl::string_view, RefCountedPtr<ClusterState>> clusters_;
+    std::vector<const grpc_channel_filter*> filters_;
+    grpc_error_handle filter_error_ = GRPC_ERROR_NONE;
   };
 
   void OnListenerUpdate(XdsApi::LdsUpdate listener);
   void OnRouteConfigUpdate(XdsApi::RdsUpdate rds_update);
-  void OnError(grpc_error* error);
+  void OnError(grpc_error_handle error);
   void OnResourceDoesNotExist();
 
-  grpc_error* CreateServiceConfig(RefCountedPtr<ServiceConfig>* service_config);
+  grpc_error_handle CreateServiceConfig(
+      RefCountedPtr<ServiceConfig>* service_config);
   void GenerateResult();
   void MaybeRemoveUnusedClusters();
 
@@ -187,13 +216,20 @@ class XdsResolver : public Resolver {
   std::string server_name_;
   const grpc_channel_args* args_;
   grpc_pollset_set* interested_parties_;
+
   RefCountedPtr<XdsClient> xds_client_;
+
   XdsClient::ListenerWatcherInterface* listener_watcher_ = nullptr;
+  // This will not contain the RouteConfiguration, even if it comes with the
+  // LDS response; instead, the relevant VirtualHost from the
+  // RouteConfiguration will be saved in current_virtual_host_.
+  XdsApi::LdsUpdate current_listener_;
+
   std::string route_config_name_;
   XdsClient::RouteConfigWatcherInterface* route_config_watcher_ = nullptr;
+  XdsApi::RdsUpdate::VirtualHost current_virtual_host_;
+
   ClusterState::ClusterStateMap cluster_state_map_;
-  std::vector<XdsApi::Route> current_update_;
-  XdsApi::Duration http_max_stream_duration_;
 };
 
 //
@@ -212,13 +248,13 @@ XdsResolver::Notifier::Notifier(RefCountedPtr<XdsResolver> resolver,
 XdsResolver::Notifier::Notifier(RefCountedPtr<XdsResolver> resolver,
                                 XdsApi::RdsUpdate update)
     : resolver_(std::move(resolver)), type_(kRdsUpdate) {
-  update_.rds_update = std::move(update);
+  update_.http_connection_manager.rds_update = std::move(update);
   GRPC_CLOSURE_INIT(&closure_, &RunInExecCtx, this, nullptr);
   ExecCtx::Run(DEBUG_LOCATION, &closure_, GRPC_ERROR_NONE);
 }
 
 XdsResolver::Notifier::Notifier(RefCountedPtr<XdsResolver> resolver,
-                                grpc_error* error)
+                                grpc_error_handle error)
     : resolver_(std::move(resolver)), type_(kError) {
   GRPC_CLOSURE_INIT(&closure_, &RunInExecCtx, this, nullptr);
   ExecCtx::Run(DEBUG_LOCATION, &closure_, error);
@@ -230,14 +266,14 @@ XdsResolver::Notifier::Notifier(RefCountedPtr<XdsResolver> resolver)
   ExecCtx::Run(DEBUG_LOCATION, &closure_, GRPC_ERROR_NONE);
 }
 
-void XdsResolver::Notifier::RunInExecCtx(void* arg, grpc_error* error) {
+void XdsResolver::Notifier::RunInExecCtx(void* arg, grpc_error_handle error) {
   Notifier* self = static_cast<Notifier*>(arg);
   GRPC_ERROR_REF(error);
   self->resolver_->work_serializer_->Run(
       [self, error]() { self->RunInWorkSerializer(error); }, DEBUG_LOCATION);
 }
 
-void XdsResolver::Notifier::RunInWorkSerializer(grpc_error* error) {
+void XdsResolver::Notifier::RunInWorkSerializer(grpc_error_handle error) {
   if (resolver_->xds_client_ == nullptr) {
     GRPC_ERROR_UNREF(error);
     delete this;
@@ -248,7 +284,8 @@ void XdsResolver::Notifier::RunInWorkSerializer(grpc_error* error) {
       resolver_->OnListenerUpdate(std::move(update_));
       break;
     case kRdsUpdate:
-      resolver_->OnRouteConfigUpdate(std::move(*update_.rds_update));
+      resolver_->OnRouteConfigUpdate(
+          std::move(*update_.http_connection_manager.rds_update));
       break;
     case kError:
       resolver_->OnError(error);
@@ -260,13 +297,35 @@ void XdsResolver::Notifier::RunInWorkSerializer(grpc_error* error) {
   delete this;
 }
 
+//
+// XdsResolver::XdsConfigSelector::Route
+//
+
+bool MethodConfigsEqual(const ServiceConfig* sc1, const ServiceConfig* sc2) {
+  if (sc1 == nullptr) return sc2 == nullptr;
+  if (sc2 == nullptr) return false;
+  return sc1->json_string() == sc2->json_string();
+}
+
+bool XdsResolver::XdsConfigSelector::Route::ClusterWeightState::operator==(
+    const ClusterWeightState& other) const {
+  return range_end == other.range_end && cluster == other.cluster &&
+         MethodConfigsEqual(method_config.get(), other.method_config.get());
+}
+
+bool XdsResolver::XdsConfigSelector::Route::operator==(
+    const Route& other) const {
+  return route == other.route &&
+         weighted_cluster_state == other.weighted_cluster_state &&
+         MethodConfigsEqual(method_config.get(), other.method_config.get());
+}
+
 //
 // XdsResolver::XdsConfigSelector
 //
 
 XdsResolver::XdsConfigSelector::XdsConfigSelector(
-    RefCountedPtr<XdsResolver> resolver,
-    const std::vector<XdsApi::Route>& routes, grpc_error* error)
+    RefCountedPtr<XdsResolver> resolver, grpc_error_handle* error)
     : resolver_(std::move(resolver)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] creating XdsConfigSelector %p",
@@ -281,8 +340,8 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
   // weighted_cluster_state field points to the memory in the route field, so
   // moving the entry in a reallocation will cause the string_view to point to
   // invalid data.
-  route_table_.reserve(routes.size());
-  for (auto& route : routes) {
+  route_table_.reserve(resolver_->current_virtual_host_.routes.size());
+  for (auto& route : resolver_->current_virtual_host_.routes) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
       gpr_log(GPR_INFO, "[xds_resolver %p] XdsConfigSelector %p: route: %s",
               resolver_.get(), this, route.ToString().c_str());
@@ -294,27 +353,95 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
     // one.
     if (!route.max_stream_duration.has_value()) {
       route_entry.route.max_stream_duration =
-          resolver_->http_max_stream_duration_;
+          resolver_->current_listener_.http_connection_manager
+              .http_max_stream_duration;
     }
-    error = CreateMethodConfig(&route_entry.method_config, route_entry.route);
     if (route.weighted_clusters.empty()) {
+      *error = CreateMethodConfig(route_entry.route, nullptr,
+                                  &route_entry.method_config);
       MaybeAddCluster(route.cluster_name);
     } else {
       uint32_t end = 0;
       for (const auto& weighted_cluster : route_entry.route.weighted_clusters) {
-        MaybeAddCluster(weighted_cluster.name);
+        Route::ClusterWeightState cluster_weight_state;
+        *error = CreateMethodConfig(route_entry.route, &weighted_cluster,
+                                    &cluster_weight_state.method_config);
+        if (*error != GRPC_ERROR_NONE) return;
         end += weighted_cluster.weight;
-        route_entry.weighted_cluster_state.emplace_back(end,
-                                                        weighted_cluster.name);
+        cluster_weight_state.range_end = end;
+        cluster_weight_state.cluster = weighted_cluster.name;
+        route_entry.weighted_cluster_state.push_back(
+            std::move(cluster_weight_state));
+        MaybeAddCluster(weighted_cluster.name);
       }
     }
   }
+  // Populate filter list.
+  bool found_router = false;
+  for (const auto& http_filter :
+       resolver_->current_listener_.http_connection_manager.http_filters) {
+    // Stop at the router filter.  It's a no-op for us, and we ignore
+    // anything that may come after it, for compatibility with Envoy.
+    if (http_filter.config.config_proto_type_name ==
+        kXdsHttpRouterFilterConfigName) {
+      found_router = true;
+      break;
+    }
+    // Find filter.  This is guaranteed to succeed, because it's checked
+    // at config validation time in the XdsApi code.
+    const XdsHttpFilterImpl* filter_impl =
+        XdsHttpFilterRegistry::GetFilterForType(
+            http_filter.config.config_proto_type_name);
+    GPR_ASSERT(filter_impl != nullptr);
+    // Add C-core filter to list.
+    filters_.push_back(filter_impl->channel_filter());
+  }
+  // For compatibility with Envoy, if the router filter is not
+  // configured, we fail all RPCs.
+  if (!found_router) {
+    filter_error_ =
+        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                               "no xDS HTTP router filter configured"),
+                           GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
+    filters_.push_back(&grpc_lame_filter);
+  }
+}
+
+XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    gpr_log(GPR_INFO, "[xds_resolver %p] destroying XdsConfigSelector %p",
+            resolver_.get(), this);
+  }
+  clusters_.clear();
+  resolver_->MaybeRemoveUnusedClusters();
+  GRPC_ERROR_UNREF(filter_error_);
+}
+
+const XdsHttpFilterImpl::FilterConfig* FindFilterConfigOverride(
+    const std::string& instance_name,
+    const XdsApi::RdsUpdate::VirtualHost& vhost, const XdsApi::Route& route,
+    const XdsApi::Route::ClusterWeight* cluster_weight) {
+  // Check ClusterWeight, if any.
+  if (cluster_weight != nullptr) {
+    auto it = cluster_weight->typed_per_filter_config.find(instance_name);
+    if (it != cluster_weight->typed_per_filter_config.end()) return &it->second;
+  }
+  // Check Route.
+  auto it = route.typed_per_filter_config.find(instance_name);
+  if (it != route.typed_per_filter_config.end()) return &it->second;
+  // Check VirtualHost.
+  it = vhost.typed_per_filter_config.find(instance_name);
+  if (it != vhost.typed_per_filter_config.end()) return &it->second;
+  // Not found.
+  return nullptr;
 }
 
-grpc_error* XdsResolver::XdsConfigSelector::CreateMethodConfig(
-    RefCountedPtr<ServiceConfig>* method_config, const XdsApi::Route& route) {
-  grpc_error* error = GRPC_ERROR_NONE;
+grpc_error_handle XdsResolver::XdsConfigSelector::CreateMethodConfig(
+    const XdsApi::Route& route,
+    const XdsApi::Route::ClusterWeight* cluster_weight,
+    RefCountedPtr<ServiceConfig>* method_config) {
   std::vector<std::string> fields;
+  // Set timeout.
   if (route.max_stream_duration.has_value() &&
       (route.max_stream_duration->seconds != 0 ||
        route.max_stream_duration->nanos != 0)) {
@@ -322,6 +449,51 @@ grpc_error* XdsResolver::XdsConfigSelector::CreateMethodConfig(
                                         route.max_stream_duration->seconds,
                                         route.max_stream_duration->nanos));
   }
+  // Handle xDS HTTP filters.
+  std::map<std::string, std::vector<std::string>> per_filter_configs;
+  grpc_channel_args* args = grpc_channel_args_copy(resolver_->args_);
+  for (const auto& http_filter :
+       resolver_->current_listener_.http_connection_manager.http_filters) {
+    // Stop at the router filter.  It's a no-op for us, and we ignore
+    // anything that may come after it, for compatibility with Envoy.
+    if (http_filter.config.config_proto_type_name ==
+        kXdsHttpRouterFilterConfigName) {
+      break;
+    }
+    // Find filter.  This is guaranteed to succeed, because it's checked
+    // at config validation time in the XdsApi code.
+    const XdsHttpFilterImpl* filter_impl =
+        XdsHttpFilterRegistry::GetFilterForType(
+            http_filter.config.config_proto_type_name);
+    GPR_ASSERT(filter_impl != nullptr);
+    // Allow filter to add channel args that may affect service config
+    // parsing.
+    args = filter_impl->ModifyChannelArgs(args);
+    // Find config override, if any.
+    const XdsHttpFilterImpl::FilterConfig* config_override =
+        FindFilterConfigOverride(http_filter.name,
+                                 resolver_->current_virtual_host_, route,
+                                 cluster_weight);
+    // Generate service config for filter.
+    auto method_config_field =
+        filter_impl->GenerateServiceConfig(http_filter.config, config_override);
+    if (!method_config_field.ok()) {
+      return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrCat("failed to generate method config for HTTP filter ",
+                       http_filter.name, ": ",
+                       method_config_field.status().ToString())
+              .c_str());
+    }
+    per_filter_configs[method_config_field->service_config_field_name]
+        .push_back(method_config_field->element);
+  }
+  for (const auto& p : per_filter_configs) {
+    fields.emplace_back(absl::StrCat("    \"", p.first, "\": [\n",
+                                     absl::StrJoin(p.second, ",\n"),
+                                     "\n    ]"));
+  }
+  // Construct service config.
+  grpc_error_handle error = GRPC_ERROR_NONE;
   if (!fields.empty()) {
     std::string json = absl::StrCat(
         "{\n"
@@ -333,19 +505,20 @@ grpc_error* XdsResolver::XdsConfigSelector::CreateMethodConfig(
         absl::StrJoin(fields, ",\n"),
         "\n  } ]\n"
         "}");
-    *method_config =
-        ServiceConfig::Create(resolver_->args_, json.c_str(), &error);
+    *method_config = ServiceConfig::Create(args, json.c_str(), &error);
   }
+  grpc_channel_args_destroy(args);
   return error;
 }
 
-XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] destroying XdsConfigSelector %p",
-            resolver_.get(), this);
-  }
-  clusters_.clear();
-  resolver_->MaybeRemoveUnusedClusters();
+grpc_channel_args* XdsResolver::XdsConfigSelector::ModifyChannelArgs(
+    grpc_channel_args* args) {
+  if (filter_error_ == GRPC_ERROR_NONE) return args;
+  grpc_arg error_arg = MakeLameClientErrorArg(filter_error_);
+  grpc_channel_args* new_args =
+      grpc_channel_args_copy_and_add(args, &error_arg, 1);
+  grpc_channel_args_destroy(args);
+  return new_args;
 }
 
 void XdsResolver::XdsConfigSelector::MaybeAddCluster(const std::string& name) {
@@ -361,56 +534,52 @@ void XdsResolver::XdsConfigSelector::MaybeAddCluster(const std::string& name) {
   }
 }
 
-absl::optional<absl::string_view> GetMetadataValue(
-    const std::string& target_key, grpc_metadata_batch* initial_metadata,
+absl::optional<absl::string_view> GetHeaderValue(
+    grpc_metadata_batch* initial_metadata, absl::string_view header_name,
     std::string* concatenated_value) {
-  // Find all values for the specified key.
-  GPR_DEBUG_ASSERT(initial_metadata != nullptr);
-  absl::InlinedVector<absl::string_view, 1> values;
-  for (grpc_linked_mdelem* md = initial_metadata->list.head; md != nullptr;
-       md = md->next) {
-    absl::string_view key = StringViewFromSlice(GRPC_MDKEY(md->md));
-    absl::string_view value = StringViewFromSlice(GRPC_MDVALUE(md->md));
-    if (target_key == key) values.push_back(value);
-  }
-  // If none found, no match.
-  if (values.empty()) return absl::nullopt;
-  // If exactly one found, return it as-is.
-  if (values.size() == 1) return values.front();
-  // If more than one found, concatenate the values, using
-  // *concatenated_values as a temporary holding place for the
-  // concatenated string.
-  *concatenated_value = absl::StrJoin(values, ",");
-  return *concatenated_value;
-}
-
-bool HeaderMatchHelper(const HeaderMatcher& header_matcher,
-                       grpc_metadata_batch* initial_metadata) {
-  std::string concatenated_value;
-  absl::optional<absl::string_view> value;
   // Note: If we ever allow binary headers here, we still need to
   // special-case ignore "grpc-tags-bin" and "grpc-trace-bin", since
   // they are not visible to the LB policy in grpc-go.
-  if (absl::EndsWith(header_matcher.name(), "-bin") ||
-      header_matcher.name() == "grpc-previous-rpc-attempts") {
-    value = absl::nullopt;
-  } else if (header_matcher.name() == "content-type") {
-    value = "application/grpc";
-  } else {
-    value = GetMetadataValue(header_matcher.name(), initial_metadata,
-                             &concatenated_value);
+  if (absl::EndsWith(header_name, "-bin")) {
+    return absl::nullopt;
+  } else if (header_name == "content-type") {
+    return "application/grpc";
   }
-  return header_matcher.Match(value);
+  return grpc_metadata_batch_get_value(initial_metadata, header_name,
+                                       concatenated_value);
 }
 
 bool HeadersMatch(const std::vector<HeaderMatcher>& header_matchers,
                   grpc_metadata_batch* initial_metadata) {
   for (const auto& header_matcher : header_matchers) {
-    if (!HeaderMatchHelper(header_matcher, initial_metadata)) return false;
+    std::string concatenated_value;
+    if (!header_matcher.Match(GetHeaderValue(
+            initial_metadata, header_matcher.name(), &concatenated_value))) {
+      return false;
+    }
   }
   return true;
 }
 
+absl::optional<uint64_t> HeaderHashHelper(
+    const XdsApi::Route::HashPolicy& policy,
+    grpc_metadata_batch* initial_metadata) {
+  GPR_ASSERT(policy.type == XdsApi::Route::HashPolicy::HEADER);
+  std::string value_buffer;
+  absl::optional<absl::string_view> header_value =
+      GetHeaderValue(initial_metadata, policy.header_name, &value_buffer);
+  if (policy.regex != nullptr) {
+    // If GetHeaderValue() did not already store the value in
+    // value_buffer, copy it there now, so we can modify it.
+    if (header_value->data() != value_buffer.data()) {
+      value_buffer = std::string(*header_value);
+    }
+    RE2::GlobalReplace(&value_buffer, *policy.regex, policy.regex_substitution);
+    header_value = value_buffer;
+  }
+  return XXH64(header_value->data(), header_value->size(), 0);
+}
+
 bool UnderFraction(const uint32_t fraction_per_million) {
   // Generate a random number in [0, 1000000).
   const uint32_t random_number = rand() % 1000000;
@@ -437,13 +606,15 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
     }
     // Found a route match
     absl::string_view cluster_name;
+    RefCountedPtr<ServiceConfig> method_config;
     if (entry.route.weighted_clusters.empty()) {
       cluster_name = entry.route.cluster_name;
+      method_config = entry.method_config;
     } else {
       const uint32_t key =
           rand() %
           entry.weighted_cluster_state[entry.weighted_cluster_state.size() - 1]
-              .first;
+              .range_end;
       // Find the index in weighted clusters corresponding to key.
       size_t mid = 0;
       size_t start_index = 0;
@@ -451,9 +622,9 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
       size_t index = 0;
       while (end_index > start_index) {
         mid = (start_index + end_index) / 2;
-        if (entry.weighted_cluster_state[mid].first > key) {
+        if (entry.weighted_cluster_state[mid].range_end > key) {
           end_index = mid;
-        } else if (entry.weighted_cluster_state[mid].first < key) {
+        } else if (entry.weighted_cluster_state[mid].range_end < key) {
           start_index = mid + 1;
         } else {
           index = mid + 1;
@@ -461,21 +632,56 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
         }
       }
       if (index == 0) index = start_index;
-      GPR_ASSERT(entry.weighted_cluster_state[index].first > key);
-      cluster_name = entry.weighted_cluster_state[index].second;
+      GPR_ASSERT(entry.weighted_cluster_state[index].range_end > key);
+      cluster_name = entry.weighted_cluster_state[index].cluster;
+      method_config = entry.weighted_cluster_state[index].method_config;
     }
     auto it = clusters_.find(cluster_name);
     GPR_ASSERT(it != clusters_.end());
     XdsResolver* resolver =
         static_cast<XdsResolver*>(resolver_->Ref().release());
     ClusterState* cluster_state = it->second->Ref().release();
+    // Generate a hash
+    absl::optional<uint64_t> hash;
+    for (const auto& hash_policy : entry.route.hash_policies) {
+      absl::optional<uint64_t> new_hash;
+      switch (hash_policy.type) {
+        case XdsApi::Route::HashPolicy::HEADER:
+          new_hash = HeaderHashHelper(hash_policy, args.initial_metadata);
+          break;
+        case XdsApi::Route::HashPolicy::CHANNEL_ID:
+          new_hash =
+              static_cast<uint64_t>(reinterpret_cast<uintptr_t>(resolver));
+          break;
+        default:
+          GPR_ASSERT(0);
+      }
+      if (new_hash.has_value()) {
+        // Rotating the old value prevents duplicate hash rules from cancelling
+        // each other out and preserves all of the entropy
+        const uint64_t old_value =
+            hash.has_value() ? ((hash.value() << 1) | (hash.value() >> 63)) : 0;
+        hash = old_value ^ new_hash.value();
+      }
+      // If the policy is a terminal policy and a hash has been generated,
+      // ignore the rest of the hash policies.
+      if (hash_policy.terminal && hash.has_value()) {
+        break;
+      }
+    }
+    if (!hash.has_value()) {
+      // If there is no hash, we just choose a random value as a default.
+      hash = rand();
+    }
     CallConfig call_config;
-    if (entry.method_config != nullptr) {
-      call_config.service_config = entry.method_config;
+    if (method_config != nullptr) {
       call_config.method_configs =
-          entry.method_config->GetMethodParsedConfigVector(grpc_empty_slice());
+          method_config->GetMethodParsedConfigVector(grpc_empty_slice());
+      call_config.service_config = std::move(method_config);
     }
     call_config.call_attributes[kXdsClusterAttribute] = it->first;
+    call_config.call_attributes[kRequestRingHashAttribute] =
+        absl::StrFormat("%" PRIu64, hash.value());
     call_config.on_call_committed = [resolver, cluster_state]() {
       cluster_state->Unref();
       ExecCtx::Run(
@@ -489,7 +695,7 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
           // the data plane mutex.
           DEBUG_LOCATION,
           GRPC_CLOSURE_CREATE(
-              [](void* arg, grpc_error* /*error*/) {
+              [](void* arg, grpc_error_handle /*error*/) {
                 auto* resolver = static_cast<XdsResolver*>(arg);
                 resolver->work_serializer_->Run(
                     [resolver]() {
@@ -511,13 +717,13 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
 //
 
 void XdsResolver::StartLocked() {
-  grpc_error* error = GRPC_ERROR_NONE;
-  xds_client_ = XdsClient::GetOrCreate(&error);
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  xds_client_ = XdsClient::GetOrCreate(args_, &error);
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR,
             "Failed to create xds client -- channel will remain in "
             "TRANSIENT_FAILURE: %s",
-            grpc_error_string(error));
+            grpc_error_std_string(error).c_str());
     result_handler_->ReturnError(error);
     return;
   }
@@ -563,24 +769,34 @@ void XdsResolver::OnListenerUpdate(XdsApi::LdsUpdate listener) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] received updated listener data", this);
   }
-  if (listener.route_config_name != route_config_name_) {
+  if (listener.http_connection_manager.route_config_name !=
+      route_config_name_) {
     if (route_config_watcher_ != nullptr) {
       xds_client_->CancelRouteConfigDataWatch(
           route_config_name_, route_config_watcher_,
-          /*delay_unsubscription=*/!listener.route_config_name.empty());
+          /*delay_unsubscription=*/
+          !listener.http_connection_manager.route_config_name.empty());
       route_config_watcher_ = nullptr;
     }
-    route_config_name_ = std::move(listener.route_config_name);
+    route_config_name_ =
+        std::move(listener.http_connection_manager.route_config_name);
     if (!route_config_name_.empty()) {
+      current_virtual_host_.routes.clear();
       auto watcher = absl::make_unique<RouteConfigWatcher>(Ref());
       route_config_watcher_ = watcher.get();
       xds_client_->WatchRouteConfigData(route_config_name_, std::move(watcher));
     }
   }
-  http_max_stream_duration_ = listener.http_max_stream_duration;
+  current_listener_ = std::move(listener);
   if (route_config_name_.empty()) {
-    GPR_ASSERT(listener.rds_update.has_value());
-    OnRouteConfigUpdate(std::move(*listener.rds_update));
+    GPR_ASSERT(
+        current_listener_.http_connection_manager.rds_update.has_value());
+    OnRouteConfigUpdate(
+        std::move(*current_listener_.http_connection_manager.rds_update));
+  } else {
+    // HCM may contain newer filter config. We need to propagate the update as
+    // config selector to the channel
+    GenerateResult();
   }
 }
 
@@ -598,17 +814,18 @@ void XdsResolver::OnRouteConfigUpdate(XdsApi::RdsUpdate rds_update) {
             .c_str()));
     return;
   }
-  // Save the list of routes in the resolver.
-  current_update_ = std::move(vhost->routes);
+  // Save the virtual host in the resolver.
+  current_virtual_host_ = std::move(*vhost);
   // Send a new result to the channel.
   GenerateResult();
 }
 
-void XdsResolver::OnError(grpc_error* error) {
+void XdsResolver::OnError(grpc_error_handle error) {
   gpr_log(GPR_ERROR, "[xds_resolver %p] received error from XdsClient: %s",
-          this, grpc_error_string(error));
+          this, grpc_error_std_string(error).c_str());
   Result result;
-  result.args = grpc_channel_args_copy(args_);
+  grpc_arg new_arg = xds_client_->MakeChannelArg();
+  result.args = grpc_channel_args_copy_and_add(args_, &new_arg, 1);
   result.service_config_error = error;
   result_handler_->ReturnResult(std::move(result));
 }
@@ -618,7 +835,7 @@ void XdsResolver::OnResourceDoesNotExist() {
           "[xds_resolver %p] LDS/RDS resource does not exist -- clearing "
           "update and returning empty service config",
           this);
-  current_update_.clear();
+  current_virtual_host_.routes.clear();
   Result result;
   result.service_config =
       ServiceConfig::Create(args_, "{}", &result.service_config_error);
@@ -627,7 +844,7 @@ void XdsResolver::OnResourceDoesNotExist() {
   result_handler_->ReturnResult(std::move(result));
 }
 
-grpc_error* XdsResolver::CreateServiceConfig(
+grpc_error_handle XdsResolver::CreateServiceConfig(
     RefCountedPtr<ServiceConfig>* service_config) {
   std::vector<std::string> clusters;
   for (const auto& cluster : cluster_state_map_) {
@@ -654,18 +871,17 @@ grpc_error* XdsResolver::CreateServiceConfig(
       "  ]\n"
       "}");
   std::string json = absl::StrJoin(config_parts, "");
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   *service_config = ServiceConfig::Create(args_, json.c_str(), &error);
   return error;
 }
 
 void XdsResolver::GenerateResult() {
-  if (current_update_.empty()) return;
+  if (current_virtual_host_.routes.empty()) return;
   // First create XdsConfigSelector, which may add new entries to the cluster
   // state map, and then CreateServiceConfig for LB policies.
-  grpc_error* error = GRPC_ERROR_NONE;
-  auto config_selector =
-      MakeRefCounted<XdsConfigSelector>(Ref(), current_update_, error);
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  auto config_selector = MakeRefCounted<XdsConfigSelector>(Ref(), &error);
   if (error != GRPC_ERROR_NONE) {
     OnError(error);
     return;
@@ -680,8 +896,12 @@ void XdsResolver::GenerateResult() {
     gpr_log(GPR_INFO, "[xds_resolver %p] generated service config: %s", this,
             result.service_config->json_string().c_str());
   }
-  grpc_arg new_arg = config_selector->MakeChannelArg();
-  result.args = grpc_channel_args_copy_and_add(args_, &new_arg, 1);
+  grpc_arg new_args[] = {
+      xds_client_->MakeChannelArg(),
+      config_selector->MakeChannelArg(),
+  };
+  result.args =
+      grpc_channel_args_copy_and_add(args_, new_args, GPR_ARRAY_SIZE(new_args));
   result_handler_->ReturnResult(std::move(result));
 }