grpc 1.66.0 → 1.67.0.pre1

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

@@ -58,6 +58,7 @@
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_common_types_parser.h"
 #include "src/core/xds/grpc/xds_lb_policy_registry.h"
+#include "src/core/xds/grpc/xds_metadata_parser.h"
 
 namespace grpc_core {
 
@@ -300,22 +301,22 @@ void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
     uint64_t max_ring_size = 8388608;
     if (ring_hash_config != nullptr) {
       ValidationErrors::ScopedField field(errors, ".ring_hash_lb_config");
-      const google_protobuf_UInt64Value* uint64_value =
+      auto value = ParseUInt64Value(
           envoy_config_cluster_v3_Cluster_RingHashLbConfig_maximum_ring_size(
-              ring_hash_config);
-      if (uint64_value != nullptr) {
+              ring_hash_config));
+      if (value.has_value()) {
         ValidationErrors::ScopedField field(errors, ".maximum_ring_size");
-        max_ring_size = google_protobuf_UInt64Value_value(uint64_value);
+        max_ring_size = *value;
         if (max_ring_size > 8388608 || max_ring_size == 0) {
           errors->AddError("must be in the range of 1 to 8388608");
         }
       }
-      uint64_value =
+      value = ParseUInt64Value(
           envoy_config_cluster_v3_Cluster_RingHashLbConfig_minimum_ring_size(
-              ring_hash_config);
-      if (uint64_value != nullptr) {
+              ring_hash_config));
+      if (value.has_value()) {
         ValidationErrors::ScopedField field(errors, ".minimum_ring_size");
-        min_ring_size = google_protobuf_UInt64Value_value(uint64_value);
+        min_ring_size = *value;
         if (min_ring_size > 8388608 || min_ring_size == 0) {
           errors->AddError("must be in the range of 1 to 8388608");
         }
@@ -478,13 +479,10 @@ absl::StatusOr<std::shared_ptr<const XdsClusterResource>> CdsResourceParse(
       const auto* threshold = thresholds[i];
       if (envoy_config_cluster_v3_CircuitBreakers_Thresholds_priority(
               threshold) == envoy_config_core_v3_DEFAULT) {
-        const google_protobuf_UInt32Value* max_requests =
+        auto value = ParseUInt32Value(
             envoy_config_cluster_v3_CircuitBreakers_Thresholds_max_requests(
-                threshold);
-        if (max_requests != nullptr) {
-          cds_update->max_concurrent_requests =
-              google_protobuf_UInt32Value_value(max_requests);
-        }
+                threshold));
+        if (value.has_value()) cds_update->max_concurrent_requests = *value;
         break;
       }
     }
@@ -515,91 +513,80 @@ absl::StatusOr<std::shared_ptr<const XdsClusterResource>> CdsResourceParse(
       outlier_detection_update.max_ejection_time =
           ParseDuration(duration, &errors);
     }
-    const google_protobuf_UInt32Value* max_ejection_percent =
+    auto max_ejection_percent = ParseUInt32Value(
         envoy_config_cluster_v3_OutlierDetection_max_ejection_percent(
-            outlier_detection);
-    if (max_ejection_percent != nullptr) {
-      outlier_detection_update.max_ejection_percent =
-          google_protobuf_UInt32Value_value(max_ejection_percent);
+            outlier_detection));
+    if (max_ejection_percent.has_value()) {
+      outlier_detection_update.max_ejection_percent = *max_ejection_percent;
       if (outlier_detection_update.max_ejection_percent > 100) {
         ValidationErrors::ScopedField field(&errors, ".max_ejection_percent");
         errors.AddError("value must be <= 100");
       }
     }
-    const google_protobuf_UInt32Value* enforcing_success_rate =
+    auto enforcement_percentage = ParseUInt32Value(
         envoy_config_cluster_v3_OutlierDetection_enforcing_success_rate(
-            outlier_detection);
-    if (enforcing_success_rate != nullptr) {
-      uint32_t enforcement_percentage =
-          google_protobuf_UInt32Value_value(enforcing_success_rate);
-      if (enforcement_percentage > 100) {
+            outlier_detection));
+    if (enforcement_percentage.has_value()) {
+      if (*enforcement_percentage > 100) {
         ValidationErrors::ScopedField field(&errors, ".enforcing_success_rate");
         errors.AddError("value must be <= 100");
       }
-      if (enforcement_percentage != 0) {
+      if (*enforcement_percentage != 0) {
         OutlierDetectionConfig::SuccessRateEjection success_rate_ejection;
-        success_rate_ejection.enforcement_percentage = enforcement_percentage;
-        const google_protobuf_UInt32Value* minimum_hosts =
+        success_rate_ejection.enforcement_percentage = *enforcement_percentage;
+        auto minimum_hosts = ParseUInt32Value(
             envoy_config_cluster_v3_OutlierDetection_success_rate_minimum_hosts(
-                outlier_detection);
-        if (minimum_hosts != nullptr) {
-          success_rate_ejection.minimum_hosts =
-              google_protobuf_UInt32Value_value(minimum_hosts);
+                outlier_detection));
+        if (minimum_hosts.has_value()) {
+          success_rate_ejection.minimum_hosts = *minimum_hosts;
         }
-        const google_protobuf_UInt32Value* request_volume =
+        auto request_volume = ParseUInt32Value(
             envoy_config_cluster_v3_OutlierDetection_success_rate_request_volume(
-                outlier_detection);
-        if (request_volume != nullptr) {
-          success_rate_ejection.request_volume =
-              google_protobuf_UInt32Value_value(request_volume);
+                outlier_detection));
+        if (request_volume.has_value()) {
+          success_rate_ejection.request_volume = *request_volume;
         }
-        const google_protobuf_UInt32Value* stdev_factor =
+        auto stdev_factor = ParseUInt32Value(
             envoy_config_cluster_v3_OutlierDetection_success_rate_stdev_factor(
-                outlier_detection);
-        if (stdev_factor != nullptr) {
-          success_rate_ejection.stdev_factor =
-              google_protobuf_UInt32Value_value(stdev_factor);
+                outlier_detection));
+        if (stdev_factor.has_value()) {
+          success_rate_ejection.stdev_factor = *stdev_factor;
         }
         outlier_detection_update.success_rate_ejection = success_rate_ejection;
       }
     }
-    const google_protobuf_UInt32Value* enforcing_failure_percentage =
+    enforcement_percentage = ParseUInt32Value(
         envoy_config_cluster_v3_OutlierDetection_enforcing_failure_percentage(
-            outlier_detection);
-    if (enforcing_failure_percentage != nullptr) {
-      uint32_t enforcement_percentage =
-          google_protobuf_UInt32Value_value(enforcing_failure_percentage);
-      if (enforcement_percentage > 100) {
+            outlier_detection));
+    if (enforcement_percentage.has_value()) {
+      if (*enforcement_percentage > 100) {
         ValidationErrors::ScopedField field(&errors,
                                             ".enforcing_failure_percentage");
         errors.AddError("value must be <= 100");
       }
-      if (enforcement_percentage != 0) {
+      if (*enforcement_percentage != 0) {
         OutlierDetectionConfig::FailurePercentageEjection
             failure_percentage_ejection;
         failure_percentage_ejection.enforcement_percentage =
-            enforcement_percentage;
-        const google_protobuf_UInt32Value* minimum_hosts =
+            *enforcement_percentage;
+        auto minimum_hosts = ParseUInt32Value(
             envoy_config_cluster_v3_OutlierDetection_failure_percentage_minimum_hosts(
-                outlier_detection);
-        if (minimum_hosts != nullptr) {
-          failure_percentage_ejection.minimum_hosts =
-              google_protobuf_UInt32Value_value(minimum_hosts);
+                outlier_detection));
+        if (minimum_hosts.has_value()) {
+          failure_percentage_ejection.minimum_hosts = *minimum_hosts;
         }
-        const google_protobuf_UInt32Value* request_volume =
+        auto request_volume = ParseUInt32Value(
             envoy_config_cluster_v3_OutlierDetection_failure_percentage_request_volume(
-                outlier_detection);
-        if (request_volume != nullptr) {
-          failure_percentage_ejection.request_volume =
-              google_protobuf_UInt32Value_value(request_volume);
+                outlier_detection));
+        if (request_volume.has_value()) {
+          failure_percentage_ejection.request_volume = *request_volume;
         }
-        const google_protobuf_UInt32Value* threshold =
+        auto threshold = ParseUInt32Value(
             envoy_config_cluster_v3_OutlierDetection_failure_percentage_threshold(
-                outlier_detection);
-        if (threshold != nullptr) {
-          failure_percentage_ejection.threshold =
-              google_protobuf_UInt32Value_value(threshold);
-          if (enforcement_percentage > 100) {
+                outlier_detection));
+        if (threshold.has_value()) {
+          failure_percentage_ejection.threshold = *threshold;
+          if (*enforcement_percentage > 100) {
             ValidationErrors::ScopedField field(
                 &errors, ".failure_percentage_threshold");
             errors.AddError("value must be <= 100");
@@ -641,36 +628,11 @@ absl::StatusOr<std::shared_ptr<const XdsClusterResource>> CdsResourceParse(
     cds_update->override_host_statuses.Add(
         XdsHealthStatus(XdsHealthStatus::kHealthy));
   }
-  // Record telemetry labels (if any).
-  const envoy_config_core_v3_Metadata* metadata =
-      envoy_config_cluster_v3_Cluster_metadata(cluster);
-  if (metadata != nullptr) {
-    google_protobuf_Struct* telemetry_labels_struct;
-    if (envoy_config_core_v3_Metadata_filter_metadata_get(
-            metadata,
-            StdStringToUpbString(
-                absl::string_view("com.google.csm.telemetry_labels")),
-            &telemetry_labels_struct)) {
-      size_t iter = kUpb_Map_Begin;
-      const google_protobuf_Struct_FieldsEntry* fields_entry;
-      while ((fields_entry = google_protobuf_Struct_fields_next(
-                  telemetry_labels_struct, &iter)) != nullptr) {
-        // Adds any entry whose value is a string to telemetry_labels.
-        const google_protobuf_Value* value =
-            google_protobuf_Struct_FieldsEntry_value(fields_entry);
-        if (google_protobuf_Value_has_string_value(value)) {
-          if (UpbStringToAbsl(google_protobuf_Struct_FieldsEntry_key(
-                  fields_entry)) == "service_name") {
-            cds_update->service_telemetry_label = RefCountedStringValue(
-                UpbStringToAbsl(google_protobuf_Value_string_value(value)));
-          } else if (UpbStringToAbsl(google_protobuf_Struct_FieldsEntry_key(
-                         fields_entry)) == "service_namespace") {
-            cds_update->namespace_telemetry_label = RefCountedStringValue(
-                UpbStringToAbsl(google_protobuf_Value_string_value(value)));
-          }
-        }
-      }
-    }
+  // Parse metadata.
+  {
+    ValidationErrors::ScopedField field(&errors, ".metadata");
+    cds_update->metadata = ParseXdsMetadataMap(
+        context, envoy_config_cluster_v3_Cluster_metadata(cluster), &errors);
   }
   // Return result.
   if (!errors.ok()) {

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

@@ -30,7 +30,6 @@
 #include "upb/mem/arena.hpp"
 
 #include <grpc/support/json.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/util/json/json.h"

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

@@ -372,11 +372,9 @@ CommonTlsContext CommonTlsContextParse(
 }
 
 //
-// ExtractXdsExtension
+// ParseProtobufStructToJson()
 //
 
-namespace {
-
 absl::StatusOr<Json> ParseProtobufStructToJson(
     const XdsResourceType::DecodeContext& context,
     const google_protobuf_Struct* resource) {
@@ -405,7 +403,9 @@ absl::StatusOr<Json> ParseProtobufStructToJson(
   return std::move(*json);
 }
 
-}  // namespace
+//
+// ExtractXdsExtension()
+//
 
 absl::optional<XdsExtension> ExtractXdsExtension(
     const XdsResourceType::DecodeContext& context,

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

@@ -21,6 +21,7 @@
 #include "envoy/extensions/transport_sockets/tls/v3/tls.upb.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
+#include "google/protobuf/struct.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 
 #include "src/core/lib/gprpp/time.h"
@@ -39,12 +40,28 @@ inline bool ParseBoolValue(const google_protobuf_BoolValue* bool_value_proto,
   return google_protobuf_BoolValue_value(bool_value_proto);
 }
 
+inline absl::optional<uint64_t> ParseUInt64Value(
+    const google_protobuf_UInt64Value* proto) {
+  if (proto == nullptr) return absl::nullopt;
+  return google_protobuf_UInt64Value_value(proto);
+}
+
+inline absl::optional<uint32_t> ParseUInt32Value(
+    const google_protobuf_UInt32Value* proto) {
+  if (proto == nullptr) return absl::nullopt;
+  return google_protobuf_UInt32Value_value(proto);
+}
+
 CommonTlsContext CommonTlsContextParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_extensions_transport_sockets_tls_v3_CommonTlsContext*
         common_tls_context_proto,
     ValidationErrors* errors);
 
+absl::StatusOr<Json> ParseProtobufStructToJson(
+    const XdsResourceType::DecodeContext& context,
+    const google_protobuf_Struct* resource);
+
 absl::optional<XdsExtension> ExtractXdsExtension(
     const XdsResourceType::DecodeContext& context,
     const google_protobuf_Any* any, ValidationErrors* errors);

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

@@ -52,6 +52,7 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/util/string.h"
 #include "src/core/util/upb_utils.h"
+#include "src/core/xds/grpc/xds_common_types_parser.h"
 #include "src/core/xds/grpc/xds_health_status.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 
@@ -61,10 +62,10 @@ namespace grpc_core {
 
 namespace {
 
-// TODO(roth): Remove this once dualstack support is stable.
+// TODO(roth): Remove this after 1.67 is released.
 bool XdsDualstackEndpointsEnabled() {
   auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS");
-  if (!value.has_value()) return false;
+  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;
@@ -126,16 +127,15 @@ absl::optional<EndpointAddresses> EndpointAddressesParse(
   auto status = XdsHealthStatus::FromUpb(health_status);
   if (!status.has_value()) return absl::nullopt;
   // load_balancing_weight
-  uint32_t weight = 1;
+  uint32_t weight;
   {
     ValidationErrors::ScopedField field(errors, ".load_balancing_weight");
-    const google_protobuf_UInt32Value* load_balancing_weight =
-        envoy_config_endpoint_v3_LbEndpoint_load_balancing_weight(lb_endpoint);
-    if (load_balancing_weight != nullptr) {
-      weight = google_protobuf_UInt32Value_value(load_balancing_weight);
-      if (weight == 0) {
-        errors->AddError("must be greater than 0");
-      }
+    weight = ParseUInt32Value(
+                 envoy_config_endpoint_v3_LbEndpoint_load_balancing_weight(
+                     lb_endpoint))
+                 .value_or(1);
+    if (weight == 0) {
+      errors->AddError("must be greater than 0");
     }
   }
   // endpoint
@@ -207,11 +207,11 @@ absl::optional<ParsedLocality> LocalityParse(
   // load_balancing_weight
   // If LB weight is not specified or 0, it means this locality is assigned
   // no load.
-  const google_protobuf_UInt32Value* lb_weight =
-      envoy_config_endpoint_v3_LocalityLbEndpoints_load_balancing_weight(
-          locality_lb_endpoints);
   parsed_locality.locality.lb_weight =
-      lb_weight != nullptr ? google_protobuf_UInt32Value_value(lb_weight) : 0;
+      ParseUInt32Value(
+          envoy_config_endpoint_v3_LocalityLbEndpoints_load_balancing_weight(
+              locality_lb_endpoints))
+          .value_or(0);
   if (parsed_locality.locality.lb_weight == 0) return absl::nullopt;
   // locality
   const envoy_config_core_v3_Locality* locality =

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

@@ -87,6 +87,7 @@ void XdsHttpFaultFilter::PopulateSymtab(upb_DefPool* symtab) const {
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpFaultFilter::GenerateFilterConfig(
+    absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
@@ -195,12 +196,12 @@ XdsHttpFaultFilter::GenerateFilterConfig(
     }
   }
   // Section 3: Parse the maximum active faults
-  const auto* max_fault_wrapper =
+  auto max_fault_wrapper = ParseUInt32Value(
       envoy_extensions_filters_http_fault_v3_HTTPFault_max_active_faults(
-          http_fault);
-  if (max_fault_wrapper != nullptr) {
+          http_fault));
+  if (max_fault_wrapper.has_value()) {
     fault_injection_policy_json["maxFaults"] =
-        Json::FromNumber(google_protobuf_UInt32Value_value(max_fault_wrapper));
+        Json::FromNumber(*max_fault_wrapper);
   }
   return FilterConfig{ConfigProtoName(),
                       Json::FromObject(std::move(fault_injection_policy_json))};
@@ -208,11 +209,13 @@ XdsHttpFaultFilter::GenerateFilterConfig(
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpFaultFilter::GenerateFilterConfigOverride(
+    absl::string_view instance_name,
     const XdsResourceType::DecodeContext& context, 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(context, std::move(extension), errors);
+  return GenerateFilterConfig(instance_name, context, std::move(extension),
+                              errors);
 }
 
 void XdsHttpFaultFilter::AddFilter(InterceptionChainBuilder& builder) const {
@@ -229,7 +232,7 @@ ChannelArgs XdsHttpFaultFilter::ModifyChannelArgs(
 }
 
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
-XdsHttpFaultFilter::GenerateServiceConfig(
+XdsHttpFaultFilter::GenerateMethodConfig(
     const FilterConfig& hcm_filter_config,
     const FilterConfig* filter_config_override) const {
   Json policy_json = filter_config_override != nullptr
@@ -239,4 +242,10 @@ XdsHttpFaultFilter::GenerateServiceConfig(
   return ServiceConfigJsonEntry{"faultInjectionPolicy", JsonDump(policy_json)};
 }
 
+absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
+XdsHttpFaultFilter::GenerateServiceConfig(
+    const FilterConfig& /*hcm_filter_config*/) const {
+  return ServiceConfigJsonEntry{"", ""};
+}
+
 }  // namespace grpc_core

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

@@ -39,17 +39,21 @@ class XdsHttpFaultFilter final : public XdsHttpFilterImpl {
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
   absl::optional<FilterConfig> GenerateFilterConfig(
+      absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   absl::optional<FilterConfig> GenerateFilterConfigOverride(
+      absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   void AddFilter(InterceptionChainBuilder& builder) const override;
   const grpc_channel_filter* channel_filter() const override;
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
-  absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+  absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
       const FilterConfig& hcm_filter_config,
       const FilterConfig* filter_config_override) const override;
+  absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+      const FilterConfig& hcm_filter_config) const override;
   bool IsSupportedOnClients() const override { return true; }
   bool IsSupportedOnServers() const override { return false; }
 };

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

@@ -60,6 +60,7 @@ class XdsHttpFilterImpl {
     // The value of this field in the method config will be a JSON array,
     // which will be populated with the elements returned by each filter
     // instance.
+    // Entry will be skipped if this field is empty.
     std::string service_config_field_name;
     // The element to add to the JSON array.
     std::string element;
@@ -80,12 +81,14 @@ class XdsHttpFilterImpl {
   // Generates a Config from the xDS filter config proto.
   // Used for the top-level config in the HCM HTTP filter list.
   virtual absl::optional<FilterConfig> GenerateFilterConfig(
+      absl::string_view instance_name,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const = 0;
 
   // Generates a Config from the xDS filter config proto.
   // Used for the typed_per_filter_config override in VirtualHost and Route.
   virtual absl::optional<FilterConfig> GenerateFilterConfigOverride(
+      absl::string_view instance_name,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const = 0;
 
@@ -106,10 +109,17 @@ class XdsHttpFilterImpl {
   // The filter_config_override comes from the first of the ClusterWeight,
   // Route, or VirtualHost entries that it is found in, or null if
   // there is no override in any of those locations.
-  virtual absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+  virtual absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
       const FilterConfig& hcm_filter_config,
       const FilterConfig* filter_config_override) const = 0;
 
+  // Function to convert the Configs into a JSON string to be added to the
+  // top level of the service config.
+  // The hcm_filter_config comes from the HttpConnectionManager config.
+  // Currently used only on the client side.
+  virtual absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+      const FilterConfig& hcm_filter_config) const = 0;
+
   // Returns true if the filter is supported on clients; false otherwise
   virtual bool IsSupportedOnClients() const = 0;
 

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

@@ -25,13 +25,14 @@
 #include "envoy/extensions/filters/http/router/v3/router.upb.h"
 #include "envoy/extensions/filters/http/router/v3/router.upbdefs.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/util/json/json.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"
 #include "src/core/xds/grpc/xds_http_stateful_session_filter.h"
+#include "src/core/xds/grpc/xds_metadata_parser.h"
 
 namespace grpc_core {
 
@@ -53,6 +54,7 @@ void XdsHttpRouterFilter::PopulateSymtab(upb_DefPool* symtab) const {
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpRouterFilter::GenerateFilterConfig(
+    absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
@@ -72,6 +74,7 @@ XdsHttpRouterFilter::GenerateFilterConfig(
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpRouterFilter::GenerateFilterConfigOverride(
+    absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& /*context*/,
     XdsExtension /*extension*/, ValidationErrors* errors) const {
   errors->AddError("router filter does not support config override");
@@ -88,6 +91,9 @@ XdsHttpFilterRegistry::XdsHttpFilterRegistry(bool register_builtins) {
     RegisterFilter(std::make_unique<XdsHttpFaultFilter>());
     RegisterFilter(std::make_unique<XdsHttpRbacFilter>());
     RegisterFilter(std::make_unique<XdsHttpStatefulSessionFilter>());
+    if (XdsGcpAuthFilterEnabled()) {
+      RegisterFilter(std::make_unique<XdsHttpGcpAuthnFilter>());
+    }
   }
 }
 

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

@@ -45,19 +45,26 @@ class XdsHttpRouterFilter final : public XdsHttpFilterImpl {
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
   absl::optional<FilterConfig> GenerateFilterConfig(
+      absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   absl::optional<FilterConfig> GenerateFilterConfigOverride(
+      absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   void AddFilter(InterceptionChainBuilder& /*builder*/) const override {}
   const grpc_channel_filter* channel_filter() const override { return nullptr; }
-  absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+  absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
       const FilterConfig& /*hcm_filter_config*/,
       const FilterConfig* /*filter_config_override*/) const override {
     // This will never be called, since channel_filter() returns null.
     return absl::UnimplementedError("router filter should never be called");
   }
+  absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+      const FilterConfig& /*hcm_filter_config*/) const override {
+    // This will never be called, since channel_filter() returns null.
+    return absl::UnimplementedError("router filter should never be called");
+  }
   bool IsSupportedOnClients() const override { return true; }
   bool IsSupportedOnServers() const override { return true; }
   bool IsTerminalFilter() const override { return true; }