grpc 1.78.0 → 1.80.0.pre1

data/src/core/ext/filters/gcp_authentication/gcp_authentication_filter.cc

@@ -36,6 +36,20 @@
 
 namespace grpc_core {
 
+//
+// GcpAuthenticationFilter::Config
+//
+
+bool GcpAuthenticationFilter::Config::Equals(const FilterConfig& other) const {
+  const auto& o = DownCast<const Config&>(other);
+  return instance_name == o.instance_name && cache_size == o.cache_size;
+}
+
+std::string GcpAuthenticationFilter::Config::ToString() const {
+  return absl::StrCat("{instance_name=\"", instance_name,
+                      "\", cache_size=", cache_size, "}");
+}
+
 //
 // GcpAuthenticationFilter::Call
 //
@@ -83,7 +97,7 @@ absl::Status GcpAuthenticationFilter::Call::OnClientInitialMetadata(
   }
   auto& metadata_map = it->second->cluster->metadata;
   const XdsMetadataValue* metadata_value =
-      metadata_map.Find(filter->filter_config_->filter_instance_name);
+      metadata_map.Find(filter->filter_config_->instance_name);
   // If no audience in the cluster, then no need to add call creds.
   if (metadata_value == nullptr) return absl::OkStatus();
   // If the entry is present but the wrong type, fail the RPC.
@@ -137,57 +151,72 @@ GcpAuthenticationFilter::CallCredentialsCache::Get(
 // GcpAuthenticationFilter
 //
 
-const grpc_channel_filter GcpAuthenticationFilter::kFilter =
+const grpc_channel_filter GcpAuthenticationFilter::kFilterVtable =
     MakePromiseBasedFilter<GcpAuthenticationFilter, FilterEndpoint::kClient,
                            0>();
 
 absl::StatusOr<std::unique_ptr<GcpAuthenticationFilter>>
 GcpAuthenticationFilter::Create(const ChannelArgs& args,
                                 ChannelFilter::Args filter_args) {
-  // Get filter config.
-  auto service_config = args.GetObjectRef<ServiceConfig>();
-  if (service_config == nullptr) {
-    return absl::InvalidArgumentError(
-        "gcp_auth: no service config in channel args");
-  }
-  auto* config = static_cast<const GcpAuthenticationParsedConfig*>(
-      service_config->GetGlobalParsedConfig(
-          GcpAuthenticationServiceConfigParser::ParserIndex()));
-  if (config == nullptr) {
-    return absl::InvalidArgumentError("gcp_auth: parsed config not found");
-  }
-  auto* filter_config = config->GetConfig(filter_args.instance_id());
-  if (filter_config == nullptr) {
-    return absl::InvalidArgumentError(
-        "gcp_auth: filter instance ID not found in filter config");
+  RefCountedPtr<const Config> config;
+  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
+    // Construct new-style filter config from legacy service config.
+    auto service_config = args.GetObjectRef<ServiceConfig>();
+    if (service_config == nullptr) {
+      return absl::InvalidArgumentError(
+          "gcp_auth: no service config in channel args");
+    }
+    auto* global_config = static_cast<const GcpAuthenticationParsedConfig*>(
+        service_config->GetGlobalParsedConfig(
+            GcpAuthenticationServiceConfigParser::ParserIndex()));
+    if (global_config == nullptr) {
+      return absl::InvalidArgumentError("gcp_auth: parsed config not found");
+    }
+    auto* filter_config = global_config->GetConfig(filter_args.instance_id());
+    if (filter_config == nullptr) {
+      return absl::InvalidArgumentError(
+          "gcp_auth: filter instance ID not found in filter config");
+    }
+    auto new_config = MakeRefCounted<Config>();
+    new_config->instance_name = filter_config->filter_instance_name;
+    new_config->cache_size = filter_config->cache_size;
+    config = std::move(new_config);
+  } else {
+    // Get filter config.
+    if (filter_args.config() == nullptr) {
+      return absl::InternalError("gcp_auth: filter config not set");
+    }
+    if (filter_args.config()->type() != Config::Type()) {
+      return absl::InternalError(
+          absl::StrCat("wrong config type passed to GCP authn filter: ",
+                       filter_args.config()->type().name()));
+    }
+    config = filter_args.config().TakeAsSubclass<const Config>();
   }
   // Get XdsConfig so that we can look up CDS resources.
   auto xds_config = args.GetObjectRef<XdsConfig>();
   if (xds_config == nullptr) {
-    return absl::InvalidArgumentError(
+    return absl::InternalError(
         "gcp_auth: xds config not found in channel args");
   }
   // Get cache from blackboard.  This must have been populated
   // previously by the XdsConfigSelector.
-  auto cache = filter_args.GetState<CallCredentialsCache>(
-      filter_config->filter_instance_name);
+  auto cache =
+      filter_args.GetState<CallCredentialsCache>(config->instance_name);
   if (cache == nullptr) {
-    return absl::InvalidArgumentError(
+    return absl::InternalError(
         "gcp_auth: cache object not found in filter state");
   }
   // Instantiate filter.
-  return std::unique_ptr<GcpAuthenticationFilter>(
-      new GcpAuthenticationFilter(std::move(service_config), filter_config,
-                                  std::move(xds_config), std::move(cache)));
+  return std::unique_ptr<GcpAuthenticationFilter>(new GcpAuthenticationFilter(
+      std::move(config), std::move(xds_config), std::move(cache)));
 }
 
 GcpAuthenticationFilter::GcpAuthenticationFilter(
-    RefCountedPtr<ServiceConfig> service_config,
-    const GcpAuthenticationParsedConfig::Config* filter_config,
+    RefCountedPtr<const Config> filter_config,
     RefCountedPtr<const XdsConfig> xds_config,
     RefCountedPtr<CallCredentialsCache> cache)
-    : service_config_(std::move(service_config)),
-      filter_config_(filter_config),
+    : filter_config_(std::move(filter_config)),
       xds_config_(std::move(xds_config)),
       cache_(std::move(cache)) {}
 

data/src/core/ext/filters/gcp_authentication/gcp_authentication_filter.h

@@ -42,6 +42,19 @@ namespace grpc_core {
 class GcpAuthenticationFilter
     : public ImplementChannelFilter<GcpAuthenticationFilter> {
  public:
+  struct Config : public FilterConfig {
+    static UniqueTypeName Type() {
+      return GRPC_UNIQUE_TYPE_NAME_HERE("gcp_authentication_filter_config");
+    }
+    UniqueTypeName type() const override { return Type(); }
+
+    bool Equals(const FilterConfig& other) const override;
+    std::string ToString() const override;
+
+    std::string instance_name;
+    uint64_t cache_size = 10;
+  };
+
   class CallCredentialsCache : public Blackboard::Entry {
    public:
     explicit CallCredentialsCache(size_t max_size) : cache_(max_size) {}
@@ -58,7 +71,7 @@ class GcpAuthenticationFilter
         cache_ ABSL_GUARDED_BY(&mu_);
   };
 
-  static const grpc_channel_filter kFilter;
+  static const grpc_channel_filter kFilterVtable;
 
   static absl::string_view TypeName() { return "gcp_authentication_filter"; }
 
@@ -81,16 +94,11 @@ class GcpAuthenticationFilter
   };
 
  private:
-  GcpAuthenticationFilter(
-      RefCountedPtr<ServiceConfig> service_config,
-      const GcpAuthenticationParsedConfig::Config* filter_config,
-      RefCountedPtr<const XdsConfig> xds_config,
-      RefCountedPtr<CallCredentialsCache> cache);
-
-  // TODO(roth): Consider having the channel stack hold this ref so that
-  // individual filters don't need to.
-  const RefCountedPtr<ServiceConfig> service_config_;
-  const GcpAuthenticationParsedConfig::Config* filter_config_;
+  GcpAuthenticationFilter(RefCountedPtr<const Config> filter_config,
+                          RefCountedPtr<const XdsConfig> xds_config,
+                          RefCountedPtr<CallCredentialsCache> cache);
+
+  const RefCountedPtr<const Config> filter_config_;
   const RefCountedPtr<const XdsConfig> xds_config_;
   const RefCountedPtr<CallCredentialsCache> cache_;
 };

data/src/core/ext/filters/stateful_session/stateful_session_filter.cc

@@ -59,20 +59,50 @@ UniqueTypeName XdsOverrideHostAttribute::TypeName() {
   return kFactory.Create();
 }
 
-const grpc_channel_filter StatefulSessionFilter::kFilter =
+bool StatefulSessionFilter::Config::Equals(const FilterConfig& other) const {
+  const auto& o = DownCast<const Config&>(other);
+  return cookie_name == o.cookie_name && path == o.path && ttl == o.ttl;
+}
+
+std::string StatefulSessionFilter::Config::ToString() const {
+  std::vector<std::string> parts;
+  if (!cookie_name.empty()) {
+    parts.push_back(absl::StrCat("cookie_name=\"", cookie_name, "\""));
+  }
+  if (!path.empty()) {
+    parts.push_back(absl::StrCat("path=\"", path, "\""));
+  }
+  if (ttl != Duration::Zero()) {
+    parts.push_back(absl::StrCat("ttl=", ttl.ToString()));
+  }
+  return absl::StrCat("{", absl::StrJoin(parts, ", "), "}");
+}
+
+const grpc_channel_filter StatefulSessionFilter::kFilterVtable =
     MakePromiseBasedFilter<StatefulSessionFilter, FilterEndpoint::kClient,
                            kFilterExaminesServerInitialMetadata>();
 
 absl::StatusOr<std::unique_ptr<StatefulSessionFilter>>
 StatefulSessionFilter::Create(const ChannelArgs&,
                               ChannelFilter::Args filter_args) {
+  if (IsXdsChannelFilterChainPerRouteEnabled()) {
+    if (filter_args.config() == nullptr) {
+      return absl::InternalError("no config in stateful session filter");
+    }
+    if (filter_args.config()->type() != Config::Type()) {
+      return absl::InternalError(
+          absl::StrCat("wrong config type in stateful session filter: ",
+                       filter_args.config()->type().name()));
+    }
+  }
   return std::make_unique<StatefulSessionFilter>(filter_args);
 }
 
 StatefulSessionFilter::StatefulSessionFilter(ChannelFilter::Args filter_args)
     : index_(filter_args.instance_id()),
       service_config_parser_index_(
-          StatefulSessionServiceConfigParser::ParserIndex()) {}
+          StatefulSessionServiceConfigParser::ParserIndex()),
+      config_(filter_args.config().TakeAsSubclass<const Config>()) {}
 
 namespace {
 
@@ -91,9 +121,11 @@ absl::string_view AllocateStringOnArena(
 }
 
 // Adds the set-cookie header to the server initial metadata if needed.
+// TODO(roth): Un-templatize this when we remove the
+// xds_channel_filter_chain_per_route experiment.
+template <typename T>
 void MaybeUpdateServerInitialMetadata(
-    const StatefulSessionMethodParsedConfig::CookieConfig* cookie_config,
-    bool cluster_changed, absl::string_view actual_cluster,
+    const T& config, bool cluster_changed, absl::string_view actual_cluster,
     absl::string_view cookie_address_list,
     XdsOverrideHostAttribute* override_host_attribute,
     ServerMetadata& server_initial_metadata) {
@@ -106,13 +138,13 @@ void MaybeUpdateServerInitialMetadata(
   std::string new_value = absl::StrCat(
       override_host_attribute->actual_address_list(), ";", actual_cluster);
   std::vector<std::string> parts = {absl::StrCat(
-      *cookie_config->name, "=", absl::Base64Escape(new_value), "; HttpOnly")};
-  if (!cookie_config->path.empty()) {
-    parts.emplace_back(absl::StrCat("Path=", cookie_config->path));
+      config.cookie_name, "=", absl::Base64Escape(new_value), "; HttpOnly")};
+  if (!config.path.empty()) {
+    parts.emplace_back(absl::StrCat("Path=", config.path));
   }
-  if (cookie_config->ttl > Duration::Zero()) {
+  if (config.ttl > Duration::Zero()) {
     parts.emplace_back(
-        absl::StrCat("Max-Age=", cookie_config->ttl.as_timespec().tv_sec));
+        absl::StrCat("Max-Age=", config.ttl.as_timespec().tv_sec));
   }
   server_initial_metadata.Append(
       "set-cookie", Slice::FromCopiedString(absl::StrJoin(parts, "; ")),
@@ -214,21 +246,30 @@ bool IsConfiguredPath(absl::string_view configured_path,
 void StatefulSessionFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, StatefulSessionFilter* filter) {
   GRPC_LATENT_SEE_SCOPE("StatefulSessionFilter::Call::OnClientInitialMetadata");
-  // Get config.
-  auto* service_config_call_data = GetContext<ServiceConfigCallData>();
-  GRPC_CHECK_NE(service_config_call_data, nullptr);
-  auto* method_params = static_cast<StatefulSessionMethodParsedConfig*>(
-      service_config_call_data->GetMethodParsedConfig(
-          filter->service_config_parser_index_));
-  GRPC_CHECK_NE(method_params, nullptr);
-  cookie_config_ = method_params->GetConfig(filter->index_);
-  GRPC_CHECK_NE(cookie_config_, nullptr);
-  if (!cookie_config_->name.has_value() ||
-      !IsConfiguredPath(cookie_config_->path, md)) {
+  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
+    // Get config.
+    auto* service_config_call_data = GetContext<ServiceConfigCallData>();
+    GRPC_CHECK_NE(service_config_call_data, nullptr);
+    auto* method_params = static_cast<StatefulSessionMethodParsedConfig*>(
+        service_config_call_data->GetMethodParsedConfig(
+            filter->service_config_parser_index_));
+    GRPC_CHECK_NE(method_params, nullptr);
+    cookie_config_ = method_params->GetConfig(filter->index_);
+    GRPC_CHECK_NE(cookie_config_, nullptr);
+    OnClientInitialMetadataImpl(md, *cookie_config_);
+    return;
+  }
+  OnClientInitialMetadataImpl(md, *filter->config_);
+}
+
+template <typename T>
+void StatefulSessionFilter::Call::OnClientInitialMetadataImpl(
+    ClientMetadata& md, const T& config) {
+  if (config.cookie_name.empty() || !IsConfiguredPath(config.path, md)) {
     return;
   }
   // Base64-decode cookie value.
-  std::string cookie_value = GetCookieValue(md, *cookie_config_->name);
+  std::string cookie_value = GetCookieValue(md, config.cookie_name);
   // Cookie format is "host;cluster"
   std::pair<absl::string_view, absl::string_view> host_cluster =
       absl::StrSplit(cookie_value, absl::MaxSplits(';', 1));
@@ -237,6 +278,8 @@ void StatefulSessionFilter::Call::OnClientInitialMetadata(
     cookie_address_list_ = AllocateStringOnArena(host_cluster.first);
   }
   // Set override host attribute.
+  auto* service_config_call_data = GetContext<ServiceConfigCallData>();
+  GRPC_CHECK_NE(service_config_call_data, nullptr);
   override_host_attribute_ =
       GetContext<Arena>()->ManagedNew<XdsOverrideHostAttribute>(
           cookie_address_list_);
@@ -252,16 +295,24 @@ void StatefulSessionFilter::Call::OnClientInitialMetadata(
   perform_filtering_ = true;
 }
 
-void StatefulSessionFilter::Call::OnServerInitialMetadata(ServerMetadata& md) {
+void StatefulSessionFilter::Call::OnServerInitialMetadata(
+    ServerMetadata& md, StatefulSessionFilter* filter) {
   GRPC_LATENT_SEE_SCOPE("StatefulSessionFilter::Call::OnServerInitialMetadata");
   if (!perform_filtering_) return;
   // Add cookie to server initial metadata if needed.
-  MaybeUpdateServerInitialMetadata(cookie_config_, cluster_changed_,
+  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
+    MaybeUpdateServerInitialMetadata(*cookie_config_, cluster_changed_,
+                                     cluster_name_, cookie_address_list_,
+                                     override_host_attribute_, md);
+    return;
+  }
+  MaybeUpdateServerInitialMetadata(*filter->config_, cluster_changed_,
                                    cluster_name_, cookie_address_list_,
                                    override_host_attribute_, md);
 }
 
-void StatefulSessionFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
+void StatefulSessionFilter::Call::OnServerTrailingMetadata(
+    ServerMetadata& md, StatefulSessionFilter* filter) {
   GRPC_LATENT_SEE_SCOPE(
       "StatefulSessionFilter::Call::OnServerTrailingMetadata");
   if (!perform_filtering_) return;
@@ -269,7 +320,13 @@ void StatefulSessionFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
   // cookie to the trailing metadata instead of the
   // initial metadata.
   if (md.get(GrpcTrailersOnly()).value_or(false)) {
-    MaybeUpdateServerInitialMetadata(cookie_config_, cluster_changed_,
+    if (!IsXdsChannelFilterChainPerRouteEnabled()) {
+      MaybeUpdateServerInitialMetadata(*cookie_config_, cluster_changed_,
+                                       cluster_name_, cookie_address_list_,
+                                       override_host_attribute_, md);
+      return;
+    }
+    MaybeUpdateServerInitialMetadata(*filter->config_, cluster_changed_,
                                      cluster_name_, cookie_address_list_,
                                      override_host_attribute_, md);
   }

data/src/core/ext/filters/stateful_session/stateful_session_filter.h

@@ -70,7 +70,21 @@ class XdsOverrideHostAttribute
 class StatefulSessionFilter
     : public ImplementChannelFilter<StatefulSessionFilter> {
  public:
-  static const grpc_channel_filter kFilter;
+  struct Config : public FilterConfig {
+    static UniqueTypeName Type() {
+      return GRPC_UNIQUE_TYPE_NAME_HERE("stateful_session_filter_config");
+    }
+    UniqueTypeName type() const override { return Type(); }
+
+    bool Equals(const FilterConfig& other) const override;
+    std::string ToString() const override;
+
+    std::string cookie_name;
+    std::string path;
+    Duration ttl;
+  };
+
+  static const grpc_channel_filter kFilterVtable;
 
   static absl::string_view TypeName() { return "stateful_session_filter"; }
 
@@ -83,8 +97,10 @@ class StatefulSessionFilter
    public:
     void OnClientInitialMetadata(ClientMetadata& md,
                                  StatefulSessionFilter* filter);
-    void OnServerInitialMetadata(ServerMetadata& md);
-    void OnServerTrailingMetadata(ServerMetadata& md);
+    void OnServerInitialMetadata(ServerMetadata& md,
+                                 StatefulSessionFilter* filter);
+    void OnServerTrailingMetadata(ServerMetadata& md,
+                                  StatefulSessionFilter* filter);
     static inline const NoInterceptor OnClientToServerMessage;
     static inline const NoInterceptor OnClientToServerHalfClose;
     static inline const NoInterceptor OnServerToClientMessage;
@@ -102,7 +118,12 @@ class StatefulSessionFilter
     }
 
    private:
+    // TODO(roth): Remove these when removing the
+    // xds_channel_filter_chain_per_route experiment.
+    template <typename T>
+    void OnClientInitialMetadataImpl(ClientMetadata& md, const T& config);
     const StatefulSessionMethodParsedConfig::CookieConfig* cookie_config_;
+
     XdsOverrideHostAttribute* override_host_attribute_;
     absl::string_view cluster_name_;
     absl::string_view cookie_address_list_;
@@ -111,10 +132,14 @@ class StatefulSessionFilter
   };
 
  private:
+  // TODO(roth): Remove these fields when removing the
+  // xds_channel_filter_chain_per_route experiment.
   // The relative index of instances of the same filter.
   const size_t index_;
   // Index of the service config parser.
   const size_t service_config_parser_index_;
+
+  const RefCountedPtr<const Config> config_;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/stateful_session/stateful_session_service_config_parser.cc

@@ -27,18 +27,20 @@ namespace grpc_core {
 
 const JsonLoaderInterface*
 StatefulSessionMethodParsedConfig::CookieConfig::JsonLoader(const JsonArgs&) {
-  static const auto* loader = JsonObjectLoader<CookieConfig>()
-                                  .OptionalField("name", &CookieConfig::name)
-                                  .OptionalField("path", &CookieConfig::path)
-                                  .OptionalField("ttl", &CookieConfig::ttl)
-                                  .Finish();
+  static const auto* loader =
+      JsonObjectLoader<CookieConfig>()
+          .OptionalField("name", &CookieConfig::cookie_name)
+          .OptionalField("path", &CookieConfig::path)
+          .OptionalField("ttl", &CookieConfig::ttl)
+          .Finish();
   return loader;
 }
 
 void StatefulSessionMethodParsedConfig::CookieConfig::JsonPostLoad(
-    const Json&, const JsonArgs&, ValidationErrors* errors) {
+    const Json& json, const JsonArgs&, ValidationErrors* errors) {
   // Validate that cookie_name is non-empty.
-  if (name.has_value() && name->empty()) {
+  if (json.object().find("name") != json.object().end() &&
+      cookie_name.empty()) {
     ValidationErrors::ScopedField field(errors, ".name");
     errors->AddError("must be non-empty");
   }

data/src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h

@@ -45,7 +45,7 @@ class StatefulSessionMethodParsedConfig
     : public ServiceConfigParser::ParsedConfig {
  public:
   struct CookieConfig {
-    std::optional<std::string> name;  // Will be unset if disabled.
+    std::string cookie_name;  // Will be empty if disabled.
     std::string path;
     Duration ttl;
 

data/src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h

@@ -19,7 +19,6 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CALL_TRACER_WRAPPER_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CALL_TRACER_WRAPPER_H
 
-#include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"
 
 struct grpc_chttp2_stream;
@@ -43,7 +42,14 @@ class Chttp2CallTracerWrapper final : public CallTracerInterface {
   // Everything else is a no-op.
   void RecordSendInitialMetadata(
       grpc_metadata_batch* /*send_initial_metadata*/) override {}
+  void MutateSendInitialMetadata(
+      grpc_metadata_batch* /*send_initial_metadata*/) override {}
   void RecordSendTrailingMetadata(
+      grpc_metadata_batch* send_trailing_metadata) override {
+    GRPC_CHECK(!IsCallTracerSendTrailingMetadataIsAnAnnotationEnabled());
+    MutateSendTrailingMetadata(send_trailing_metadata);
+  }
+  void MutateSendTrailingMetadata(
       grpc_metadata_batch* /*send_trailing_metadata*/) override {}
   void RecordSendMessage(const Message& /*send_message*/) override {}
   void RecordSendCompressedMessage(