grpc 1.78.1 → 1.80.0

data/src/core/client_channel/config_selector.h

@@ -28,6 +28,7 @@
 #include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/filter/blackboard.h"
+#include "src/core/filter/filter_chain.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
@@ -61,15 +62,10 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
   }
 
   // The channel will call this when the resolver returns a new ConfigSelector
-  // to determine what set of dynamic filters will be configured.
-  virtual void AddFilters(InterceptionChainBuilder& /*builder*/,
-                          const Blackboard* /*old_blackboard*/,
-                          Blackboard* /*new_blackboard*/) {}
-  // TODO(roth): Remove this once the legacy filter stack goes away.
-  virtual std::vector<const grpc_channel_filter*> GetFilters(
-      const Blackboard* /*old_blackboard*/, Blackboard* /*new_blackboard*/) {
-    return {};
-  }
+  // to initialize the filter chains that the ConfigSelector may need.
+  virtual void BuildFilterChains(FilterChainBuilder& builder,
+                                 const Blackboard* old_blackboard,
+                                 Blackboard* new_blackboard) = 0;
 
   // Gets the configuration for the call and stores it in service config
   // call data.
@@ -78,7 +74,8 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
     Arena* arena;
     ClientChannelServiceConfigCallData* service_config_call_data;
   };
