grpc 1.80.0 → 1.81.0

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

@@ -73,6 +73,31 @@ Duration ParseDuration(const google_protobuf_Duration* proto_duration,
   return Duration::FromSecondsAndNanoseconds(seconds, nanos);
 }
 
+//
+// ParseFractionalPercent()
+//
+
+uint32_t ParseFractionalPercent(
+    const envoy_type_v3_FractionalPercent* fractional_percent) {
+  if (fractional_percent == nullptr) return 1000000;
+  uint32_t numerator =
+      envoy_type_v3_FractionalPercent_numerator(fractional_percent);
+  const auto denominator =
+      static_cast<envoy_type_v3_FractionalPercent_DenominatorType>(
+          envoy_type_v3_FractionalPercent_denominator(fractional_percent));
+  switch (denominator) {
+    case envoy_type_v3_FractionalPercent_MILLION:
+      break;
+    case envoy_type_v3_FractionalPercent_TEN_THOUSAND:
+      numerator *= 100;
+      break;
+    case envoy_type_v3_FractionalPercent_HUNDRED:
+    default:
+      numerator *= 10000;
+  }
+  return std::min(numerator, 1000000u);
+}
+
 //
 // ParseXdsAddress()
 //
@@ -618,9 +643,14 @@ std::pair<std::string, std::string> ParseHeader(
   {
     ValidationErrors::ScopedField field(errors, ".key");
     if (key.size() > 16384) errors->AddError("longer than 16384 bytes");
-    ValidateMetadataResult result = ValidateHeaderKeyIsLegal(key);
-    if (result != ValidateMetadataResult::kOk) {
-      errors->AddError(ValidateMetadataResultToString(result));
+    if (absl::StartsWith(key, ":") || absl::StartsWith(key, "grpc-") ||
+        key == "host") {
+      errors->AddError(absl::StrCat("header \"", key, "\" not allowed"));
+    } else {
+      ValidateMetadataResult result = ValidateHeaderKeyIsLegal(key);
+      if (result != ValidateMetadataResult::kOk) {
+        errors->AddError(ValidateMetadataResultToString(result));
+      }
     }
   }
   // value or raw_value

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

@@ -24,6 +24,7 @@
 #include "envoy/config/core/v3/grpc_service.upb.h"
 #include "envoy/extensions/transport_sockets/tls/v3/tls.upb.h"
 #include "envoy/type/matcher/v3/string.upb.h"
+#include "envoy/type/v3/percent.upb.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/struct.upb.h"
@@ -59,7 +60,10 @@ inline std::optional<uint32_t> ParseUInt32Value(
   return google_protobuf_UInt32Value_value(proto);
 }
 
-// Returns the IP address in URI form.
+// Returns the number per million.
+uint32_t ParseFractionalPercent(
+    const envoy_type_v3_FractionalPercent* fractional_percent);
+
 std::optional<grpc_resolved_address> ParseXdsAddress(
     const envoy_config_core_v3_Address* address, ValidationErrors* errors);
 

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

@@ -16,21 +16,26 @@
 
 #include "src/core/xds/grpc/xds_endpoint.h"
 
-#include <vector>
+#include <string>
 
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
+#include "src/core/util/string.h"
 
 namespace grpc_core {
 
 std::string XdsEndpointResource::Priority::Locality::ToString() const {
-  std::vector<std::string> endpoint_strings;
+  std::string result = "{name=";
+  StrAppend(result, name->human_readable_string().as_string_view());
+  StrAppend(result, ", lb_weight=");
+  StrAppend(result, std::to_string(lb_weight));
+  StrAppend(result, ", endpoints=[");
+  bool is_first = true;
   for (const EndpointAddresses& endpoint : endpoints) {
-    endpoint_strings.emplace_back(endpoint.ToString());
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, endpoint.ToString());
+    is_first = false;
   }
-  return absl::StrCat("{name=", name->human_readable_string().as_string_view(),
-                      ", lb_weight=", lb_weight, ", endpoints=[",
-                      absl::StrJoin(endpoint_strings, ", "), "]}");
+  StrAppend(result, "]}");
+  return result;
 }
 
 bool XdsEndpointResource::Priority::operator==(const Priority& other) const {
@@ -47,12 +52,15 @@ bool XdsEndpointResource::Priority::operator==(const Priority& other) const {
 }
 
 std::string XdsEndpointResource::Priority::ToString() const {
-  std::vector<std::string> locality_strings;
-  locality_strings.reserve(localities.size());
+  std::string result = "[";
+  bool is_first = true;
   for (const auto& [_, locality] : localities) {
-    locality_strings.emplace_back(locality.ToString());
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, locality.ToString());
+    is_first = false;
   }
-  return absl::StrCat("[", absl::StrJoin(locality_strings, ", "), "]");
+  StrAppend(result, "]");
+  return result;
 }
 
 bool XdsEndpointResource::DropConfig::ShouldDrop(
@@ -72,25 +80,37 @@ bool XdsEndpointResource::DropConfig::ShouldDrop(
 }
 
 std::string XdsEndpointResource::DropConfig::ToString() const {
-  std::vector<std::string> category_strings;
+  std::string result = "{[";
+  bool is_first = true;
   for (const DropCategory& category : drop_category_list_) {
-    category_strings.emplace_back(
-        absl::StrCat(category.name, "=", category.parts_per_million));
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, category.name);
+    StrAppend(result, "=");
+    StrAppend(result, std::to_string(category.parts_per_million));
+    is_first = false;
   }
-  return absl::StrCat("{[", absl::StrJoin(category_strings, ", "),
-                      "], drop_all=", drop_all_, "}");
+  StrAppend(result, "], drop_all=");
+  StrAppend(result, drop_all_ ? "true" : "false");
+  StrAppend(result, "}");
+  return result;
 }
 
 std::string XdsEndpointResource::ToString() const {
-  std::vector<std::string> priority_strings;
+  std::string result = "{priorities=[";
   for (size_t i = 0; i < priorities.size(); ++i) {
-    const Priority& priority = priorities[i];
-    priority_strings.emplace_back(
-        absl::StrCat("priority ", i, ": ", priority.ToString()));
+    if (i > 0) StrAppend(result, ", ");
+    StrAppend(result, "priority ");
+    StrAppend(result, std::to_string(i));
+    StrAppend(result, ": ");
+    StrAppend(result, priorities[i].ToString());
   }
-  return absl::StrCat(
-      "priorities=[", absl::StrJoin(priority_strings, ", "), "], drop_config=",
-      drop_config == nullptr ? "<null>" : drop_config->ToString());
+  StrAppend(result, "]");
+  if (drop_config != nullptr) {
+    StrAppend(result, ", drop_config=");
+    StrAppend(result, drop_config->ToString());
+  }
+  StrAppend(result, "}");
+  return result;
 }
 
 }  // namespace grpc_core

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

@@ -19,8 +19,7 @@
 #include <string>
 
 #include "envoy/config/core/v3/health_check.upb.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
+#include "src/core/util/string.h"
 
 namespace grpc_core {
 
@@ -59,15 +58,20 @@ const char* XdsHealthStatus::ToString() const {
 }
 
 std::string XdsHealthStatusSet::ToString() const {
-  std::vector<const char*> set;
-  set.reserve(3);
+  std::string result = "{";
+  bool is_first = true;
   for (const auto& status :
        {XdsHealthStatus::kUnknown, XdsHealthStatus::kHealthy,
         XdsHealthStatus::kDraining}) {
     const XdsHealthStatus health_status(status);
-    if (Contains(health_status)) set.push_back(health_status.ToString());
+    if (Contains(health_status)) {
+      if (!is_first) StrAppend(result, ", ");
+      StrAppend(result, health_status.ToString());
+      is_first = false;
+    }
   }
-  return absl::StrCat("{", absl::StrJoin(set, ", "), "}");
+  StrAppend(result, "}");
+  return result;
 }
 
 }  // namespace grpc_core

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

@@ -0,0 +1,302 @@
+//
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "src/core/xds/grpc/xds_http_composite_filter.h"
+
+#include "envoy/config/core/v3/extension.upb.h"
+#include "envoy/extensions/common/matching/v3/extension_matcher.upb.h"
+#include "envoy/extensions/common/matching/v3/extension_matcher.upbdefs.h"
+#include "envoy/extensions/filters/common/matcher/action/v3/skip_action.upb.h"
+#include "envoy/extensions/filters/common/matcher/action/v3/skip_action.upbdefs.h"
+#include "envoy/extensions/filters/http/composite/v3/composite.upb.h"
+#include "envoy/extensions/filters/http/composite/v3/composite.upbdefs.h"
+#include "src/core/filter/composite/composite_filter.h"
+#include "src/core/util/validation_errors.h"
+#include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/grpc/xds_http_filter.h"
+#include "src/core/xds/grpc/xds_http_filter_registry.h"
+#include "src/core/xds/grpc/xds_matcher.h"
+#include "src/core/xds/grpc/xds_matcher_action.h"
+#include "src/core/xds/grpc/xds_matcher_context.h"
+#include "src/core/xds/grpc/xds_matcher_parse.h"
+#include "src/core/xds/xds_client/xds_client.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+absl::string_view XdsHttpCompositeFilter::ConfigProtoName() const {
+  return "envoy.extensions.common.matching.v3.ExtensionWithMatcher";
+}
+
+absl::string_view XdsHttpCompositeFilter::OverrideConfigProtoName() const {
+  return "envoy.extensions.common.matching.v3.ExtensionWithMatcherPerRoute";
+}
+
+void XdsHttpCompositeFilter::PopulateSymtab(upb_DefPool* symtab) const {
+  envoy_extensions_common_matching_v3_ExtensionWithMatcher_getmsgdef(symtab);
+  envoy_extensions_common_matching_v3_ExtensionWithMatcherPerRoute_getmsgdef(
+      symtab);
+  envoy_extensions_filters_common_matcher_action_v3_SkipFilter_getmsgdef(
+      symtab);
+  envoy_extensions_filters_http_composite_v3_Composite_getmsgdef(symtab);
+  envoy_extensions_filters_http_composite_v3_ExecuteFilterAction_getmsgdef(
+      symtab);
+}
+
+void XdsHttpCompositeFilter::AddFilter(
+    FilterChainBuilder& builder,
+    RefCountedPtr<const FilterConfig> config) const {
+  builder.AddFilter<CompositeFilter>(std::move(config));
+}
+
+const grpc_channel_filter* XdsHttpCompositeFilter::channel_filter() const {
+  return &CompositeFilter::kFilterVtable;
+}
+
+namespace {
+
+// Matcher action factory for SkipFilter.
+class SkipFilterActionFactory final : public XdsMatcherActionFactory {
+ public:
+  absl::string_view type() const override {
+    return CompositeFilter::SkipFilterAction::Type().name();
+  }
+
+  std::unique_ptr<XdsMatcher::Action> ParseAndCreateAction(
+      const XdsResourceType::DecodeContext& context,
+      absl::string_view serialized_value,
+      ValidationErrors* errors) const override {
+    const auto* skip_filter =
+        envoy_extensions_filters_common_matcher_action_v3_SkipFilter_parse(
+            serialized_value.data(), serialized_value.size(), context.arena);
+    if (skip_filter == nullptr) {
+      errors->AddError("could not parse SkipFilter action");
+      return nullptr;
+    }
+    return std::make_unique<CompositeFilter::SkipFilterAction>();
+  }
+};
+
+// Matcher action factory for ExecuteFilterAction.
+class ExecuteFilterActionFactory final : public XdsMatcherActionFactory {
+ public:
+  absl::string_view type() const override {
+    return CompositeFilter::ExecuteFilterAction::Type().name();
+  }
+
+  std::unique_ptr<XdsMatcher::Action> ParseAndCreateAction(
+      const XdsResourceType::DecodeContext& context,
+      absl::string_view serialized_value,
+      ValidationErrors* errors) const override {
+    const auto* execute_filter =
+        envoy_extensions_filters_http_composite_v3_ExecuteFilterAction_parse(
+            serialized_value.data(), serialized_value.size(), context.arena);
+    if (execute_filter == nullptr) {
+      errors->AddError("could not parse ExecuteFilterAction");
+      return nullptr;
+    }
+    const auto& http_filter_registry =
+        DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+            .http_filter_registry();
+    std::vector<CompositeFilter::ExecuteFilterAction::Filter> filters;
+    if (const auto* filter_chain =
+            envoy_extensions_filters_http_composite_v3_ExecuteFilterAction_filter_chain(
+                execute_filter);
+        filter_chain != nullptr) {
+      size_t num_filters;
+      const auto* const* typed_configs =
+          envoy_extensions_filters_http_composite_v3_FilterChainConfiguration_typed_config(
+              filter_chain, &num_filters);
+      for (size_t i = 0; i < num_filters; ++i) {
+        const auto* typed_config = typed_configs[i];
+        filters.push_back(
+            ParseFilter(context, http_filter_registry, typed_config, errors));
+      }
+    } else if (
+        const auto* typed_config =
+            envoy_extensions_filters_http_composite_v3_ExecuteFilterAction_typed_config(
+                execute_filter);
+        typed_config != nullptr) {
+      filters.push_back(
+          ParseFilter(context, http_filter_registry, typed_config, errors));
+    } else {
+      errors->AddError("one of typed_config or filter_chain must be set");
+    }
+    uint32_t sample_per_million = 1000000;
+    const auto* sample_percent_proto =
+        envoy_extensions_filters_http_composite_v3_ExecuteFilterAction_sample_percent(
+            execute_filter);
+    if (sample_percent_proto != nullptr) {
+      const auto* default_value =
+          envoy_config_core_v3_RuntimeFractionalPercent_default_value(
+              sample_percent_proto);
+      if (default_value == nullptr) {
+        ValidationErrors::ScopedField field(errors,
+                                            ".sample_percent.default_value");
+        errors->AddError("field not set");
+      } else {
+        sample_per_million = ParseFractionalPercent(default_value);
+      }
+    }
+    return std::make_unique<CompositeFilter::ExecuteFilterAction>(
+        std::move(filters), sample_per_million);
+  }
+
+ private:
+  static CompositeFilter::ExecuteFilterAction::Filter ParseFilter(
+      const XdsResourceType::DecodeContext& context,
+      const XdsHttpFilterRegistry& http_filter_registry,
+      const envoy_config_core_v3_TypedExtensionConfig* typed_config,
+      ValidationErrors* errors) {
+    absl::string_view name = UpbStringToAbsl(
+        envoy_config_core_v3_TypedExtensionConfig_name(typed_config));
+    const auto* any =
+        envoy_config_core_v3_TypedExtensionConfig_typed_config(typed_config);
+    ValidationErrors::ScopedField field(errors, ".typed_config.typed_config");
+    auto extension = ExtractXdsExtension(context, any, errors);
+    const XdsHttpFilterImpl* filter_impl = nullptr;
+    RefCountedPtr<const FilterConfig> config;
+    if (extension.has_value()) {
+      filter_impl =
+          http_filter_registry.GetFilterForTopLevelType(extension->type);
+      if (filter_impl == nullptr) {
+        errors->AddError("unsupported filter type");
+      } else if (filter_impl->IsTerminalFilter()) {
+        errors->AddError(
+            "terminal filters may not be used under composite filter");
+      } else {
+        config =
+            filter_impl->ParseTopLevelConfig(name, context, *extension, errors);
+      }
+    }
+    return {filter_impl, std::move(config)};
+  }
+};
+
+std::unique_ptr<XdsMatcher> ParseMatcher(
+    const XdsResourceType::DecodeContext& context,
+    const xds_type_matcher_v3_Matcher* matcher, ValidationErrors* errors) {
+  XdsMatcherActionRegistry action_registry;
+  action_registry.AddActionFactory(std::make_unique<SkipFilterActionFactory>());
+  action_registry.AddActionFactory(
+      std::make_unique<ExecuteFilterActionFactory>());
+  return ParseXdsMatcher(context, matcher, action_registry,
+                         RpcMatchContext::Type(),
+                         /*allow_keep_matching=*/false, errors);
+}
+
+}  // namespace
+
+RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::ParseTopLevelConfig(
+    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 composite filter config");
+    return nullptr;
+  }
+  auto* extension_with_matcher =
+      envoy_extensions_common_matching_v3_ExtensionWithMatcher_parse(
+          serialized_filter_config->data(), serialized_filter_config->size(),
+          context.arena);
+  if (extension_with_matcher == nullptr) {
+    errors->AddError("could not parse composite filter config");
+    return nullptr;
+  }
+  // Check extension_config.
+  const auto* extension_config =
+      envoy_extensions_common_matching_v3_ExtensionWithMatcher_extension_config(
+          extension_with_matcher);
+  if (extension_config == nullptr) {
+    ValidationErrors::ScopedField field(errors, ".extension_config");
+    errors->AddError("field not set");
+  } else {
+    ValidationErrors::ScopedField field(errors,
+                                        ".extension_config.typed_config");
+    const auto* typed_config =
+        envoy_config_core_v3_TypedExtensionConfig_typed_config(
+            extension_config);
+    auto extension = ExtractXdsExtension(context, typed_config, errors);
+    if (extension.has_value()) {
+      if (extension->type !=
+          "envoy.extensions.filters.http.composite.v3.Composite") {
+        errors->AddError("unsupported extension config type");
+      }
+    }
+  }
+  // Parse matcher.
+  auto config = MakeRefCounted<CompositeFilter::Config>();
+  const auto* matcher =
+      envoy_extensions_common_matching_v3_ExtensionWithMatcher_xds_matcher(
+          extension_with_matcher);
+  if (matcher != nullptr) {
+    ValidationErrors::ScopedField field(errors, ".xds_matcher");
+    config->matcher = ParseMatcher(context, matcher, errors);
+  }
+  return config;
+}
+
+RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::ParseOverrideConfig(
+    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 composite filter override config");
+    return nullptr;
+  }
+  auto* extension_with_matcher =
+      envoy_extensions_common_matching_v3_ExtensionWithMatcherPerRoute_parse(
+          serialized_filter_config->data(), serialized_filter_config->size(),
+          context.arena);
+  if (extension_with_matcher == nullptr) {
+    errors->AddError("could not parse composite filter override config");
+    return nullptr;
+  }
+  ValidationErrors::ScopedField field(errors, ".xds_matcher");
+  auto config = MakeRefCounted<CompositeFilter::Config>();
+  config->matcher = ParseMatcher(
+      context,
+      envoy_extensions_common_matching_v3_ExtensionWithMatcherPerRoute_xds_matcher(
+          extension_with_matcher),
+      errors);
+  return config;
+}
+
+void XdsHttpCompositeFilter::UpdateBlackboard(
+    const FilterConfig& config, const Blackboard* old_blackboard,
+    Blackboard* new_blackboard) const {
+  auto& composite_config = DownCast<const CompositeFilter::Config&>(config);
+  if (composite_config.matcher == nullptr) return;
+  composite_config.matcher->ForEachAction(
+      [&](const XdsMatcher::Action& action) {
+        if (action.type() != CompositeFilter::ExecuteFilterAction::Type()) {
+          return;
+        }
+        const auto& execute_filter_action =
+            DownCast<const CompositeFilter::ExecuteFilterAction&>(action);
+        for (const auto& [filter_impl, filter_config] :
+             execute_filter_action.filter_chain()) {
+          filter_impl->UpdateBlackboard(*filter_config, old_blackboard,
+                                        new_blackboard);
+        }
+      });
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,84 @@
+//
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_HTTP_COMPOSITE_FILTER_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_HTTP_COMPOSITE_FILTER_H
+
+#include <optional>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/util/validation_errors.h"
+#include "src/core/xds/grpc/xds_common_types.h"
+#include "src/core/xds/grpc/xds_http_filter.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
+#include "upb/reflection/def.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+class XdsHttpCompositeFilter final : public XdsHttpFilterImpl {
+ public:
+  absl::string_view ConfigProtoName() const override;
+  absl::string_view OverrideConfigProtoName() const override;
+  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 {
+    return std::nullopt;
+  }
+  std::optional<Json> GenerateFilterConfigOverride(
+      absl::string_view /*instance_name*/,
+      const XdsResourceType::DecodeContext& /*context*/,
+      const XdsExtension& /*extension*/,
+      ValidationErrors* /*errors*/) const override {
+    return std::nullopt;
+  }
+  const grpc_channel_filter* channel_filter() const override;
+  absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
+      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 {
+    return absl::UnimplementedError(
+        "old-style filter config APIs not supported");
+  }
+  void AddFilter(FilterChainBuilder& builder,
+                 RefCountedPtr<const FilterConfig> config) const override;
+  RefCountedPtr<const FilterConfig> ParseTopLevelConfig(
+      absl::string_view instance_name,
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
+  RefCountedPtr<const FilterConfig> ParseOverrideConfig(
+      absl::string_view instance_name,
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
+  void UpdateBlackboard(const FilterConfig& config,
+                        const Blackboard* old_blackboard,
+                        Blackboard* new_blackboard) const override;
+  bool IsSupportedOnClients() const override { return true; }
+  bool IsSupportedOnServers() const override { return false; }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_HTTP_COMPOSITE_FILTER_H

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

@@ -16,8 +16,6 @@
 
 #include "src/core/xds/grpc/xds_http_filter_registry.h"
 
-#include <grpc/support/port_platform.h>
-
 #include <map>
 #include <utility>
 #include <variant>
@@ -25,8 +23,11 @@
 
 #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/util/grpc_check.h"
 #include "src/core/util/json/json.h"
+#include "src/core/util/sync.h"
+#include "src/core/xds/grpc/xds_http_composite_filter.h"
 #include "src/core/xds/grpc/xds_http_fault_filter.h"
 #include "src/core/xds/grpc/xds_http_gcp_authn_filter.h"
 #include "src/core/xds/grpc/xds_http_rbac_filter.h"
@@ -109,6 +110,30 @@ RefCountedPtr<const FilterConfig> XdsHttpRouterFilter::ParseOverrideConfig(
 // XdsHttpFilterRegistry
 //
 
+namespace {
+
+bool XdsCompositeFilterEnabled() {
+  // This experiment is a prereq.
+  if (!IsXdsChannelFilterChainPerRouteEnabled()) return false;
+  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);
+
+}  // namespace
+
+void SetXdsHttpFilterFactoryForTest(
+    absl::AnyInvocable<std::unique_ptr<XdsHttpFilterImpl>()> factory) {
+  MutexLock lock(g_mu);
+  *g_http_filter_factory_factory = std::move(factory);
+}
+
 XdsHttpFilterRegistry::XdsHttpFilterRegistry(bool register_builtins) {
   if (register_builtins) {
     RegisterFilter(std::make_unique<XdsHttpRouterFilter>());
@@ -116,6 +141,13 @@ XdsHttpFilterRegistry::XdsHttpFilterRegistry(bool register_builtins) {
     RegisterFilter(std::make_unique<XdsHttpRbacFilter>());
     RegisterFilter(std::make_unique<XdsHttpStatefulSessionFilter>());
     RegisterFilter(std::make_unique<XdsHttpGcpAuthnFilter>());
+    if (XdsCompositeFilterEnabled()) {
+      RegisterFilter(std::make_unique<XdsHttpCompositeFilter>());
+    }
+    MutexLock lock(g_mu);
+    if (*g_http_filter_factory_factory != nullptr) {
+      RegisterFilter((*g_http_filter_factory_factory)());
+    }
   }
 }
 

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

@@ -31,6 +31,7 @@
 #include "src/core/xds/grpc/xds_http_filter.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "upb/reflection/def.h"
+#include "absl/functional/any_invocable.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
@@ -113,6 +114,9 @@ class XdsHttpFilterRegistry final {
   std::map<absl::string_view, XdsHttpFilterImpl*> override_config_map_;
 };
 
+void SetXdsHttpFilterFactoryForTest(
+    absl::AnyInvocable<std::unique_ptr<XdsHttpFilterImpl>()> factory);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_HTTP_FILTER_REGISTRY_H