grpc 1.82.0 → 1.83.0.pre1

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

@@ -34,6 +34,7 @@
 #include "envoy/config/endpoint/v3/endpoint_components.upb.h"
 #include "envoy/type/v3/percent.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -41,11 +42,9 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/load_balancing/ring_hash/ring_hash.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_args.h"
 #include "src/core/util/json/json_object_loader.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"
@@ -66,23 +65,11 @@ namespace grpc_core {
 
 namespace {
 
-// TODO(roth): Remove this after 1.67 is released.
-bool XdsDualstackEndpointsEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS");
-  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;
-}
-
 // TODO(roth): Flip the default to false once this proves stable, then
 // remove it entirely at some point in the future.
 bool XdsEndpointHashKeyBackwardCompatEnabled() {
-  auto value = GetEnv("GRPC_XDS_ENDPOINT_HASH_KEY_BACKWARD_COMPAT");
-  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;
+  return IsExperimentEnvVarEnabled("GRPC_XDS_ENDPOINT_HASH_KEY_BACKWARD_COMPAT",
+                                   /*default_value=*/true);
 }
 
 void MaybeLogClusterLoadAssignment(
@@ -170,7 +157,9 @@ std::optional<EndpointAddresses> EndpointAddressesParse(
           envoy_config_endpoint_v3_Endpoint_address(endpoint), errors);
       if (address.has_value()) addresses.push_back(*address);
     }
-    if (XdsDualstackEndpointsEnabled()) {
+    // TODO(roth): Remove this after 1.67 is released.
+    if (IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS",
+                                  /*default_value=*/true)) {
       size_t size;
       auto* additional_addresses =
           envoy_config_endpoint_v3_Endpoint_additional_addresses(endpoint,

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

@@ -23,7 +23,7 @@
 
 #include "envoy/extensions/filters/http/router/v3/router.upb.h"
 #include "envoy/extensions/filters/http/router/v3/router.upbdefs.h"
-#include "src/core/util/env.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/sync.h"
@@ -112,14 +112,6 @@ RefCountedPtr<const FilterConfig> XdsHttpRouterFilter::ParseOverrideConfig(
 
 namespace {
 
-bool XdsCompositeFilterEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_COMPOSITE_FILTER");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 Mutex* g_mu = new Mutex;
 NoDestruct<absl::AnyInvocable<std::unique_ptr<XdsHttpFilterImpl>()>>
     g_http_filter_factory_factory ABSL_GUARDED_BY(*g_mu);
@@ -139,7 +131,7 @@ XdsHttpFilterRegistry::XdsHttpFilterRegistry(bool register_builtins) {
     RegisterFilter(std::make_unique<XdsHttpRbacFilter>());
     RegisterFilter(std::make_unique<XdsHttpStatefulSessionFilter>());
     RegisterFilter(std::make_unique<XdsHttpGcpAuthnFilter>());
-    if (XdsCompositeFilterEnabled()) {
+    if (IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_COMPOSITE_FILTER")) {
       RegisterFilter(std::make_unique<XdsHttpCompositeFilter>());
     }
     MutexLock lock(g_mu);

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

@@ -36,14 +36,13 @@
 #include "envoy/type/matcher/v3/string.upb.h"
 #include "envoy/type/v3/range.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/ext/filters/rbac/rbac_filter.h"
 #include "src/core/ext/filters/rbac/rbac_service_config_parser.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/down_cast.h"
-#include "src/core/util/env.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_writer.h"
-#include "src/core/util/string.h"
 #include "src/core/util/upb_utils.h"
 #include "src/core/xds/grpc/xds_audit_logger_registry.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
@@ -60,15 +59,6 @@ namespace grpc_core {
 
 namespace {
 
-// TODO(lwge): Remove once the feature is stable.
-bool XdsRbacAuditLoggingEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_RBAC_AUDIT_LOGGING");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 Json ParseRegexMatcherToJson(
     const envoy_type_matcher_v3_RegexMatcher* regex_matcher) {
   return Json::FromObject(
@@ -479,7 +469,8 @@ Json ParseHttpRbacToJson(const XdsResourceType::DecodeContext& context,
                               Json::FromObject(std::move(policies_object)));
     }
     // Flatten the nested messages defined in rbac.proto
-    if (XdsRbacAuditLoggingEnabled() &&
+    // TODO(lwge): Remove env var guard once the feature is stable.
+    if (IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_RBAC_AUDIT_LOGGING") &&
         envoy_config_rbac_v3_RBAC_has_audit_logging_options(rules)) {
       ValidationErrors::ScopedField field(errors, ".audit_logging_options");
       const auto* audit_logging_options =

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_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,

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

@@ -190,16 +190,14 @@ 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,
     Blackboard& blackboard)
     : hcm_filter_configs_(hcm_filter_configs),
-      vhost_(vhost),
       builder_(builder),
       add_last_filter_(std::move(add_last_filter)),
       blackboard_(blackboard) {
@@ -216,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(
@@ -233,44 +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, 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(
@@ -279,77 +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, 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), 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 {

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

@@ -80,49 +80,99 @@ class XdsRouting final {
       grpc_metadata_batch* initial_metadata, absl::string_view header_name,
       std::string* concatenated_value);
 
-  // Logic for building a filter chain for a given route.  Caching is
-  // done to avoid unnecessary work while iterating over the list of
-  // routes in a given VirtualHost.
+  // Logic for building filter chains for each route within a
+  // RouteConfiguration.  Caching is done to avoid unnecessary work while
+  // iterating over the list of routes.
   //
   // TODO(roth): Currently, this class uses the xds_resolver tracer for
   // logging.  When we change the server side to use the new filter
   // config structure, add a new tracer and use that instead, so that it
   // can be used on both the client and server side.
-  class PerRouteFilterChainBuilder {
+  class RouteConfigFilterChainBuilder {
    public:
+    // Builds filter chains for each route within a VirtualHost.
+    class VirtualHostFilterChainBuilder {
+     public:
+      // Builds filter chains for each ClusterWeight within a route.
+      class WeightedClusterRouteFilterChainBuilder {
+       public:
+        WeightedClusterRouteFilterChainBuilder(
+            VirtualHostFilterChainBuilder& vhost_builder,
+            const XdsRouteConfigResource::Route& route)
+            : vhost_builder_(vhost_builder), route_(route) {}
+
+        // Builds a filter chain for a ClusterWeight.
+        absl::StatusOr<RefCountedPtr<const FilterChain>>
+        BuildFilterChainForClusterWeight(
+            const XdsRouteConfigResource::Route::RouteAction::ClusterWeight&
+                cluster_weight);
+
+       private:
+        absl::StatusOr<RefCountedPtr<const FilterChain>> GetRouteFilterChain();
+
+        VirtualHostFilterChainBuilder& vhost_builder_;
+        const XdsRouteConfigResource::Route& route_;
+
+        // Cached filter chain for the route, to be used for any ClusterWeight
+        // that does not have any filter config overrides.
+        absl::StatusOr<RefCountedPtr<const FilterChain>> route_filter_chain_ =
+            nullptr;
+      };
+
+      VirtualHostFilterChainBuilder(
+          RouteConfigFilterChainBuilder& route_config_builder,
+          const XdsRouteConfigResource::VirtualHost& vhost)
+          : route_config_builder_(route_config_builder), vhost_(vhost) {}
+
+      // Builds a filter chain for a route that has an individual cluster
+      // or a ClusterSpecifierPlugin.
+      absl::StatusOr<RefCountedPtr<const FilterChain>> BuildFilterChainForRoute(
+          const XdsRouteConfigResource::Route& route);
+
+      // Returns a filter chain builder for a given route that uses
+      // WeightedClusters.
+      WeightedClusterRouteFilterChainBuilder
+      MakeWeightedClusterRouteFilterChainBuilder(
+          const XdsRouteConfigResource::Route& route) {
+        return WeightedClusterRouteFilterChainBuilder(*this, route);
+      }
+
+     private:
+      absl::StatusOr<RefCountedPtr<const FilterChain>>
+      GetVirtualHostFilterChain();
+
+      RouteConfigFilterChainBuilder& route_config_builder_;
+      const XdsRouteConfigResource::VirtualHost& vhost_;
+
+      // Cached filter chain for the virtual host, to be used for any route
+      // that does not have any filter config overrides.
+      absl::StatusOr<RefCountedPtr<const FilterChain>> vhost_filter_chain_ =
+          nullptr;
+    };
+
     // The add_last_filter() callback is called on the builder after
     // adding all of the xDS HTTP filters and right before building the
     // filter chain.  May be null if not needed.
-    PerRouteFilterChainBuilder(
+    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,
         Blackboard& blackboard);
 
-    // Builds a filter chain for a route that has an individual cluster
-    // or a ClusterSpecifierPlugin.
-    absl::StatusOr<RefCountedPtr<const FilterChain>> BuildFilterChainForRoute(
-        const XdsRouteConfigResource::Route& route);
-
-    // Builds a filter chain for a route that uses WeightedClusters.
-    // The set_filter_chain_for_cluster_weight() function will be called
-    // once for each index in the WeightedClusters list.
-    void BuildFilterChainForRouteWithWeightedClusters(
-        const XdsRouteConfigResource::Route& route,
-        absl::FunctionRef<
-            void(size_t, absl::StatusOr<RefCountedPtr<const FilterChain>>)>
-            set_filter_chain_for_cluster_weight);
+    // Returns a filter chain builder for a given virtual host.
+    VirtualHostFilterChainBuilder MakeVirtualHostFilterChainBuilder(
+        const XdsRouteConfigResource::VirtualHost& vhost) {
+      return VirtualHostFilterChainBuilder(*this, vhost);
+    }
 
    private:
     absl::StatusOr<RefCountedPtr<const FilterChain>> GetDefaultFilterChain();
 
     const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
         hcm_filter_configs_;
-    const XdsRouteConfigResource::VirtualHost& vhost_;
     FilterChainBuilder& builder_;
     absl::AnyInvocable<void(FilterChainBuilder&)> add_last_filter_;
     Blackboard& blackboard_;

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

@@ -24,11 +24,10 @@
 #include <vector>
 
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/util/down_cast.h"
-#include "src/core/util/env.h"
 #include "src/core/util/json/json_reader.h"
 #include "src/core/util/json/json_writer.h"
-#include "src/core/util/string.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
@@ -98,16 +97,6 @@ struct ChannelOrCallCreds {
   }
 };
 
-// TODO(roth): Remove this guard once we have reports from OSS Istio
-// users that this works properly.
-bool XdsBootstrapCallCredsEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_BOOTSTRAP_CALL_CREDS");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 }  // namespace
 
 RefCountedPtr<const ChannelCredsConfig> ParseXdsBootstrapChannelCreds(
@@ -170,7 +159,9 @@ void GrpcXdsServer::JsonPostLoad(const Json& json, const JsonArgs& args,
       ParseXdsBootstrapChannelCreds(json, args, errors);
   // Parse "call_creds".
   std::vector<RefCountedPtr<const CallCredsConfig>> call_creds_configs;
-  if (XdsBootstrapCallCredsEnabled()) {
+  // TODO(roth): Remove this guard once we have reports from OSS Istio
+  // users that this works properly.
+  if (IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_BOOTSTRAP_CALL_CREDS")) {
     call_creds_configs = ParseXdsBootstrapCallCreds(json, args, errors);
   }
   // Parse "server_features".
@@ -238,6 +229,22 @@ std::string GrpcXdsServerTarget::Key() const {
     StrAppend(result, call_creds_config->ToString());
     StrAppend(result, "}");
   }
+  if (!initial_metadata_.empty()) {
+    StrAppend(result, ", initial_metadata=[");
+    bool is_first = true;
+    for (const auto& metadata : initial_metadata_) {
+      if (!is_first) StrAppend(result, ", ");
+      StrAppend(result, metadata.first);
+      StrAppend(result, "=");
+      StrAppend(result, metadata.second);
+      is_first = false;
+    }
+    StrAppend(result, "]");
+  }
+  if (timeout_ != Duration::Zero()) {
+    StrAppend(result, ", timeout=");
+    StrAppend(result, timeout_.ToString());
+  }
   StrAppend(result, "}");
   return result;
 }
@@ -258,6 +265,8 @@ bool GrpcXdsServerTarget::Equals(const XdsServerTarget& other) const {
       return false;
     }
   }
+  if (initial_metadata_ != o.initial_metadata_) return false;
+  if (timeout_ != o.timeout_) return false;
   return true;
 }