-  virtual absl::Status GetCallConfig(GetCallConfigArgs args) = 0;
+  virtual absl::StatusOr<RefCountedPtr<const FilterChain>> GetCallConfig(
+      GetCallConfigArgs args) = 0;
 
   static absl::string_view ChannelArgName() { return GRPC_ARG_CONFIG_SELECTOR; }
   static int ChannelArgsCompare(const ConfigSelector* a,
@@ -108,14 +105,21 @@ class DefaultConfigSelector final : public ConfigSelector {
     return kFactory.Create();
   }
 
-  absl::Status GetCallConfig(GetCallConfigArgs args) override {
+  void BuildFilterChains(FilterChainBuilder& builder,
+                         const Blackboard* /*old_blackboard*/,
+                         Blackboard* /*new_blackboard*/) override {
+    filter_chain_ = builder.Build();
+  }
+
+  absl::StatusOr<RefCountedPtr<const FilterChain>> GetCallConfig(
+      GetCallConfigArgs args) override {
     Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
     GRPC_CHECK_NE(path, nullptr);
     auto* parsed_method_configs =
         service_config_->GetMethodParsedConfigVector(path->c_slice());
     args.service_config_call_data->SetServiceConfig(service_config_,
                                                     parsed_method_configs);
-    return absl::OkStatus();
+    return filter_chain_;
   }
 
   // Only comparing the ConfigSelector itself, not the underlying
@@ -124,6 +128,7 @@ class DefaultConfigSelector final : public ConfigSelector {
 
  private:
   RefCountedPtr<ServiceConfig> service_config_;
+  absl::StatusOr<RefCountedPtr<FilterChain>> filter_chain_;
 };
 
 }  // namespace grpc_core

data/src/core/client_channel/dynamic_filters.cc

@@ -109,7 +109,8 @@ void DynamicFilters::Call::Destroy(void* arg, grpc_error_handle /*error*/) {
   DynamicFilters::Call* self = static_cast<DynamicFilters::Call*>(arg);
   // Keep some members before destroying the subchannel call.
   grpc_closure* after_call_stack_destroy = self->after_call_stack_destroy_;
-  RefCountedPtr<DynamicFilters> channel_stack = std::move(self->channel_stack_);
+  RefCountedPtr<const DynamicFilters> channel_stack =
+      std::move(self->channel_stack_);
   // Destroy the subchannel call.
   self->~Call();
   // Destroy the call stack. This should be after destroying the call, because
@@ -136,12 +137,12 @@ void DynamicFilters::Call::IncrementRefCount(const DebugLocation& /*location*/,
 namespace {
 
 absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
-    const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters,
+    const ChannelArgs& args, std::vector<FilterAndConfig> filters,
     const Blackboard* blackboard) {
   ChannelStackBuilderImpl builder("DynamicFilters", GRPC_CLIENT_DYNAMIC, args);
   builder.SetBlackboard(blackboard);
-  for (auto filter : filters) {
-    builder.AppendFilter(filter);
+  for (auto& [filter, config] : filters) {
+    builder.AppendFilter(filter, std::move(config));
   }
   return builder.Build();
 }
@@ -149,7 +150,7 @@ absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
 }  // namespace
 
 RefCountedPtr<DynamicFilters> DynamicFilters::Create(
-    const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters,
+    const ChannelArgs& args, std::vector<FilterAndConfig> filters,
     const Blackboard* blackboard) {
   // Attempt to create channel stack from requested filters.
   auto p = CreateChannelStack(args, std::move(filters), blackboard);
@@ -158,13 +159,13 @@ RefCountedPtr<DynamicFilters> DynamicFilters::Create(
     // Create with lame filter instead.
     auto error = p.status();
     p = CreateChannelStack(args.Set(MakeLameClientErrorArg(&error)),
-                           {&LameClientFilter::kFilter}, nullptr);
+                           {{&LameClientFilter::kFilter, nullptr}}, nullptr);
   }
   return MakeRefCounted<DynamicFilters>(std::move(p.value()));
 }
 
 RefCountedPtr<DynamicFilters::Call> DynamicFilters::CreateCall(
-    DynamicFilters::Call::Args args, grpc_error_handle* error) {
+    DynamicFilters::Call::Args args, grpc_error_handle* error) const {
   size_t allocation_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Call)) +
                            channel_stack_->call_stack_size;
   Call* call = static_cast<Call*>(args.arena->Alloc(allocation_size));

data/src/core/client_channel/dynamic_filters.h

@@ -24,6 +24,7 @@
 #include <vector>
 
 #include "src/core/filter/blackboard.h"
+#include "src/core/filter/filter_chain.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -41,13 +42,13 @@
 
 namespace grpc_core {
 
-class DynamicFilters final : public RefCounted<DynamicFilters> {
+class DynamicFilters final : public FilterChain {
  public:
   // Implements the interface of RefCounted<>.
   class Call {
    public:
     struct Args {
-      RefCountedPtr<DynamicFilters> channel_stack;
+      RefCountedPtr<const DynamicFilters> channel_stack;
       grpc_polling_entity* pollent;
       gpr_cycle_counter start_time;
       Timestamp deadline;
@@ -84,18 +85,19 @@ class DynamicFilters final : public RefCounted<DynamicFilters> {
 
     static void Destroy(void* arg, grpc_error_handle error);
 
-    RefCountedPtr<DynamicFilters> channel_stack_;
+    RefCountedPtr<const DynamicFilters> channel_stack_;
     grpc_closure* after_call_stack_destroy_ = nullptr;
   };
 
   static RefCountedPtr<DynamicFilters> Create(
-      const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters,
+      const ChannelArgs& args, std::vector<FilterAndConfig> filters,
       const Blackboard* blackboard);
 
   explicit DynamicFilters(RefCountedPtr<grpc_channel_stack> channel_stack)
       : channel_stack_(std::move(channel_stack)) {}
 
-  RefCountedPtr<Call> CreateCall(Call::Args args, grpc_error_handle* error);
+  RefCountedPtr<Call> CreateCall(Call::Args args,
+                                 grpc_error_handle* error) const;
 
   grpc_channel_stack* channel_stack() const { return channel_stack_.get(); }
 

data/src/core/client_channel/retry_filter.cc

@@ -127,7 +127,7 @@ const RetryMethodConfig* RetryFilter::GetRetryPolicy(Arena* arena) {
       svc_cfg_call_data->GetMethodParsedConfig(service_config_parser_index_));
 }
 
-const grpc_channel_filter RetryFilter::kVtable = {
+const grpc_channel_filter RetryFilter::kFilterVtable = {
     RetryFilter::LegacyCallData::StartTransportStreamOpBatch,
     RetryFilter::StartTransportOp,
     sizeof(RetryFilter::LegacyCallData),

data/src/core/client_channel/retry_filter.h

@@ -43,7 +43,7 @@ namespace grpc_core {
 
 class RetryFilter final {
  public:
-  static const grpc_channel_filter kVtable;
+  static const grpc_channel_filter kFilterVtable;
 
   static void UpdateBlackboard(const ServiceConfig& service_config,
                                const Blackboard* old_blackboard,
@@ -89,7 +89,7 @@ class RetryFilter final {
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
     GRPC_CHECK(args->is_last);
-    GRPC_CHECK(elem->filter == &kVtable);
+    GRPC_CHECK(elem->filter == &kFilterVtable);
     new (elem->channel_data) RetryFilter(*args);
     return absl::OkStatus();
   }