grpc 1.81.1 → 1.83.1

data/src/core/xds/grpc/xds_http_stateful_session_filter.cc

@@ -30,7 +30,6 @@
 #include "envoy/extensions/http/stateful_session/cookie/v3/cookie.upbdefs.h"
 #include "envoy/type/http/v3/cookie.upb.h"
 #include "src/core/ext/filters/stateful_session/stateful_session_filter.h"
-#include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_writer.h"
@@ -64,134 +63,6 @@ void XdsHttpStatefulSessionFilter::PopulateSymtab(upb_DefPool* symtab) const {
       symtab);
 }
 
-namespace {
-
-Json::Object ValidateStatefulSession(
-    const XdsResourceType::DecodeContext& context,
-    const envoy_extensions_filters_http_stateful_session_v3_StatefulSession*
-        stateful_session,
-    ValidationErrors* errors) {
-  ValidationErrors::ScopedField field(errors, ".session_state");
-  const auto* session_state =
-      envoy_extensions_filters_http_stateful_session_v3_StatefulSession_session_state(
-          stateful_session);
-  if (session_state == nullptr) {
-    return {};
-  }
-  ValidationErrors::ScopedField field2(errors, ".typed_config");
-  const auto* typed_config =
-      envoy_config_core_v3_TypedExtensionConfig_typed_config(session_state);
-  auto extension = ExtractXdsExtension(context, typed_config, errors);
-  if (!extension.has_value()) return {};
-  if (extension->type !=
-      "envoy.extensions.http.stateful_session.cookie.v3"
-      ".CookieBasedSessionState") {
-    errors->AddError("unsupported session state type");
-    return {};
-  }
-  absl::string_view* serialized_session_state =
-      std::get_if<absl::string_view>(&extension->value);
-  if (serialized_session_state == nullptr) {
-    errors->AddError("could not parse session state config");
-    return {};
-  }
-  auto* cookie_state =
-      envoy_extensions_http_stateful_session_cookie_v3_CookieBasedSessionState_parse(
-          serialized_session_state->data(), serialized_session_state->size(),
-          context.arena);
-  if (cookie_state == nullptr) {
-    errors->AddError("could not parse session state config");
-    return {};
-  }
-  ValidationErrors::ScopedField field3(errors, ".cookie");
-  const auto* cookie =
-      envoy_extensions_http_stateful_session_cookie_v3_CookieBasedSessionState_cookie(
-          cookie_state);
-  if (cookie == nullptr) {
-    errors->AddError("field not present");
-    return {};
-  }
-  Json::Object cookie_config;
-  // name
-  std::string cookie_name =
-      UpbStringToStdString(envoy_type_http_v3_Cookie_name(cookie));
-  if (cookie_name.empty()) {
-    ValidationErrors::ScopedField field(errors, ".name");
-    errors->AddError("field not present");
-  }
-  cookie_config["name"] = Json::FromString(std::move(cookie_name));
-  // ttl
-  {
-    ValidationErrors::ScopedField field(errors, ".ttl");
-    const auto* duration = envoy_type_http_v3_Cookie_ttl(cookie);
-    if (duration != nullptr) {
-      Duration ttl = ParseDuration(duration, errors);
-      cookie_config["ttl"] = Json::FromString(ttl.ToJsonString());
-    }
-  }
-  // path
-  std::string path =
-      UpbStringToStdString(envoy_type_http_v3_Cookie_path(cookie));
-  if (!path.empty()) cookie_config["path"] = Json::FromString(std::move(path));
-  return cookie_config;
-}
-
-}  // namespace
-
-std::optional<Json> XdsHttpStatefulSessionFilter::GenerateFilterConfig(
-    absl::string_view /*instance_name*/,
-    const XdsResourceType::DecodeContext& context,
-    const XdsExtension& extension, ValidationErrors* errors) const {
-  const absl::string_view* serialized_filter_config =
-      std::get_if<absl::string_view>(&extension.value);
-  if (serialized_filter_config == nullptr) {
-    errors->AddError("could not parse stateful session filter config");
-    return std::nullopt;
-  }
-  auto* stateful_session =
-      envoy_extensions_filters_http_stateful_session_v3_StatefulSession_parse(
-          serialized_filter_config->data(), serialized_filter_config->size(),
-          context.arena);
-  if (stateful_session == nullptr) {
-    errors->AddError("could not parse stateful session filter config");
-    return std::nullopt;
-  }
-  return Json::FromObject(
-      ValidateStatefulSession(context, stateful_session, errors));
-}
-
-std::optional<Json> XdsHttpStatefulSessionFilter::GenerateFilterConfigOverride(
-    absl::string_view /*instance_name*/,
-    const XdsResourceType::DecodeContext& context,
-    const XdsExtension& extension, ValidationErrors* errors) const {
-  const absl::string_view* serialized_filter_config =
-      std::get_if<absl::string_view>(&extension.value);
-  if (serialized_filter_config == nullptr) {
-    errors->AddError("could not parse stateful session filter override config");
-    return std::nullopt;
-  }
-  auto* stateful_session_per_route =
-      envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_parse(
-          serialized_filter_config->data(), serialized_filter_config->size(),
-          context.arena);
-  if (stateful_session_per_route == nullptr) {
-    errors->AddError("could not parse stateful session filter override config");
-    return std::nullopt;
-  }
-  Json::Object config;
-  if (!envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_disabled(
-          stateful_session_per_route)) {
-    ValidationErrors::ScopedField field(errors, ".stateful_session");
-    const auto* stateful_session =
-        envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_stateful_session(
-            stateful_session_per_route);
-    if (stateful_session != nullptr) {
-      config = ValidateStatefulSession(context, stateful_session, errors);
-    }
-  }
-  return Json::FromObject(std::move(config));
-}
-
 const grpc_channel_filter* XdsHttpStatefulSessionFilter::channel_filter()
     const {
   return &StatefulSessionFilter::kFilterVtable;
@@ -203,26 +74,6 @@ void XdsHttpStatefulSessionFilter::AddFilter(
   builder.AddFilter<StatefulSessionFilter>(std::move(config));
 }
 
-ChannelArgs XdsHttpStatefulSessionFilter::ModifyChannelArgs(
-    const ChannelArgs& args) const {
-  return args.Set(GRPC_ARG_PARSE_STATEFUL_SESSION_METHOD_CONFIG, 1);
-}
-
-absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
-XdsHttpStatefulSessionFilter::GenerateMethodConfig(
-    const Json& hcm_filter_config, const Json* filter_config_override) const {
-  const Json& config = filter_config_override != nullptr
-                           ? *filter_config_override
-                           : hcm_filter_config;
-  return ServiceConfigJsonEntry{"stateful_session", JsonDump(config)};
-}
-
-absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
-XdsHttpStatefulSessionFilter::GenerateServiceConfig(
-    const Json& /*hcm_filter_config*/) const {
-  return ServiceConfigJsonEntry{"", ""};
-}
-
 namespace {
 
 RefCountedPtr<StatefulSessionFilter::Config> ParseStatefulSession(

data/src/core/xds/grpc/xds_http_stateful_session_filter.h

@@ -40,19 +40,30 @@ class XdsHttpStatefulSessionFilter final : public XdsHttpFilterImpl {
   void PopulateSymtab(upb_DefPool* symtab) const override;
   std::optional<Json> GenerateFilterConfig(
       absl::string_view /*instance_name*/,
-      const XdsResourceType::DecodeContext& context,
-      const XdsExtension& extension, ValidationErrors* errors) const override;
+      const XdsResourceType::DecodeContext& /*context*/,
+      const XdsExtension& /*extension*/,
+      ValidationErrors* /*errors*/) const override {
+    return std::nullopt;
+  }
   std::optional<Json> GenerateFilterConfigOverride(
       absl::string_view /*instance_name*/,
-      const XdsResourceType::DecodeContext& context,
-      const XdsExtension& extension, ValidationErrors* errors) const override;
+      const XdsResourceType::DecodeContext& /*context*/,
+      const XdsExtension& /*extension*/,
+      ValidationErrors* /*errors*/) const override {
+    return std::nullopt;
+  }
   const grpc_channel_filter* channel_filter() const override;
-  ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
-      const Json& hcm_filter_config,
-      const Json* filter_config_override) const override;
+      const Json& /*hcm_filter_config*/,
+      const Json* /*filter_config_override*/) const override {
+    return absl::UnimplementedError(
+        "old-style filter config APIs not supported");
+  }
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
-      const Json& hcm_filter_config) const override;
+      const Json& /*hcm_filter_config*/) const override {
+    return absl::UnimplementedError(
+        "old-style filter config APIs not supported");
+  }
   void AddFilter(FilterChainBuilder& builder,
                  RefCountedPtr<const FilterConfig> config) const override;
   RefCountedPtr<const FilterConfig> ParseTopLevelConfig(

data/src/core/xds/grpc/xds_lb_policy_registry.cc

@@ -32,8 +32,10 @@
 #include "envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.upb.h"
 #include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "src/core/client_channel/client_channel_service_config.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/load_balancing/weighted_round_robin/weighted_round_robin.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_common_types.h"
@@ -135,6 +137,22 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory final
       }
       config["errorUtilizationPenalty"] = Json::FromNumber(value);
     }
