grpc 1.81.1 → 1.82.0.pre2

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

@@ -0,0 +1,58 @@
+//
+// Copyright 2024 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/blackboard.h"
+
+namespace grpc_core {
+
+void Blackboard::Entry::Orphaned() {
+  if (blackboard_ != nullptr) blackboard_->Remove(type_, key_, this);
+}
+
+RefCountedPtr<Blackboard::Entry> Blackboard::Get(UniqueTypeName type,
+                                                 const std::string& key) const {
+  MutexLock lock(&mu_);
+  auto it = map_.find(std::pair(type, key));
+  if (it == map_.end()) return nullptr;
+  return it->second->RefIfNonZero();
+}
+
+RefCountedPtr<Blackboard::Entry> Blackboard::GetOrSet(
+    UniqueTypeName type, const std::string& key,
+    absl::FunctionRef<RefCountedPtr<Entry>()> construct) {
+  MutexLock lock(&mu_);
+  auto& entry = map_[std::pair(type, key)];
+  if (entry != nullptr) {
+    auto reffed_entry = entry->RefIfNonZero();
+    if (reffed_entry != nullptr) return reffed_entry;
+  }
+  auto constructed = construct();
+  entry = constructed->WeakRef();
+  constructed->blackboard_ = Ref();
+  constructed->type_ = type;
+  constructed->key_ = key;
+  return constructed;
+}
+
+void Blackboard::Remove(UniqueTypeName type, const std::string& key,
+                        Entry* entry) {
+  MutexLock lock(&mu_);
+  auto it = map_.find(std::pair(type, key));
+  if (it == map_.end()) return;
+  if (it->second == entry) map_.erase(it);
+}
+
+}  // namespace grpc_core

data/src/core/{filter → xds/grpc}/blackboard.h

@@ -14,19 +14,22 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_FILTER_BLACKBOARD_H
-#define GRPC_SRC_CORE_FILTER_BLACKBOARD_H
+#ifndef GRPC_SRC_CORE_XDS_GRPC_BLACKBOARD_H
+#define GRPC_SRC_CORE_XDS_GRPC_BLACKBOARD_H
 
 #include <string>
 #include <utility>
 
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/dual_ref_counted.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/useful.h"
 #include "absl/container/flat_hash_map.h"
