grpc 1.78.0 → 1.80.0.pre1

data/src/core/load_balancing/oob_backend_metric.cc

@@ -207,7 +207,6 @@ class OrcaProducer::OrcaStreamEventHandler final
 
 void OrcaProducer::Start(WeakRefCountedPtr<Subchannel> subchannel) {
   subchannel_ = std::move(subchannel);
-  connected_subchannel_ = subchannel_->connected_subchannel();
   auto connectivity_watcher =
       MakeRefCounted<ConnectivityWatcher>(WeakRefAsSubclass<OrcaProducer>());
   connectivity_watcher_ = connectivity_watcher.get();
@@ -260,9 +259,8 @@ Duration OrcaProducer::GetMinIntervalLocked() const {
 }
 
 void OrcaProducer::MaybeStartStreamLocked() {
-  if (connected_subchannel_ == nullptr) return;
   stream_client_ = MakeOrphanable<SubchannelStreamClient>(
-      connected_subchannel_, subchannel_->pollset_set(),
+      subchannel_,
       std::make_unique<OrcaStreamEventHandler>(
           WeakRefAsSubclass<OrcaProducer>(), report_interval_),
       GRPC_TRACE_FLAG_ENABLED(orca_client) ? "OrcaClient" : nullptr);
@@ -281,10 +279,8 @@ void OrcaProducer::NotifyWatchers(
 void OrcaProducer::OnConnectivityStateChange(grpc_connectivity_state state) {
   MutexLock lock(&mu_);
   if (state == GRPC_CHANNEL_READY) {
-    connected_subchannel_ = subchannel_->connected_subchannel();
     if (!watchers_.empty()) MaybeStartStreamLocked();
   } else {
-    connected_subchannel_.reset();
     stream_client_.reset();
   }
 }

data/src/core/load_balancing/oob_backend_metric_internal.h

@@ -80,7 +80,6 @@ class OrcaProducer final : public Subchannel::DataProducerInterface {
   void NotifyWatchers(const BackendMetricData& backend_metric_data);
 
   WeakRefCountedPtr<Subchannel> subchannel_;
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
   ConnectivityWatcher* connectivity_watcher_;
   Mutex mu_;
   std::set<OrcaWatcher*> watchers_ ABSL_GUARDED_BY(mu_);

data/src/core/load_balancing/xds/xds_cluster_impl.cc

@@ -666,8 +666,8 @@ XdsClusterImplLb::MaybeCreateCertificateProviderLocked(
   RefCountedPtr<grpc_tls_certificate_provider> root_cert_provider;
   bool use_system_root_certs = false;
   absl::Status status = Match(
-      cluster_resource.common_tls_context.certificate_validation_context
-          .ca_certs,
+      cluster_resource.upstream_tls_context.common_tls_context
+          .certificate_validation_context.ca_certs,
       [](const std::monostate&) {
         // No root cert configured.
         return absl::OkStatus();
@@ -693,11 +693,11 @@ XdsClusterImplLb::MaybeCreateCertificateProviderLocked(
   if (!status.ok()) return status;
   // Configure identity cert.
   absl::string_view identity_provider_instance_name =
-      cluster_resource.common_tls_context.tls_certificate_provider_instance
-          .instance_name;
+      cluster_resource.upstream_tls_context.common_tls_context
+          .tls_certificate_provider_instance.instance_name;
   absl::string_view identity_cert_name =
-      cluster_resource.common_tls_context.tls_certificate_provider_instance
-          .certificate_name;
+      cluster_resource.upstream_tls_context.common_tls_context
+          .tls_certificate_provider_instance.certificate_name;
   RefCountedPtr<grpc_tls_certificate_provider> identity_cert_provider;
   if (!identity_provider_instance_name.empty()) {
     identity_cert_provider =
@@ -711,12 +711,15 @@ XdsClusterImplLb::MaybeCreateCertificateProviderLocked(
   }
   // Configure SAN matchers.
   const std::vector<StringMatcher>& san_matchers =
-      cluster_resource.common_tls_context.certificate_validation_context
-          .match_subject_alt_names;
+      cluster_resource.upstream_tls_context.common_tls_context
+          .certificate_validation_context.match_subject_alt_names;
   // Create xds cert provider.
   return MakeRefCounted<XdsCertificateProvider>(
       std::move(root_cert_provider), root_cert_name, use_system_root_certs,
-      std::move(identity_cert_provider), identity_cert_name, san_matchers);
+      std::move(identity_cert_provider), identity_cert_name, san_matchers,
+      cluster_resource.upstream_tls_context.sni,
+      cluster_resource.upstream_tls_context.auto_host_sni,
+      cluster_resource.upstream_tls_context.auto_sni_san_validation);
 }
 
 void XdsClusterImplLb::MaybeUpdatePickerLocked() {

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -21,7 +21,7 @@
 
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/endpoint_info/endpoint_info_handshaker.h"
-#include "src/core/handshaker/http_connect/http_connect_handshaker.h"
+#include "src/core/handshaker/http_connect/http_connect_client_handshaker.h"
 #include "src/core/handshaker/tcp_connect/tcp_connect_handshaker.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
@@ -41,6 +41,7 @@ extern void BuildClientChannelConfiguration(
     CoreConfiguration::Builder* builder);
 extern void SecurityRegisterHandshakerFactories(
     CoreConfiguration::Builder* builder);
+extern void RegisterAuthComparators(CoreConfiguration::Builder* builder);
 extern void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder);
 extern void RegisterLegacyChannelIdleFilters(
     CoreConfiguration::Builder* builder);
@@ -98,7 +99,7 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   // We want TCP connect handshaker to be registered last so that it is added
   // to the start of the handshaker list.
   RegisterEndpointInfoHandshaker(builder);
-  RegisterHttpConnectHandshaker(builder);
+  RegisterHttpConnectClientHandshaker(builder);
   RegisterTCPConnectHandshaker(builder);
   RegisterChttp2Transport(builder);
 #ifndef GRPC_MINIMAL_LB_POLICY

data/src/core/resolver/xds/xds_resolver.cc

@@ -191,36 +191,25 @@ class XdsResolver final : public Resolver {
       struct ClusterWeightState {
         uint32_t range_end;
         absl::string_view cluster;
+        absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain;
+        // TODO(roth): Remove this field as part of removing the
+        // xds_channel_filter_chain_per_route experiment.
         RefCountedPtr<ServiceConfig> method_config;
-
-        bool operator==(const ClusterWeightState& other) const {
-          return range_end == other.range_end && cluster == other.cluster &&
-                 MethodConfigsEqual(method_config.get(),
-                                    other.method_config.get());
-        }
       };
 
       XdsRouteConfigResource::Route route;
+      // TODO(roth): Remove this field as part of removing the
+      // xds_channel_filter_chain_per_route experiment.
       RefCountedPtr<ServiceConfig> method_config;
+      absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain;
       std::vector<ClusterWeightState> weighted_cluster_state;
 
       explicit RouteEntry(const XdsRouteConfigResource::Route& r) : route(r) {}
-
-      bool operator==(const RouteEntry& other) const {
-        return route == other.route &&
-               weighted_cluster_state == other.weighted_cluster_state &&
-               MethodConfigsEqual(method_config.get(),
-                                  other.method_config.get());
-      }
     };
 
     static absl::StatusOr<RefCountedPtr<RouteConfigData>> Create(
         XdsResolver* resolver, const Duration& default_max_stream_duration);
 
-    bool operator==(const RouteConfigData& other) const {
-      return clusters_ == other.clusters_ && routes_ == other.routes_;
-    }
-
     RefCountedPtr<ClusterRef> FindClusterRef(absl::string_view name) const {
       auto it = clusters_.find(name);
       if (it == clusters_.end()) {
@@ -232,21 +221,22 @@ class XdsResolver final : public Resolver {
     RouteEntry* GetRouteForRequest(absl::string_view path,
                                    grpc_metadata_batch* initial_metadata);
 
+    void BuildFilterChains(const XdsConfig& xds_config,
+                           const XdsHttpFilterRegistry& http_filter_registry,
+                           FilterChainBuilder& builder,
+                           const Blackboard* old_blackboard,
+                           Blackboard* new_blackboard);
+
    private:
     class RouteListIterator;
 
     static absl::StatusOr<RefCountedPtr<ServiceConfig>> CreateMethodConfig(
         XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
+        // TODO(roth): Remove this field as part of removing the
+        // xds_channel_filter_chain_per_route experiment.
         const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
             cluster_weight);
 
-    static 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();
-    }
-
     absl::Status AddRouteEntry(XdsResolver* resolver,
                                const XdsRouteConfigResource::Route& route,
                                const Duration& default_max_stream_duration);
@@ -268,25 +258,27 @@ class XdsResolver final : public Resolver {
 
     bool Equals(const ConfigSelector* other) const override {
       const auto* other_xds = static_cast<const XdsConfigSelector*>(other);
-      // Don't need to compare resolver_, since that will always be the same.
-      return *route_config_data_ == *other_xds->route_config_data_ &&
-             filters_ == other_xds->filters_;
+      // Only need to compare LDS and RDS resources, since all of our
+      // other state is derived from those.
+      return *xds_config_->listener == *other_xds->xds_config_->listener &&
+             *xds_config_->route_config ==
+                 *other_xds->xds_config_->route_config;
     }
 
-    absl::Status GetCallConfig(GetCallConfigArgs args) override;
-
-    void AddFilters(InterceptionChainBuilder& builder,
-                    const Blackboard* old_blackboard,
-                    Blackboard* new_blackboard) override;
+    void BuildFilterChains(FilterChainBuilder& builder,
+                           const Blackboard* old_blackboard,
+                           Blackboard* new_blackboard) override;
 
-    std::vector<const grpc_channel_filter*> GetFilters(
-        const Blackboard* old_blackboard, Blackboard* new_blackboard) override;
+    absl::StatusOr<RefCountedPtr<const FilterChain>> GetCallConfig(
+        GetCallConfigArgs args) override;
 
    private:
     RefCountedPtr<XdsResolver> resolver_;
-    std::shared_ptr<const XdsListenerResource> listener_;
+    RefCountedPtr<const XdsConfig> xds_config_;
     RefCountedPtr<RouteConfigData> route_config_data_;
-    std::vector<const XdsHttpFilterImpl*> filters_;
+    // TODO(roth): Remove this field as part of removing the
+    // xds_channel_filter_chain_per_route experiment.
+    absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain_;
   };
 
   class XdsRouteStateAttributeImpl final : public XdsRouteStateAttribute {
@@ -315,7 +307,7 @@ class XdsResolver final : public Resolver {
   class ClusterSelectionFilter final
       : public ImplementChannelFilter<ClusterSelectionFilter> {
    public:
-    const static grpc_channel_filter kFilter;
+    const static grpc_channel_filter kFilterVtable;
 
     static absl::string_view TypeName() { return "cluster_selection_filter"; }
 
@@ -439,6 +431,61 @@ XdsResolver::RouteConfigData::GetRouteForRequest(
   return &routes_[*route_index];
 }
 
+RefCountedPtr<const FilterConfig> GetOverrideConfig(
+    const XdsHttpFilterImpl* filter_impl,
+    const XdsRouteConfigResource::TypedPerFilterConfig& typed_per_filter_config,
+    const std::string& name) {
+  auto it = typed_per_filter_config.find(name);
+  if (it == typed_per_filter_config.end()) return nullptr;
+  if (it->second.config_proto_type != filter_impl->OverrideConfigProtoName()) {
+    return nullptr;
+  }
+  return it->second.filter_config;
+}
+
+void XdsResolver::RouteConfigData::BuildFilterChains(
+    const XdsConfig& xds_config,
+    const XdsHttpFilterRegistry& http_filter_registry,
+    FilterChainBuilder& builder, const Blackboard* old_blackboard,
+    Blackboard* new_blackboard) {
+  const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
+      xds_config.listener->listener);
+  XdsRouting::PerRouteFilterChainBuilder per_route_builder(
+      hcm.http_filters, http_filter_registry, *xds_config.virtual_host, builder,
+      [](FilterChainBuilder& builder) {
+        builder.AddFilter<ClusterSelectionFilter>(nullptr);
+      },
+      old_blackboard, new_blackboard);
+  // Set the filter chain for each route.
+  for (auto& route_entry : routes_) {
+    const auto* route_action =
+        std::get_if<XdsRouteConfigResource::Route::RouteAction>(
+            &route_entry.route.action);
+    if (route_action == nullptr) continue;
+    // If the route uses WeightedClusters, construct a filter chain for
+    // each ClusterWeight entry.
+    if (const auto* weighted_clusters = std::get_if<std::vector<
+            XdsRouteConfigResource::Route::RouteAction::ClusterWeight>>(
+            &route_action->action);
+        weighted_clusters != nullptr) {
+      per_route_builder.BuildFilterChainForRouteWithWeightedClusters(
+          route_entry.route,
+          [&](size_t index,
+              absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain) {
+            GRPC_CHECK_LT(index, route_entry.weighted_cluster_state.size());
+            route_entry.weighted_cluster_state[index].filter_chain =
+                std::move(filter_chain);
+          });
+    }
+    // If the route does not use WeightedClusters, then we generate a
+    // filter chain for the route.
+    else {
+      route_entry.filter_chain =
+          per_route_builder.BuildFilterChainForRoute(route_entry.route);
+    }
+  }
+}
+
 absl::StatusOr<RefCountedPtr<ServiceConfig>>
 XdsResolver::RouteConfigData::CreateMethodConfig(
     XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
@@ -491,18 +538,22 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
         absl::StrFormat("    \"timeout\": \"%s\"",
                         route_action.max_stream_duration->ToJsonString()));
   }
-  // Handle xDS HTTP filters.
-  const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
-      resolver->current_config_->listener->listener);
-  auto result = XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
-      DownCast<const GrpcXdsBootstrap&>(resolver->xds_client_->bootstrap())
-          .http_filter_registry(),
-      hcm.http_filters, *resolver->current_config_->virtual_host, route,
-      cluster_weight, resolver->args_);
-  if (!result.ok()) return result.status();
-  for (const auto& [name, config] : result->per_filter_configs) {
-    fields.emplace_back(absl::StrCat("    \"", name, "\": [\n",
-                                     absl::StrJoin(config, ",\n"), "\n    ]"));
+  ChannelArgs args = resolver->args_;
+  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
+    // Handle xDS HTTP filters.
+    const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
+        resolver->current_config_->listener->listener);
+    auto result = XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
+        DownCast<const GrpcXdsBootstrap&>(resolver->xds_client_->bootstrap())
+            .http_filter_registry(),
+        hcm.http_filters, *resolver->current_config_->virtual_host, route,
+        cluster_weight, resolver->args_);
+    if (!result.ok()) return result.status();
+    for (const auto& [name, config] : result->per_filter_configs) {
+      fields.emplace_back(absl::StrCat(
+          "    \"", name, "\": [\n", absl::StrJoin(config, ",\n"), "\n    ]"));
+    }
+    args = result->args;
   }
   // Construct service config.
   if (!fields.empty()) {
@@ -516,7 +567,7 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
         absl::StrJoin(fields, ",\n"),
         "\n  } ]\n"
         "}");
-    return ServiceConfigImpl::Create(result->args, json.c_str());
+    return ServiceConfigImpl::Create(args, json.c_str());
   }
   return nullptr;
 }
@@ -614,26 +665,10 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
     RefCountedPtr<XdsResolver> resolver,
     RefCountedPtr<RouteConfigData> route_config_data)
     : resolver_(std::move(resolver)),
-      listener_(resolver_->current_config_->listener),
+      xds_config_(resolver_->current_config_),
       route_config_data_(std::move(route_config_data)) {
   GRPC_TRACE_LOG(xds_resolver, INFO) << "[xds_resolver " << resolver_.get()
                                      << "] creating XdsConfigSelector " << this;
-  // Populate filter list.
-  const auto& http_filter_registry =
-      DownCast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
-          .http_filter_registry();
-  const auto& hcm =
-      std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
-  for (const auto& http_filter : hcm.http_filters) {
-    // Find filter.  This is guaranteed to succeed, because it's checked
-    // at config validation time.
-    const XdsHttpFilterImpl* filter_impl =
-        http_filter_registry.GetFilterForType(
-            http_filter.config.config_proto_type_name);
-    GRPC_CHECK_NE(filter_impl, nullptr);
-    // Add filter to list.
-    filters_.push_back(filter_impl);
-  }
 }
 
 XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
@@ -667,8 +702,8 @@ std::optional<uint64_t> HeaderHashHelper(
   return XXH64(header_value->data(), header_value->size(), 0);
 }
 
-absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
-    GetCallConfigArgs args) {
+absl::StatusOr<RefCountedPtr<const FilterChain>>
+XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
   Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
   GRPC_CHECK_NE(path, nullptr);
   auto* entry = route_config_data_->GetRouteForRequest(path->as_string_view(),
@@ -686,6 +721,7 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
   }
   std::string cluster_name;
   RefCountedPtr<ServiceConfig> method_config;
+  absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain;
   Match(
       route_action->action,
       // cluster name
@@ -694,6 +730,7 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
         cluster_name =
             absl::StrCat("cluster:", action_cluster_name.cluster_name);
         method_config = entry->method_config;
+        filter_chain = entry->filter_chain;
       },
       // WeightedClusters
       [&](const std::vector<
@@ -718,10 +755,11 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
           }
         }
         if (index == 0) index = start_index;
-        GRPC_CHECK(entry->weighted_cluster_state[index].range_end > key);
-        cluster_name = absl::StrCat(
-            "cluster:", entry->weighted_cluster_state[index].cluster);
-        method_config = entry->weighted_cluster_state[index].method_config;
+        const auto& cluster_weight = entry->weighted_cluster_state[index];
+        GRPC_CHECK(cluster_weight.range_end > key);
+        cluster_name = absl::StrCat("cluster:", cluster_weight.cluster);
+        method_config = cluster_weight.method_config;
+        filter_chain = cluster_weight.filter_chain;
       },
       // ClusterSpecifierPlugin
       [&](const XdsRouteConfigResource::Route::RouteAction::
@@ -730,7 +768,11 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
             "cluster_specifier_plugin:",
             cluster_specifier_plugin_name.cluster_specifier_plugin_name);
         method_config = entry->method_config;
+        filter_chain = entry->filter_chain;
       });