+    // metric_names_for_computing_utilization
+    if (WrrCustomMetricsEnabled()) {
+      size_t size;
+      auto metric_names_for_computing_utilization =
+          envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_metric_names_for_computing_utilization(
+              resource, &size);
+      if (metric_names_for_computing_utilization != nullptr && size != 0) {
+        Json::Array metric_names;
+        for (size_t i = 0; i < size; ++i) {
+          metric_names.emplace_back(Json::FromString(
+              UpbStringToStdString(metric_names_for_computing_utilization[i])));
+        }
+        config["metricNamesForComputingUtilization"] =
+            Json::FromArray(std::move(metric_names));
+      }
+    }
     return Json::Object{
         {"weighted_round_robin", Json::FromObject(std::move(config))}};
   }

data/src/core/xds/grpc/xds_listener_parser.cc

@@ -306,17 +306,15 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
         auto& entry = http_connection_manager.http_filters.back();
         entry.name = std::string(name);
         entry.config_proto_type = filter_impl->ConfigProtoName();
-        if (!is_client || !IsXdsChannelFilterChainPerRouteEnabled()) {
+        if (!is_client) {
           std::optional<Json> filter_config = filter_impl->GenerateFilterConfig(
               name, context, *extension, errors);
           if (filter_config.has_value()) {
             entry.config = std::move(*filter_config);
           }
         }
-        if (IsXdsChannelFilterChainPerRouteEnabled()) {
-          entry.filter_config = filter_impl->ParseTopLevelConfig(
-              name, context, *extension, errors);
-        }
+        entry.filter_config =
+            filter_impl->ParseTopLevelConfig(name, context, *extension, errors);
       }
     }
     if (errors->size() == original_error_size &&
@@ -559,10 +557,16 @@ std::optional<FilterChain::FilterChainMatch> FilterChainMatchParse(
     }
   }
   // source_type