+#include "absl/functional/function_ref.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
@@ -41,7 +44,17 @@ class Blackboard : public RefCounted<Blackboard> {
   // All entries must derive from this type.
   // They must also have a static method with the following signature:
   //  static UniqueTypeName Type();
-  class Entry : public RefCounted<Entry> {};
+  class Entry : public DualRefCounted<Entry> {
+   public:
+    void Orphaned() final;
+
+   private:
+    friend class Blackboard;
+
+    RefCountedPtr<Blackboard> blackboard_;
+    UniqueTypeName type_{GRPC_UNIQUE_TYPE_NAME_HERE("")};
+    std::string key_;
+  };
 
   // Returns an entry for a particular type and name, or null if not present.
   template <typename T>
@@ -49,22 +62,28 @@ class Blackboard : public RefCounted<Blackboard> {
     return Get(T::Type(), key).template TakeAsSubclass<T>();
   }
 
-  // Sets an entry for a particular type and name.
+  // Gets the entry for the specified key.  If not present, invokes
+  // construct to create it.  Returns the entry.
   template <typename T>
-  void Set(const std::string& key, RefCountedPtr<T> entry) {
-    Set(T::Type(), key, std::move(entry));
+  RefCountedPtr<T> GetOrSet(const std::string& key,
+                            absl::FunctionRef<RefCountedPtr<T>()> construct) {
+    return GetOrSet(T::Type(), key, std::move(construct))
+        .template TakeAsSubclass<T>();
   }
 
  private:
   RefCountedPtr<Entry> Get(UniqueTypeName type, const std::string& key) const;
-  void Set(UniqueTypeName type, const std::string& key,
-           RefCountedPtr<Entry> entry);
+  RefCountedPtr<Entry> GetOrSet(
+      UniqueTypeName type, const std::string& key,
+      absl::FunctionRef<RefCountedPtr<Entry>()> construct);
+  void Remove(UniqueTypeName type, const std::string& key, Entry* entry);
 
+  mutable Mutex mu_;
   absl::flat_hash_map<std::pair<UniqueTypeName, std::string>,
-                      RefCountedPtr<Entry>>
-      map_;
+                      WeakRefCountedPtr<Entry>>
+      map_ ABSL_GUARDED_BY(&mu_);
 };
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_FILTER_BLACKBOARD_H
+#endif  // GRPC_SRC_CORE_XDS_GRPC_BLACKBOARD_H

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

@@ -16,8 +16,11 @@
 
 #include "src/core/xds/grpc/xds_common_types.h"
 
+#include <string>
+
 #include "src/core/util/match.h"
 #include "src/core/util/string.h"
+#include "src/core/util/time.h"
 #include "absl/strings/match.h"
 
 namespace grpc_core {
@@ -112,6 +115,43 @@ bool CommonTlsContext::Empty() const {
          certificate_validation_context.Empty();
 }
 
+//
+// XdsGrpcService
+//
+
+std::string XdsGrpcService::ToString() const {
+  std::string result = "{";
+  bool is_first = true;
+  if (server_target != nullptr) {
+    StrAppend(result, "server_target=");
+    StrAppend(result, server_target->Key());
+    is_first = false;
+  }
+  if (timeout != Duration::Zero()) {
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "timeout=");
+    StrAppend(result, timeout.ToString());
+    is_first = false;
+  }
+  if (!initial_metadata.empty()) {
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "initial_metadata=[");
+    bool is_first_metadata = true;
+    for (const auto& metadata : initial_metadata) {
+      if (!is_first_metadata) StrAppend(result, ", ");
+      StrAppend(result, "{key=");
+      StrAppend(result, metadata.first);
+      StrAppend(result, ", value=");
+      StrAppend(result, metadata.second);
+      StrAppend(result, "}");
+      is_first_metadata = false;
+    }
+    StrAppend(result, "]");
+  }
+  StrAppend(result, "}");
+  return result;
+}
+
 //
 // HeaderMutationRules
 //

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

@@ -17,12 +17,15 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_H
 
+#include <memory>
 #include <string>
+#include <utility>
 #include <variant>
 #include <vector>
 
 #include "src/core/util/json/json.h"
 #include "src/core/util/matchers.h"
+#include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_server_grpc.h"
 #include "absl/strings/string_view.h"