+  if (IsXdsChannelFilterChainPerRouteEnabled() && !filter_chain.ok()) {
+    return filter_chain.status();
+  }
   auto cluster = route_config_data_->FindClusterRef(cluster_name);
   GRPC_CHECK(cluster != nullptr);
   // Generate a hash.
@@ -776,41 +818,41 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
   args.service_config_call_data->SetCallAttribute(
       args.arena->ManagedNew<XdsRouteStateAttributeImpl>(route_config_data_,
                                                          entry));
-  return absl::OkStatus();
+  if (!IsXdsChannelFilterChainPerRouteEnabled()) return filter_chain_;
+  return filter_chain;
 }
 
-void XdsResolver::XdsConfigSelector::AddFilters(
-    InterceptionChainBuilder& builder, const Blackboard* old_blackboard,
+void XdsResolver::XdsConfigSelector::BuildFilterChains(
+    FilterChainBuilder& builder, const Blackboard* old_blackboard,
     Blackboard* new_blackboard) {
-  const auto& hcm =
-      std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
-  GRPC_CHECK_EQ(filters_.size(), hcm.http_filters.size());
-  for (size_t i = 0; i < filters_.size(); ++i) {
-    auto* filter = filters_[i];
-    filter->AddFilter(builder);
-    filter->UpdateBlackboard(hcm.http_filters[i].config, old_blackboard,
-                             new_blackboard);
-  }
-  builder.Add<ClusterSelectionFilter>(nullptr);
-}
-
-std::vector<const grpc_channel_filter*>
-XdsResolver::XdsConfigSelector::GetFilters(const Blackboard* old_blackboard,
-                                           Blackboard* new_blackboard) {
-  const auto& hcm =
-      std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
-  GRPC_CHECK_EQ(filters_.size(), hcm.http_filters.size());
-  std::vector<const grpc_channel_filter*> filters;
-  for (size_t i = 0; i < filters_.size(); ++i) {
-    auto* filter = filters_[i];
-    if (filter->channel_filter() != nullptr) {
-      filters.push_back(filter->channel_filter());
+  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
+    const auto& http_filter_registry =
+        DownCast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
+            .http_filter_registry();
+    const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
+        xds_config_->listener->listener);
+    for (const auto& http_filter : hcm.http_filters) {
+      // Find filter.  This is guaranteed to succeed, because it's checked
+      // at config validation time.
+      const XdsHttpFilterImpl* filter_impl =
+          http_filter_registry.GetFilterForTopLevelType(
+              http_filter.config_proto_type);
+      GRPC_CHECK_NE(filter_impl, nullptr);
+      filter_impl->AddFilter(builder, nullptr);
+      filter_impl->UpdateBlackboard(http_filter.config, old_blackboard,
+                                    new_blackboard);
     }
-    filter->UpdateBlackboard(hcm.http_filters[i].config, old_blackboard,
-                             new_blackboard);
+    builder.AddFilter<ClusterSelectionFilter>(nullptr);
+    filter_chain_ = builder.Build();
+    return;
   }
-  filters.push_back(&ClusterSelectionFilter::kFilter);
-  return filters;
+  // Build filter chains.
+  const auto& http_filter_registry =
+      DownCast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
+          .http_filter_registry();
+  route_config_data_->BuildFilterChains(*xds_config_, http_filter_registry,
+                                        builder, old_blackboard,
+                                        new_blackboard);
 }
 
 //
@@ -858,7 +900,7 @@ XdsResolver::XdsRouteStateAttributeImpl::LockAndGetCluster(
 // XdsResolver::ClusterSelectionFilter
 //
 
-const grpc_channel_filter XdsResolver::ClusterSelectionFilter::kFilter =
+const grpc_channel_filter XdsResolver::ClusterSelectionFilter::kFilterVtable =
     MakePromiseBasedFilter<ClusterSelectionFilter, FilterEndpoint::kClient,
                            kFilterExaminesServerInitialMetadata>();
 
@@ -1019,20 +1061,24 @@ XdsResolver::CreateServiceConfig() {
                    "    }\n"
                    "    } }\n"
                    "  ]"));
-  auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
-      current_config_->listener->listener);
-  auto filter_configs =
-      XdsRouting::GeneratePerHTTPFilterConfigsForServiceConfig(
-          static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
-              .http_filter_registry(),
-          hcm.http_filters, args_);
-  if (!filter_configs.ok()) return filter_configs.status();
-  for (const auto& [name, config] : filter_configs->per_filter_configs) {
-    config_parts.emplace_back(absl::StrCat(
-        "  \"", name, "\": [\n", absl::StrJoin(config, ",\n"), "\n  ]"));
+  ChannelArgs args = args_;
+  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
+    auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
+        current_config_->listener->listener);
+    auto filter_configs =
+        XdsRouting::GeneratePerHTTPFilterConfigsForServiceConfig(
+            static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+                .http_filter_registry(),
+            hcm.http_filters, args_);
+    if (!filter_configs.ok()) return filter_configs.status();
+    for (const auto& [name, config] : filter_configs->per_filter_configs) {
+      config_parts.emplace_back(absl::StrCat(
+          "  \"", name, "\": [\n", absl::StrJoin(config, ",\n"), "\n  ]"));
+    }
+    args = filter_configs->args;
   }
   std::string json = absl::StrCat("{", absl::StrJoin(config_parts, ",\n"), "}");