-  filter_chain_match.source_type =
-      static_cast<XdsListenerResource::FilterChainMap::ConnectionSourceType>(
-          envoy_config_listener_v3_FilterChainMatch_source_type(
-              filter_chain_match_proto));
+  int32_t source_type = envoy_config_listener_v3_FilterChainMatch_source_type(
+      filter_chain_match_proto);
+  if (source_type < 0 || source_type > 2) {
+    ValidationErrors::ScopedField field(errors, ".source_type");
+    errors->AddError("invalid value");
+  } else {
+    filter_chain_match.source_type =
+        static_cast<XdsListenerResource::FilterChainMap::ConnectionSourceType>(
+            source_type);
+  }
   // source_prefix_ranges
   auto* source_prefix_ranges =
       envoy_config_listener_v3_FilterChainMatch_source_prefix_ranges(

data/src/core/xds/grpc/xds_metadata_parser.cc

@@ -24,8 +24,6 @@
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upb.h"
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upbdefs.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/util/env.h"
-#include "src/core/util/string.h"
 #include "src/core/util/upb_utils.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_cluster_parser.h"

data/src/core/xds/grpc/xds_route_config.h

@@ -59,7 +59,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
                std::string /*LB policy config*/>;
 
   struct RetryPolicy {
-    internal::StatusCodeSet retry_on;
+    StatusCodeSet retry_on;
     uint32_t num_retries;
 
     struct RetryBackOff {

data/src/core/xds/grpc/xds_route_config_parser.cc

@@ -45,17 +45,16 @@
 #include "re2/re2.h"
 #include "src/core/call/status_util.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/util/down_cast.h"
-#include "src/core/util/env.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/match.h"
 #include "src/core/util/matchers.h"
 #include "src/core/util/ref_counted_ptr.h"
-#include "src/core/util/string.h"
 #include "src/core/util/time.h"
 #include "src/core/util/upb_utils.h"
 #include "src/core/xds/grpc/xds_cluster_specifier_plugin.h"
@@ -79,21 +78,18 @@
 
 namespace grpc_core {
 
-// TODO(apolcyn): remove this flag by the 1.58 release
-bool XdsRlsEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_RLS_LB");
-  if (!value.has_value()) return true;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 //
 // XdsRouteConfigResourceParse()
 //
 
 namespace {
 
+// TODO(apolcyn): remove this flag by the 1.58 release
+bool XdsRlsEnabled() {
+  return IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_RLS_LB",
+                                   /*default_value=*/true);
+}
+
 XdsRouteConfigResource::ClusterSpecifierPluginMap ClusterSpecifierPluginParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RouteConfiguration* route_config,
@@ -411,10 +407,8 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
     if (filter_config.has_value()) {
       entry.config = std::move(*filter_config);
     }
-    if (IsXdsChannelFilterChainPerRouteEnabled()) {
-      entry.filter_config = filter_impl->ParseOverrideConfig(
-          key, context, *extension_to_use, errors);
-    }
+    entry.filter_config = filter_impl->ParseOverrideConfig(
+        key, context, *extension_to_use, errors);
   }
   return typed_per_filter_config;
 }
@@ -778,7 +772,7 @@ std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResourceParse(
     const envoy_config_route_v3_RouteConfiguration* route_config,
     ValidationErrors* errors) {
   auto rds_update = std::make_shared<XdsRouteConfigResource>();
-  // Get the cluster spcifier plugin map.
+  // Get the cluster specifier plugin map.
   if (XdsRlsEnabled()) {
     rds_update->cluster_specifier_plugin_map =
         ClusterSpecifierPluginParse(context, route_config, errors);

data/src/core/xds/grpc/xds_routing.cc

@@ -190,20 +190,17 @@ std::optional<absl::string_view> XdsRouting::GetHeaderValue(
   return initial_metadata->GetStringValue(header_name, concatenated_value);
 }
 
-XdsRouting::PerRouteFilterChainBuilder::PerRouteFilterChainBuilder(
+XdsRouting::RouteConfigFilterChainBuilder::RouteConfigFilterChainBuilder(
     const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
         hcm_filter_configs,
     const XdsHttpFilterRegistry& http_filter_registry,
-    const XdsRouteConfigResource::VirtualHost& vhost,
     FilterChainBuilder& builder,
     absl::AnyInvocable<void(FilterChainBuilder&)> add_last_filter,
-    const Blackboard* old_blackboard, Blackboard* new_blackboard)
+    Blackboard& blackboard)
     : hcm_filter_configs_(hcm_filter_configs),
-      vhost_(vhost),
       builder_(builder),
       add_last_filter_(std::move(add_last_filter)),
-      old_blackboard_(old_blackboard),
-      new_blackboard_(new_blackboard) {
+      blackboard_(blackboard) {
   filter_impls_.reserve(hcm_filter_configs.size());
   for (const auto& http_filter : hcm_filter_configs) {
     // Find filter.  This is guaranteed to succeed, because it's checked
@@ -217,6 +214,31 @@ XdsRouting::PerRouteFilterChainBuilder::PerRouteFilterChainBuilder(
   }
 }
 
+absl::StatusOr<RefCountedPtr<const FilterChain>>
+XdsRouting::RouteConfigFilterChainBuilder::GetDefaultFilterChain() {
+  if (default_filter_chain_.ok() && *default_filter_chain_ == nullptr) {
+    GRPC_TRACE_LOG(xds_resolver, INFO) << "Building default filter chain:";
+    for (size_t i = 0; i < filter_impls_.size(); ++i) {
+      auto* filter_impl = filter_impls_[i];
+      const auto& filter_config = hcm_filter_configs_[i];
+      RefCountedPtr<const FilterConfig> config;
+      if (filter_config.filter_config != nullptr) {
+        config = filter_impl->MergeConfigs(filter_config.filter_config, nullptr,
+                                           nullptr, nullptr, blackboard_);
+      }
+      GRPC_TRACE_LOG(xds_resolver, INFO)
+          << "  Adding filter=" << filter_config.name
+          << " config=" << (config == nullptr ? "<null>" : config->ToString());
+      filter_impl->AddFilter(builder_, std::move(config));
+    }
+    if (add_last_filter_ != nullptr) add_last_filter_(builder_);
+    default_filter_chain_ = builder_.Build();
+    GRPC_TRACE_LOG(xds_resolver, INFO)
+        << "Filter chain creation status: " << default_filter_chain_.status();
+  }
+  return default_filter_chain_;
+}
+
 namespace {
 
 RefCountedPtr<const FilterConfig> GetOverrideConfig(
@@ -234,46 +256,51 @@ RefCountedPtr<const FilterConfig> GetOverrideConfig(
 }  // namespace
 
 absl::StatusOr<RefCountedPtr<const FilterChain>>
-XdsRouting::PerRouteFilterChainBuilder::GetDefaultFilterChain() {
-  if (default_filter_chain_.ok() && *default_filter_chain_ == nullptr) {
-    GRPC_TRACE_LOG(xds_resolver, INFO) << "Building default filter chain:";
-    for (size_t i = 0; i < filter_impls_.size(); ++i) {
-      auto* filter_impl = filter_impls_[i];
-      const auto& filter_config = hcm_filter_configs_[i];
+XdsRouting::RouteConfigFilterChainBuilder::VirtualHostFilterChainBuilder::
+    GetVirtualHostFilterChain() {
+  if (vhost_filter_chain_.ok() && *vhost_filter_chain_ == nullptr) {
+    // If there are no per-vhost overrides, use the default filter chain.
+    if (vhost_.typed_per_filter_config.empty()) {
+      return route_config_builder_.GetDefaultFilterChain();
+    }
+    GRPC_TRACE_LOG(xds_resolver, INFO) << "Building virtual host filter chain:";
+    for (size_t i = 0; i < route_config_builder_.filter_impls_.size(); ++i) {
+      auto* filter_impl = route_config_builder_.filter_impls_[i];
+      const auto& filter_config = route_config_builder_.hcm_filter_configs_[i];
       RefCountedPtr<const FilterConfig> config;
       if (filter_config.filter_config != nullptr) {
         auto vhost_override_config = GetOverrideConfig(
             filter_impl, vhost_.typed_per_filter_config, filter_config.name);
-        config = filter_impl->MergeConfigs(filter_config.filter_config,
-                                           std::move(vhost_override_config),
-                                           nullptr, nullptr);
-        filter_impl->UpdateBlackboard(*config, old_blackboard_,
-                                      new_blackboard_);
+        config = filter_impl->MergeConfigs(
+            filter_config.filter_config, std::move(vhost_override_config),
+            nullptr, nullptr, route_config_builder_.blackboard_);
       }
       GRPC_TRACE_LOG(xds_resolver, INFO)
           << "  Adding filter=" << filter_config.name
           << " config=" << (config == nullptr ? "<null>" : config->ToString());
-      filter_impl->AddFilter(builder_, std::move(config));
+      filter_impl->AddFilter(route_config_builder_.builder_, std::move(config));
     }
-    if (add_last_filter_ != nullptr) add_last_filter_(builder_);
-    default_filter_chain_ = builder_.Build();
+    if (route_config_builder_.add_last_filter_ != nullptr) {
+      route_config_builder_.add_last_filter_(route_config_builder_.builder_);
+    }
+    vhost_filter_chain_ = route_config_builder_.builder_.Build();
     GRPC_TRACE_LOG(xds_resolver, INFO)
-        << "Filter chain creation status: " << default_filter_chain_.status();
+        << "Filter chain creation status: " << vhost_filter_chain_.status();
   }
-  return default_filter_chain_;
+  return vhost_filter_chain_;
 }
 
 absl::StatusOr<RefCountedPtr<const FilterChain>>
-XdsRouting::PerRouteFilterChainBuilder::BuildFilterChainForRoute(
-    const XdsRouteConfigResource::Route& route) {
+XdsRouting::RouteConfigFilterChainBuilder::VirtualHostFilterChainBuilder::
+    BuildFilterChainForRoute(const XdsRouteConfigResource::Route& route) {
   GRPC_TRACE_LOG(xds_resolver, INFO)
       << "Building filter chain for route:" << route.ToString();
-  // If there are no per-route overrides, use the default filter chain.
-  if (route.typed_per_filter_config.empty()) return GetDefaultFilterChain();
+  // If there are no per-route overrides, use the vhost filter chain.
+  if (route.typed_per_filter_config.empty()) return GetVirtualHostFilterChain();
   // Otherwise, build a new filter chain for the route.
-  for (size_t i = 0; i < filter_impls_.size(); ++i) {
-    auto* filter_impl = filter_impls_[i];
-    const auto& filter_config = hcm_filter_configs_[i];
+  for (size_t i = 0; i < route_config_builder_.filter_impls_.size(); ++i) {
+    auto* filter_impl = route_config_builder_.filter_impls_[i];
+    const auto& filter_config = route_config_builder_.hcm_filter_configs_[i];
     RefCountedPtr<const FilterConfig> config;
     if (filter_config.filter_config != nullptr) {
       auto vhost_override_config = GetOverrideConfig(
@@ -282,80 +309,78 @@ XdsRouting::PerRouteFilterChainBuilder::BuildFilterChainForRoute(
           filter_impl, route.typed_per_filter_config, filter_config.name);
       config = filter_impl->MergeConfigs(
           filter_config.filter_config, std::move(vhost_override_config),
-          std::move(route_override_config), nullptr);
-      filter_impl->UpdateBlackboard(*config, old_blackboard_, new_blackboard_);
+          std::move(route_override_config), nullptr,
+          route_config_builder_.blackboard_);
     }
     GRPC_TRACE_LOG(xds_resolver, INFO)
         << "  Adding filter=" << filter_config.name
         << " config=" << (config == nullptr ? "<null>" : config->ToString());
-    filter_impl->AddFilter(builder_, std::move(config));
+    filter_impl->AddFilter(route_config_builder_.builder_, std::move(config));
+  }
+  if (route_config_builder_.add_last_filter_ != nullptr) {
+    route_config_builder_.add_last_filter_(route_config_builder_.builder_);
   }
-  if (add_last_filter_ != nullptr) add_last_filter_(builder_);
   absl::StatusOr<RefCountedPtr<const FilterChain>> route_filter_chain =
-      builder_.Build();
+      route_config_builder_.builder_.Build();
   GRPC_TRACE_LOG(xds_resolver, INFO)
       << "Filter chain creation status: " << route_filter_chain.status();
   return route_filter_chain;
 }
 
-void XdsRouting::PerRouteFilterChainBuilder::
-    BuildFilterChainForRouteWithWeightedClusters(
-        const XdsRouteConfigResource::Route& route,
-        absl::FunctionRef<
-            void(size_t, absl::StatusOr<RefCountedPtr<const FilterChain>>)>
-            set_filter_chain_for_cluster_weight) {
-  // If any cluster weight does not have any filter config overrides,
-  // we'll reuse the route-level filter chain.  We construct it lazily
-  // and cache it so that we never construct it more than we need to.
-  absl::StatusOr<RefCountedPtr<const FilterChain>> route_filter_chain = nullptr;
-  const auto& route_action =
-      std::get<XdsRouteConfigResource::Route::RouteAction>(route.action);
-  const auto& cluster_weights = std::get<
-      std::vector<XdsRouteConfigResource::Route::RouteAction::ClusterWeight>>(
-      route_action.action);
-  for (size_t j = 0; j < cluster_weights.size(); ++j) {
-    const auto& cluster_weight = cluster_weights[j];
-    if (cluster_weight.typed_per_filter_config.empty()) {
-      // No per-ClusterWeight overrides, so use the route-level filter chain.
-      if (route_filter_chain.ok() && *route_filter_chain == nullptr) {
-        route_filter_chain = BuildFilterChainForRoute(route);
-      }
-      set_filter_chain_for_cluster_weight(j, route_filter_chain);
-    } else {
-      GRPC_TRACE_LOG(xds_resolver, INFO)
-          << "Building filter chain for route:" << route.ToString()
-          << " ClusterWeight:" << cluster_weight.ToString();
-      for (size_t i = 0; i < filter_impls_.size(); ++i) {
-        auto* filter_impl = filter_impls_[i];
-        const auto& filter_config = hcm_filter_configs_[i];
-        RefCountedPtr<const FilterConfig> config;
-        if (filter_config.filter_config != nullptr) {
-          auto vhost_override_config = GetOverrideConfig(
-              filter_impl, vhost_.typed_per_filter_config, filter_config.name);
-          auto route_override_config = GetOverrideConfig(
-              filter_impl, route.typed_per_filter_config, filter_config.name);
-          auto cluster_weight_override_config = GetOverrideConfig(
-              filter_impl, cluster_weight.typed_per_filter_config,
-              filter_config.name);
-          config = filter_impl->MergeConfigs(
-              filter_config.filter_config, std::move(vhost_override_config),
-              std::move(route_override_config),
-              std::move(cluster_weight_override_config));
-          filter_impl->UpdateBlackboard(*config, old_blackboard_,
-                                        new_blackboard_);
-        }
-        GRPC_TRACE_LOG(xds_resolver, INFO)
-            << "  Adding filter=" << filter_config.name << " config="
-            << (config == nullptr ? "<null>" : config->ToString());
-        filter_impl->AddFilter(builder_, std::move(config));
-      }
-      if (add_last_filter_ != nullptr) add_last_filter_(builder_);
-      auto filter_chain = builder_.Build();
-      GRPC_TRACE_LOG(xds_resolver, INFO)
-          << "Filter chain creation status: " << filter_chain.status();
-      set_filter_chain_for_cluster_weight(j, std::move(filter_chain));
+absl::StatusOr<RefCountedPtr<const FilterChain>>
+XdsRouting::RouteConfigFilterChainBuilder::VirtualHostFilterChainBuilder::
+    WeightedClusterRouteFilterChainBuilder::GetRouteFilterChain() {
+  if (route_filter_chain_.ok() && *route_filter_chain_ == nullptr) {
+    route_filter_chain_ = vhost_builder_.BuildFilterChainForRoute(route_);
+  }
+  return route_filter_chain_;
+}
+
+absl::StatusOr<RefCountedPtr<const FilterChain>>
+XdsRouting::RouteConfigFilterChainBuilder::VirtualHostFilterChainBuilder::
+    WeightedClusterRouteFilterChainBuilder::BuildFilterChainForClusterWeight(
+        const XdsRouteConfigResource::Route::RouteAction::ClusterWeight&
+            cluster_weight) {
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "Building filter chain for route:" << route_.ToString()
+      << " ClusterWeight:" << cluster_weight.ToString();
+  // If there are no per-ClusterWeight overrides, use the route filter chain.
+  if (cluster_weight.typed_per_filter_config.empty()) {
+    return GetRouteFilterChain();
+  }
+  // Otherwise, build a new filter chain for the ClusterWeight.
+  auto& route_config_builder = vhost_builder_.route_config_builder_;
+  for (size_t i = 0; i < route_config_builder.filter_impls_.size(); ++i) {
+    auto* filter_impl = route_config_builder.filter_impls_[i];
+    const auto& filter_config = route_config_builder.hcm_filter_configs_[i];
+    RefCountedPtr<const FilterConfig> config;
+    if (filter_config.filter_config != nullptr) {
+      auto vhost_override_config = GetOverrideConfig(
+          filter_impl, vhost_builder_.vhost_.typed_per_filter_config,
+          filter_config.name);
+      auto route_override_config = GetOverrideConfig(
+          filter_impl, route_.typed_per_filter_config, filter_config.name);
+      auto cluster_weight_override_config =
+          GetOverrideConfig(filter_impl, cluster_weight.typed_per_filter_config,
+                            filter_config.name);
+      config = filter_impl->MergeConfigs(
+          filter_config.filter_config, std::move(vhost_override_config),
+          std::move(route_override_config),
+          std::move(cluster_weight_override_config),
+          route_config_builder.blackboard_);
     }
+    GRPC_TRACE_LOG(xds_resolver, INFO)
+        << "  Adding filter=" << filter_config.name
+        << " config=" << (config == nullptr ? "<null>" : config->ToString());
+    filter_impl->AddFilter(route_config_builder.builder_, std::move(config));
+  }
+  if (route_config_builder.add_last_filter_ != nullptr) {
+    route_config_builder.add_last_filter_(route_config_builder.builder_);
   }
+  auto filter_chain = route_config_builder.builder_.Build();
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "Filter chain creation status: " << filter_chain.status();
+  return filter_chain;
 }
 
 namespace {