@@ -90,6 +93,16 @@ struct XdsGrpcService {
   std::unique_ptr<GrpcXdsServerTarget> server_target;
   Duration timeout;
   std::vector<std::pair<std::string, std::string>> initial_metadata;
+
+  bool operator==(const XdsGrpcService& other) const {
+    if (timeout != other.timeout) return false;
+    if (initial_metadata != other.initial_metadata) return false;
+    if (server_target == nullptr) return other.server_target == nullptr;
+    if (other.server_target == nullptr) return false;
+    return server_target->Equals(*other.server_target);
+  }
+
+  std::string ToString() const;
 };
 
 struct HeaderMutationRules {

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

@@ -22,9 +22,12 @@
 
 #include <algorithm>
 #include <map>
+#include <optional>
+#include <string>
 #include <utility>
 
 #include "envoy/config/core/v3/address.upb.h"
+#include "envoy/config/core/v3/base.upb.h"
 #include "envoy/extensions/transport_sockets/tls/v3/common.upb.h"
 #include "envoy/extensions/transport_sockets/tls/v3/tls.upb.h"
 #include "envoy/type/matcher/v3/regex.upb.h"
@@ -39,6 +42,7 @@
 #include "src/core/util/env.h"
 #include "src/core/util/json/json_reader.h"
 #include "src/core/util/upb_utils.h"
+#include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
 #include "src/core/xds/xds_client/xds_client.h"
 #include "upb/base/status.hpp"
@@ -48,9 +52,12 @@
 #include "xds/type/v3/typed_struct.upb.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -616,22 +623,26 @@ std::optional<XdsExtension> ExtractXdsExtension(
 
 namespace {
 
-absl::string_view GetHeaderValue(upb_StringView upb_value,
-                                 absl::string_view field_name, bool validate,
-                                 ValidationErrors* errors) {
+std::optional<std::string> GetHeaderValue(upb_StringView upb_value,
+                                          bool is_binary,
+                                          absl::string_view field_name,
+                                          ValidationErrors* errors) {
   absl::string_view value = UpbStringToAbsl(upb_value);
-  if (!value.empty()) {
-    ValidationErrors::ScopedField field(errors, field_name);
-    if (value.size() > 16384) errors->AddError("longer than 16384 bytes");
-    if (validate) {
-      ValidateMetadataResult result =
-          ValidateNonBinaryHeaderValueIsLegal(value);
-      if (result != ValidateMetadataResult::kOk) {
-        errors->AddError(ValidateMetadataResultToString(result));
-      }
+  if (value.empty()) return std::nullopt;
+  ValidationErrors::ScopedField field(errors, field_name);
+  if (value.size() > 16384) errors->AddError("longer than 16384 bytes");
+  if (is_binary) {
+    std::string decoded_value;
+    if (!absl::Base64Unescape(value, &decoded_value)) {
+      errors->AddError("invalid base64");
     }
+    return decoded_value;
+  }
+  ValidateMetadataResult result = ValidateNonBinaryHeaderValueIsLegal(value);
+  if (result != ValidateMetadataResult::kOk) {
+    errors->AddError(ValidateMetadataResultToString(result));
   }
-  return value;
+  return std::string(value);
 }
 
 std::pair<std::string, std::string> ParseHeader(
@@ -653,30 +664,22 @@ std::pair<std::string, std::string> ParseHeader(
       }
     }
   }
-  // value or raw_value
-  absl::string_view value;
-  if (absl::EndsWith(key, "-bin")) {
-    value =
-        GetHeaderValue(envoy_config_core_v3_HeaderValue_raw_value(header_value),
-                       ".raw_value", /*validate=*/false, errors);
-    if (value.empty()) {
-      value =
-          GetHeaderValue(envoy_config_core_v3_HeaderValue_value(header_value),
-                         ".value", /*validate=*/true, errors);
-      if (value.empty()) {
-        errors->AddError("either value or raw_value must be set");
-      }
-    }
-  } else {
-    // Key does not end in "-bin".
+  // Per gRFC A102, when reading HeaderValue protos, we prioritize reading
+  // the raw_value field for both binary and non-binary headers across xDS and
+  // side-streams. If raw_value is unset, we fall back to using the value field
+  // for backward compatibility.
+  bool is_binary = absl::EndsWith(key, "-bin");
+  std::optional<std::string> value =
+      GetHeaderValue(envoy_config_core_v3_HeaderValue_raw_value(header_value),
+                     is_binary, ".raw_value", errors);
+  if (!value.has_value()) {
     value = GetHeaderValue(envoy_config_core_v3_HeaderValue_value(header_value),
-                           ".value", /*validate=*/true, errors);
-    if (value.empty()) {
-      ValidationErrors::ScopedField field(errors, ".value");
-      errors->AddError("field not set");
+                           is_binary, ".value", errors);
+    if (!value.has_value()) {
+      errors->AddError("either value or raw_value must be set");
     }
   }
-  return {std::string(key), std::string(value)};
+  return {std::string(key), value.has_value() ? std::move(*value) : ""};
 }
 
 }  // namespace

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

@@ -367,7 +367,7 @@ absl::StatusOr<std::shared_ptr<const XdsEndpointResource>> EdsResourceParse(
           LocalityParse(context, endpoints[i], &address_set, &errors);
       if (parsed_locality.has_value()) {
         GRPC_CHECK_NE(parsed_locality->locality.lb_weight, 0u);
-        // Make sure prorities is big enough. Note that they might not
+        // Make sure priorities is big enough. Note that they might not
         // arrive in priority order.
         if (eds_resource->priorities.size() < parsed_locality->priority + 1) {
           eds_resource->priorities.resize(parsed_locality->priority + 1);

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

@@ -279,24 +279,40 @@ RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::ParseOverrideConfig(
   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);
-        }
-      });
+RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::MergeConfigs(
+    RefCountedPtr<const FilterConfig> top_level_config,
+    RefCountedPtr<const FilterConfig> virtual_host_override_config,
+    RefCountedPtr<const FilterConfig> route_override_config,
+    RefCountedPtr<const FilterConfig> cluster_weight_override_config,
+    Blackboard& blackboard) const {
+  // Get the config to use via our base class.
+  auto config_to_use = XdsHttpFilterImpl::MergeConfigs(
+      std::move(top_level_config), std::move(virtual_host_override_config),
+      std::move(route_override_config),
+      std::move(cluster_weight_override_config), blackboard);
+  auto& composite_config =
+      DownCast<const CompositeFilter::Config&>(*config_to_use);
+  if (composite_config.matcher == nullptr) return config_to_use;
+  // Make a copy of the config and populate its merged_config_map.
+  auto new_config = MakeRefCounted<CompositeFilter::Config>();
+  new_config->matcher = composite_config.matcher;
+  new_config->matcher->ForEachAction([&](const XdsMatcher::Action& action) {
+    if (action.type() != CompositeFilter::ExecuteFilterAction::Type()) {
+      return;
+    }
+    const auto& execute_filter_action =
+        DownCast<const CompositeFilter::ExecuteFilterAction&>(action);
+    auto& merged_configs = new_config->merged_config_map[&action];
+    GRPC_CHECK(merged_configs.empty());
+    for (const auto& [filter_impl, filter_config] :
+         execute_filter_action.filter_chain()) {
+      merged_configs.push_back(filter_impl->MergeConfigs(
+          filter_config, /*virtual_host_override_config=*/nullptr,
+          /*route_override_config=*/nullptr,
+          /*cluster_weight_override_config=*/nullptr, blackboard));
+    }
+  });
+  return new_config;
 }
 
 }  // namespace grpc_core

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

@@ -72,9 +72,12 @@ class XdsHttpCompositeFilter final : public XdsHttpFilterImpl {
       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;
+  RefCountedPtr<const FilterConfig> MergeConfigs(
+      RefCountedPtr<const FilterConfig> top_level_config,
+      RefCountedPtr<const FilterConfig> virtual_host_override_config,
+      RefCountedPtr<const FilterConfig> route_override_config,
+      RefCountedPtr<const FilterConfig> cluster_weight_override_config,
+      Blackboard& blackboard) const override;
   bool IsSupportedOnClients() const override { return true; }
   bool IsSupportedOnServers() const override { return false; }
 };

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

@@ -32,7 +32,6 @@
 #include "google/protobuf/wrappers.upb.h"
 #include "src/core/call/status_util.h"
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
-#include "src/core/ext/filters/fault_injection/fault_injection_service_config_parser.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/transport/status_conversion.h"
 #include "src/core/util/json/json.h"
@@ -83,133 +82,6 @@ void XdsHttpFaultFilter::PopulateSymtab(upb_DefPool* symtab) const {
   envoy_extensions_filters_http_fault_v3_HTTPFault_getmsgdef(symtab);
 }
 
-std::optional<Json> XdsHttpFaultFilter::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 fault injection filter config");
-    return std::nullopt;
-  }
-  auto* http_fault = envoy_extensions_filters_http_fault_v3_HTTPFault_parse(
-      serialized_filter_config->data(), serialized_filter_config->size(),
-      context.arena);
-  if (http_fault == nullptr) {
-    errors->AddError("could not parse fault injection filter config");
-    return std::nullopt;
-  }
-  // NOTE(lidiz): Here, we are manually translating the upb messages into the
-  // JSON form of the filter config as part of method config, which will be
-  // directly used later by service config. In this way, we can validate the
-  // filter configs, and NACK if needed. It also allows the service config to
-  // function independently without xDS, but not the other way around.
-  // NOTE(lidiz): please refer to FaultInjectionPolicy for ground truth
-  // definitions, located at:
-  // src/core/ext/filters/fault_injection/service_config_parser.h
-  Json::Object fault_injection_policy_json;
-  // Section 1: Parse the abort injection config
-  const auto* fault_abort =
-      envoy_extensions_filters_http_fault_v3_HTTPFault_abort(http_fault);
-  if (fault_abort != nullptr) {
-    ValidationErrors::ScopedField field(errors, ".abort");
-    grpc_status_code abort_grpc_status_code = GRPC_STATUS_OK;
-    // Try if gRPC status code is set first.  Otherwise, use HTTP status.
-    if (int abort_grpc_status_code_raw =
-            envoy_extensions_filters_http_fault_v3_FaultAbort_grpc_status(
-                fault_abort);
-        abort_grpc_status_code_raw != 0) {
-      if (!grpc_status_code_from_int(abort_grpc_status_code_raw,
-                                     &abort_grpc_status_code)) {
-        ValidationErrors::ScopedField field(errors, ".grpc_status");
-        errors->AddError(absl::StrCat("invalid gRPC status code: ",
-                                      abort_grpc_status_code_raw));
-      }
-    } else if (
-        int abort_http_status_code =
-            envoy_extensions_filters_http_fault_v3_FaultAbort_http_status(
-                fault_abort);
-        abort_http_status_code != 0 && abort_http_status_code != 200) {
-      abort_grpc_status_code =
-          grpc_http2_status_to_grpc_status(abort_http_status_code);
-    }
-    // Set the abort_code, even if it's OK
-    fault_injection_policy_json["abortCode"] =
-        Json::FromString(grpc_status_code_to_string(abort_grpc_status_code));
-    // Set the headers if we enabled header abort injection control
-    if (envoy_extensions_filters_http_fault_v3_FaultAbort_has_header_abort(
-            fault_abort)) {
-      fault_injection_policy_json["abortCodeHeader"] =
-          Json::FromString("x-envoy-fault-abort-grpc-request");
-      fault_injection_policy_json["abortPercentageHeader"] =
-          Json::FromString("x-envoy-fault-abort-percentage");
-    }
-    // Set the fraction percent
-    auto* percent =
-        envoy_extensions_filters_http_fault_v3_FaultAbort_percentage(
-            fault_abort);
-    if (percent != nullptr) {
-      fault_injection_policy_json["abortPercentageNumerator"] =
-          Json::FromNumber(envoy_type_v3_FractionalPercent_numerator(percent));
-      fault_injection_policy_json["abortPercentageDenominator"] =
-          Json::FromNumber(GetDenominator(percent));
-    }
-  }
-  // Section 2: Parse the delay injection config
-  const auto* fault_delay =
-      envoy_extensions_filters_http_fault_v3_HTTPFault_delay(http_fault);
-  if (fault_delay != nullptr) {
-    ValidationErrors::ScopedField field(errors, ".delay");
-    // Parse the delay duration
-    const auto* delay_duration =
-        envoy_extensions_filters_common_fault_v3_FaultDelay_fixed_delay(
-            fault_delay);
-    if (delay_duration != nullptr) {
-      ValidationErrors::ScopedField field(errors, ".fixed_delay");
-      Duration duration = ParseDuration(delay_duration, errors);
-      fault_injection_policy_json["delay"] =
-          Json::FromString(duration.ToJsonString());
-    }
-    // Set the headers if we enabled header delay injection control
-    if (envoy_extensions_filters_common_fault_v3_FaultDelay_has_header_delay(
-            fault_delay)) {
-      fault_injection_policy_json["delayHeader"] =
-          Json::FromString("x-envoy-fault-delay-request");
-      fault_injection_policy_json["delayPercentageHeader"] =
-          Json::FromString("x-envoy-fault-delay-request-percentage");
-    }
-    // Set the fraction percent
-    auto* percent =
-        envoy_extensions_filters_common_fault_v3_FaultDelay_percentage(
-            fault_delay);
-    if (percent != nullptr) {
-      fault_injection_policy_json["delayPercentageNumerator"] =
-          Json::FromNumber(envoy_type_v3_FractionalPercent_numerator(percent));
-      fault_injection_policy_json["delayPercentageDenominator"] =
-          Json::FromNumber(GetDenominator(percent));
-    }
-  }
-  // Section 3: Parse the maximum active faults
-  auto max_fault_wrapper = ParseUInt32Value(
-      envoy_extensions_filters_http_fault_v3_HTTPFault_max_active_faults(
-          http_fault));
-  if (max_fault_wrapper.has_value()) {
-    fault_injection_policy_json["maxFaults"] =
-        Json::FromNumber(*max_fault_wrapper);
-  }
-  return Json::FromObject(std::move(fault_injection_policy_json));
-}
-
-std::optional<Json> XdsHttpFaultFilter::GenerateFilterConfigOverride(
-    absl::string_view instance_name,
-    const XdsResourceType::DecodeContext& context,
-    const XdsExtension& extension, ValidationErrors* errors) const {
-  // HTTPFault filter has the same message type in HTTP connection manager's
-  // filter config and in overriding filter config field.
-  return GenerateFilterConfig(instance_name, context, extension, errors);
-}
-
 const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {
   return &FaultInjectionFilter::kFilterVtable;
 }