-  return ServiceConfigImpl::Create(filter_configs->args, json.c_str());
+  return ServiceConfigImpl::Create(args, json.c_str());
 }
 
 void XdsResolver::GenerateResult() {

data/src/core/server/server.cc

@@ -1047,6 +1047,7 @@ class Server::TransportConnectivityWatcher
     MutexLock lock(&server_->mu_global_);
     server_->connections_.erase(transport_.get());
     --server_->connections_open_;
+    server_->stream_quota_->DecrementOpenChannels();
     server_->MaybeFinishShutdown();
   }
 
@@ -1201,7 +1202,8 @@ Server::Server(const ChannelArgs& args)
       max_time_in_pending_queue_(Duration::Seconds(
           channel_args_
               .GetInt(GRPC_ARG_SERVER_MAX_UNREQUESTED_TIME_IN_SERVER_SECONDS)
-              .value_or(30))) {
+              .value_or(30))),
+      stream_quota_(channel_args_.GetObject<ResourceQuota>()->stream_quota()) {
   SourceConstructed();
 }
 
@@ -1340,6 +1342,7 @@ grpc_error_handle Server::SetupTransport(Transport* transport,
     GRPC_TRACE_LOG(server_channel, INFO) << "Adding connection";
     connections_.emplace(std::move(t));
     ++connections_open_;
+    stream_quota_->IncrementOpenChannels();
   } else {
     GRPC_CHECK(transport->filter_stack_transport() != nullptr);
     absl::StatusOr<RefCountedPtr<Channel>> channel = LegacyChannel::Create(
@@ -1369,9 +1372,12 @@ grpc_error_handle Server::SetupTransport(Transport* transport,
       channelz_socket_uuid = socket_node->uuid();
       socket_node->AddParent(channelz_node_.get());
     }
+
     // Initialize chand.
     chand->InitTransport(Ref(), std::move(*channel), cq_idx, transport,
                          channelz_socket_uuid);
+
+    stream_quota_->IncrementOpenChannels();
   }
   return absl::OkStatus();
 }
@@ -1705,6 +1711,7 @@ class Server::ChannelData::ConnectivityWatcher
                                  const absl::Status& /*status*/) override {
     // Don't do anything until we are being shut down.
     if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
+    chand_->server_->stream_quota_->DecrementOpenChannels();
     // Shut down channel.
     MutexLock lock(&chand_->server_->mu_global_);
     chand_->Destroy();
@@ -1720,6 +1727,7 @@ class Server::ChannelData::ConnectivityWatcher
 
 Server::ChannelData::~ChannelData() {
   if (server_ != nullptr) {
+    server_->stream_quota_->DecrementOpenChannels();
     MutexLock lock(&server_->mu_global_);
     if (list_position_.has_value()) {
       server_->channels_.erase(*list_position_);
@@ -1743,6 +1751,7 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
     server_->channels_.push_front(this);
     list_position_ = server_->channels_.begin();
   }
+
   // Start accept_stream transport op.
   grpc_transport_op* op = grpc_make_transport_op(nullptr);
   GRPC_CHECK(transport->filter_stack_transport() != nullptr);
@@ -1880,12 +1889,20 @@ Server::CallData::CallData(grpc_call_element* elem,
                     elem, grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady,
                     elem, grpc_schedule_on_exec_ctx);
+
+  // TODO(snohria): Add the same for Call-V3 as well.
+  server_->stream_quota_->IncrementOutstandingRequests();
 }
 
 Server::CallData::~CallData() {
   GRPC_CHECK(state_.load(std::memory_order_relaxed) != CallState::PENDING);
   grpc_metadata_array_destroy(&initial_metadata_);
   grpc_byte_buffer_destroy(payload_);
+
+  if (server_ != nullptr) {
+    // TODO(snohria): Add the same for Call-V3 as well.
+    server_->stream_quota_->DecrementOutstandingRequests();
+  }
 }
 
 void Server::CallData::SetState(CallState state) {

data/src/core/server/server.h

@@ -729,6 +729,8 @@ class Server : public ServerInterface,
 
   // The last time we printed a shutdown progress message.
   gpr_timespec last_shutdown_message_time_;
+
+  StreamQuotaRefPtr stream_quota_;
 };
 
 }  // namespace grpc_core

data/src/core/server/xds_server_config_fetcher.cc

@@ -1051,8 +1051,8 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
     // Find filter.  This is guaranteed to succeed, because it's checked
     // at config validation time in the XdsApi code.
     const XdsHttpFilterImpl* filter_impl =
-        http_filter_registry.GetFilterForType(
-            http_filter.config.config_proto_type_name);
+        http_filter_registry.GetFilterForTopLevelType(
+            http_filter.config_proto_type);
     GRPC_CHECK_NE(filter_impl, nullptr);
     // Some filters like the router filter are no-op filters and do not have
     // an implementation.
@@ -1119,8 +1119,8 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
         auto& hcm = filter_chain_data.http_connection_manager;
         for (const auto& http_filter : hcm.http_filters) {
           const XdsHttpFilterImpl* filter_impl =
-              http_filter_registry.GetFilterForType(
-                  http_filter.config.config_proto_type_name);
+              http_filter_registry.GetFilterForTopLevelType(
+                  http_filter.config_proto_type);
           GRPC_CHECK_NE(filter_impl,
                         nullptr);  // Enforced in config validation.
           filter_impl->UpdateBlackboard(http_filter.config, old_blackboard,