@@ -220,27 +92,6 @@ void XdsHttpFaultFilter::AddFilter(
   builder.AddFilter<FaultInjectionFilter>(std::move(config));
 }
 
-ChannelArgs XdsHttpFaultFilter::ModifyChannelArgs(
-    const ChannelArgs& args) const {
-  return args.Set(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG, 1);
-}
-
-absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
-XdsHttpFaultFilter::GenerateMethodConfig(
-    const Json& hcm_filter_config, const Json* filter_config_override) const {
-  const Json& policy_json = filter_config_override != nullptr
-                                ? *filter_config_override
-                                : hcm_filter_config;
-  // The policy JSON may be empty, that's allowed.
-  return ServiceConfigJsonEntry{"faultInjectionPolicy", JsonDump(policy_json)};
-}
-
-absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
-XdsHttpFaultFilter::GenerateServiceConfig(
-    const Json& /*hcm_filter_config*/) const {
-  return ServiceConfigJsonEntry{"", ""};
-}
-
 RefCountedPtr<const FilterConfig> XdsHttpFaultFilter::ParseTopLevelConfig(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& context,

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

@@ -40,19 +40,30 @@ class XdsHttpFaultFilter 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_http_filter.cc

@@ -22,7 +22,8 @@ RefCountedPtr<const FilterConfig> XdsHttpFilterImpl::MergeConfigs(
     RefCountedPtr<const FilterConfig> top_level_config,
     RefCountedPtr<const FilterConfig> virtual_host_override_config,
     RefCountedPtr<const FilterConfig> route_override_config,
-    RefCountedPtr<const FilterConfig> cluster_weight_override_config) const {
+    RefCountedPtr<const FilterConfig> cluster_weight_override_config,
+    Blackboard& /*blackboard*/) const {
   if (cluster_weight_override_config != nullptr) {
     return cluster_weight_override_config;
   }