grpc 1.65.2 → 1.66.0.pre3

data/src/core/lib/surface/channel_init.h

@@ -23,6 +23,7 @@
 
 #include <initializer_list>
 #include <memory>
+#include <ostream>
 #include <utility>
 #include <vector>
 
@@ -36,6 +37,7 @@
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/call_filters.h"
 #include "src/core/lib/transport/interception_chain.h"
@@ -61,9 +63,56 @@ namespace grpc_core {
 // TODO(ctiller): remove this. When we define a FilterFactory type, that type
 // can be specified with the right constraints to be depended upon by this code,
 // and that type can export a `string_view Name()` method.
-extern const char* (*NameFromChannelFilter)(const grpc_channel_filter*);
+extern UniqueTypeName (*NameFromChannelFilter)(const grpc_channel_filter*);
 
 class ChannelInit {
+ private:
+  // Version constraints: filters can be registered against a specific version
+  // of the stack (V2 || V3), or registered for any stack.
+  enum class Version : uint8_t {
+    kAny,
+    kV2,
+    kV3,
+  };
+  static const char* VersionToString(Version version) {
+    switch (version) {
+      case Version::kAny:
+        return "Any";
+      case Version::kV2:
+        return "V2";
+      case Version::kV3:
+        return "V3";
+    }
+    return "Unknown";
+  }
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, Version version) {
+    sink.Append(VersionToString(version));
+  }
+  friend std::ostream& operator<<(std::ostream& out, Version version) {
+    return out << VersionToString(version);
+  }
+  static bool SkipV3(Version version) {
+    switch (version) {
+      case Version::kAny:
+      case Version::kV3:
+        return false;
+      case Version::kV2:
+        return true;
+    }
+    GPR_UNREACHABLE_CODE(return false);
+  }
+  static bool SkipV2(Version version) {
+    switch (version) {
+      case Version::kAny:
+      case Version::kV2:
+        return false;
+      case Version::kV3:
+        return true;
+    }
+    GPR_UNREACHABLE_CODE(return false);
+  }
+
  public:
   // Predicate for if a filter registration applies
   using InclusionPredicate = absl::AnyInvocable<bool(const ChannelArgs&) const>;
@@ -79,15 +128,61 @@ class ChannelInit {
     kXdsChannelStackModifier,
     kCount
   };
+  static const char* PostProcessorSlotName(PostProcessorSlot slot) {
+    switch (slot) {
+      case PostProcessorSlot::kAuthSubstitution:
+        return "AuthSubstitution";
+      case PostProcessorSlot::kXdsChannelStackModifier:
+        return "XdsChannelStackModifier";
+      case PostProcessorSlot::kCount:
+        return "---count---";
+    }
+    return "Unknown";
+  }
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, PostProcessorSlot slot) {
+    sink.Append(PostProcessorSlotName(slot));
+  }
+  // Ordering priorities.
+  // Most filters should use the kDefault priority.
+  // Filters that need to appear before the default priority should use kTop,
+  // filters that need to appear later should use the kBottom priority.
+  // Explicit before/after ordering between filters dominates: eg, if a filter
+  // with kBottom priority is marked as *BEFORE* a kTop filter, then the first
+  // filter will appear before the second.
+  // It is an error to have two filters with kTop (or two with kBottom)
+  // available at the same time. If this occurs, the filters should be
+  // explicitly marked with a before/after relationship.
+  enum class Ordering : uint8_t { kTop, kDefault, kBottom };
+  static const char* OrderingToString(Ordering ordering) {
+    switch (ordering) {
+      case Ordering::kTop:
+        return "Top";
+      case Ordering::kDefault:
+        return "Default";
+      case Ordering::kBottom:
+        return "Bottom";
+    }
+    return "Unknown";
+  }
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, Ordering ordering) {
+    sink.Append(OrderingToString(ordering));
+  };
+  friend std::ostream& operator<<(std::ostream& out, Ordering ordering) {
+    return out << OrderingToString(ordering);
+  }
 
   class FilterRegistration {
    public:
     // TODO(ctiller): Remove grpc_channel_filter* arg when that can be
     // deprecated (once filter stack is removed).
-    explicit FilterRegistration(const grpc_channel_filter* filter,
+    explicit FilterRegistration(UniqueTypeName name,
+                                const grpc_channel_filter* filter,
                                 FilterAdder filter_adder,
                                 SourceLocation registration_source)
-        : filter_(filter),
+        : name_(name),
+          filter_(filter),
           filter_adder_(filter_adder),
           registration_source_(registration_source) {}
     FilterRegistration(const FilterRegistration&) = delete;
@@ -98,14 +193,14 @@ class ChannelInit {
     // the same channel stack type as this registration.
     template <typename Filter>
     FilterRegistration& After() {
-      return After({&Filter::kFilter});
+      return After({UniqueTypeNameFor<Filter>()});
     }
     // Ensure that this filter is placed *before* the filters listed here.
     // By Build() time all filters listed here must also be registered against
     // the same channel stack type as this registration.
     template <typename Filter>
     FilterRegistration& Before() {
-      return Before({&Filter::kFilter});
+      return Before({UniqueTypeNameFor<Filter>()});
     }
 
     // Ensure that this filter is placed *after* the filters listed here.
@@ -113,15 +208,13 @@ class ChannelInit {
     // the same channel stack type as this registration.
     // TODO(ctiller): remove in favor of the version that does not mention
     // grpc_channel_filter
-    FilterRegistration& After(
-        std::initializer_list<const grpc_channel_filter*> filters);
+    FilterRegistration& After(std::initializer_list<UniqueTypeName> filters);
     // Ensure that this filter is placed *before* the filters listed here.
     // By Build() time all filters listed here must also be registered against
     // the same channel stack type as this registration.
     // TODO(ctiller): remove in favor of the version that does not mention
     // grpc_channel_filter
-    FilterRegistration& Before(
-        std::initializer_list<const grpc_channel_filter*> filters);
+    FilterRegistration& Before(std::initializer_list<UniqueTypeName> filters);
     // Add a predicate for this filters inclusion.
     // If the predicate returns true the filter will be included in the stack.
     // Predicates do not affect the ordering of the filter stack: we first
@@ -156,20 +249,42 @@ class ChannelInit {
     // stack.
     FilterRegistration& ExcludeFromMinimalStack();
     FilterRegistration& SkipV3() {
-      skip_v3_ = true;
+      CHECK_EQ(version_, Version::kAny);
+      version_ = Version::kV2;
+      return *this;
+    }
+    FilterRegistration& SkipV2() {
+      CHECK_EQ(version_, Version::kAny);
+      version_ = Version::kV3;
+      return *this;
+    }
+    // Request this filter be placed as high as possible in the stack (given
+    // before/after constraints).
+    FilterRegistration& FloatToTop() {
+      CHECK_EQ(ordering_, Ordering::kDefault);
+      ordering_ = Ordering::kTop;
+      return *this;
+    }
+    // Request this filter be placed as low as possible in the stack (given
+    // before/after constraints).
+    FilterRegistration& SinkToBottom() {
+      CHECK_EQ(ordering_, Ordering::kDefault);
+      ordering_ = Ordering::kBottom;
       return *this;
     }
 
    private:
     friend class ChannelInit;
+    const UniqueTypeName name_;
     const grpc_channel_filter* const filter_;
     const FilterAdder filter_adder_;
-    std::vector<const grpc_channel_filter*> after_;
-    std::vector<const grpc_channel_filter*> before_;
+    std::vector<UniqueTypeName> after_;
+    std::vector<UniqueTypeName> before_;
     std::vector<InclusionPredicate> predicates_;
     bool terminal_ = false;
     bool before_all_ = false;
-    bool skip_v3_ = false;
+    Version version_ = Version::kAny;
+    Ordering ordering_ = Ordering::kDefault;
     SourceLocation registration_source_;
   };
 
@@ -182,14 +297,22 @@ class ChannelInit {
     // TODO(ctiller): remove in favor of the version that does not mention
     // grpc_channel_filter
     FilterRegistration& RegisterFilter(grpc_channel_stack_type type,
+                                       UniqueTypeName name,
                                        const grpc_channel_filter* filter,
                                        FilterAdder filter_adder = nullptr,
                                        SourceLocation registration_source = {});
+    FilterRegistration& RegisterFilter(
+        grpc_channel_stack_type type, const grpc_channel_filter* filter,
+        SourceLocation registration_source = {}) {
+      CHECK(filter != nullptr);
+      return RegisterFilter(type, NameFromChannelFilter(filter), filter,
+                            nullptr, registration_source);
+    }
     template <typename Filter>
     FilterRegistration& RegisterFilter(
         grpc_channel_stack_type type, SourceLocation registration_source = {}) {
       return RegisterFilter(
-          type, &Filter::kFilter,
+          type, UniqueTypeNameFor<Filter>(), &Filter::kFilter,
           [](InterceptionChainBuilder& builder) { builder.Add<Filter>(); },
           registration_source);
     }
@@ -198,8 +321,7 @@ class ChannelInit {
     template <typename Filter>
     FilterRegistration& RegisterV2Filter(
         grpc_channel_stack_type type, SourceLocation registration_source = {}) {
-      return RegisterFilter(type, &Filter::kFilter, nullptr,
-                            registration_source)
+      return RegisterFilter(type, &Filter::kFilter, registration_source)
           .SkipV3();
     }
 
@@ -240,20 +362,27 @@ class ChannelInit {
   using CreatedType =
       typename decltype(T::Create(ChannelArgs(), {}))::value_type;
 
+  class DependencyTracker;
+
   struct Filter {
-    Filter(const grpc_channel_filter* filter, FilterAdder filter_adder,
-           std::vector<InclusionPredicate> predicates, bool skip_v3,
+    Filter(UniqueTypeName name, const grpc_channel_filter* filter,
+           FilterAdder filter_adder, std::vector<InclusionPredicate> predicates,
+           Version version, Ordering ordering,
            SourceLocation registration_source)
-        : filter(filter),
+        : name(name),
+          filter(filter),
           filter_adder(filter_adder),
           predicates(std::move(predicates)),
           registration_source(registration_source),
-          skip_v3(skip_v3) {}
+          version(version),
+          ordering(ordering) {}
+    UniqueTypeName name;
     const grpc_channel_filter* filter;
     const FilterAdder filter_adder;
     std::vector<InclusionPredicate> predicates;
     SourceLocation registration_source;
-    bool skip_v3 = false;
+    Version version;
+    Ordering ordering;
     bool CheckPredicates(const ChannelArgs& args) const;
   };
   struct StackConfig {
@@ -267,6 +396,12 @@ class ChannelInit {
   static StackConfig BuildStackConfig(
       const std::vector<std::unique_ptr<FilterRegistration>>& registrations,
       PostProcessor* post_processors, grpc_channel_stack_type type);
+  static void PrintChannelStackTrace(
+      grpc_channel_stack_type type,
+      const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
+          registrations,
+      const DependencyTracker& dependencies, const std::vector<Filter>& filters,
+      const std::vector<Filter>& terminal_filters);
 };
 
 }  // namespace grpc_core

data/src/core/lib/surface/client_call.cc

@@ -45,6 +45,7 @@
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -58,6 +59,7 @@
 #include "src/core/lib/transport/metadata.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/util/latent_see.h"
 
 namespace grpc_core {
 
@@ -100,14 +102,14 @@ grpc_call_error ValidateClientBatch(const grpc_op* ops, size_t nops) {
 
 }  // namespace
 
-ClientCall::ClientCall(
-    grpc_call*, uint32_t, grpc_completion_queue* cq, Slice path,
-    absl::optional<Slice> authority, bool registered_method, Timestamp deadline,
-    grpc_compression_options compression_options,
-    grpc_event_engine::experimental::EventEngine* event_engine,
-    RefCountedPtr<Arena> arena,
-    RefCountedPtr<UnstartedCallDestination> destination)
-    : Call(false, deadline, std::move(arena), event_engine),
+ClientCall::ClientCall(grpc_call*, uint32_t, grpc_completion_queue* cq,
+                       Slice path, absl::optional<Slice> authority,
+                       bool registered_method, Timestamp deadline,
+                       grpc_compression_options compression_options,
+                       RefCountedPtr<Arena> arena,
+                       RefCountedPtr<UnstartedCallDestination> destination)
+    : Call(false, deadline, std::move(arena)),
+      DualRefCounted("ClientCall"),
       cq_(cq),
       call_destination_(std::move(destination)),
       compression_options_(compression_options) {
@@ -128,6 +130,7 @@ ClientCall::ClientCall(
 grpc_call_error ClientCall::StartBatch(const grpc_op* ops, size_t nops,
                                        void* notify_tag,
                                        bool is_notify_tag_closure) {
+  GRPC_LATENT_SEE_PARENT_SCOPE("ClientCall::StartBatch");
   if (nops == 0) {
     EndOpImmediately(cq_, notify_tag, is_notify_tag_closure);
     return GRPC_CALL_OK;
@@ -153,6 +156,7 @@ void ClientCall::CancelWithError(grpc_error_handle error) {
         if (call_state_.compare_exchange_strong(cur_state, kCancelled,
                                                 std::memory_order_acq_rel,
                                                 std::memory_order_acquire)) {
+          ResetDeadline();
           return;
         }
         break;
@@ -168,6 +172,7 @@ void ClientCall::CancelWithError(grpc_error_handle error) {
         if (call_state_.compare_exchange_strong(cur_state, kCancelled,
                                                 std::memory_order_acq_rel,
                                                 std::memory_order_acquire)) {
+          ResetDeadline();
           auto* unordered_start = reinterpret_cast<UnorderedStart*>(cur_state);
           while (unordered_start != nullptr) {
             auto next = unordered_start->next;
@@ -225,16 +230,17 @@ void ClientCall::StartCall(const grpc_op& send_initial_metadata_op) {
               send_initial_metadata_.get());
   PrepareOutgoingInitialMetadata(send_initial_metadata_op,
                                  *send_initial_metadata_);
-  auto call = MakeCallPair(std::move(send_initial_metadata_), event_engine(),
-                           arena()->Ref());
+  auto call = MakeCallPair(std::move(send_initial_metadata_), arena()->Ref());
   started_call_initiator_ = std::move(call.initiator);
-  call_destination_->StartCall(std::move(call.handler));
   while (true) {
+    GRPC_TRACE_LOG(call, INFO)
+        << DebugTag() << "StartCall " << GRPC_DUMP_ARGS(cur_state);
     switch (cur_state) {
       case kUnstarted:
         if (call_state_.compare_exchange_strong(cur_state, kStarted,
                                                 std::memory_order_acq_rel,
                                                 std::memory_order_acquire)) {
+          call_destination_->StartCall(std::move(call.handler));
           return;
         }
         break;
@@ -246,6 +252,7 @@ void ClientCall::StartCall(const grpc_op& send_initial_metadata_op) {
         if (call_state_.compare_exchange_strong(cur_state, kStarted,
                                                 std::memory_order_acq_rel,
                                                 std::memory_order_acquire)) {
+          call_destination_->StartCall(std::move(call.handler));
           auto unordered_start = reinterpret_cast<UnorderedStart*>(cur_state);
           while (unordered_start->next != nullptr) {
             unordered_start->start_pending_batch();
@@ -305,7 +312,7 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                 ServerMetadataHandle metadata;
                 if (!md.ok() || !md->has_value()) {
                   is_trailers_only_ = true;
-                  metadata = Arena::MakePooled<ServerMetadata>();
+                  metadata = Arena::MakePooledForOverwrite<ServerMetadata>();
                 } else {
                   metadata = std::move(md->value());
                   is_trailers_only_ =
@@ -338,6 +345,8 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
           [this, out_status, out_status_details, out_error_string,
            out_trailing_metadata](
               ServerMetadataHandle server_trailing_metadata) {
+            saw_trailing_metadata_.store(true, std::memory_order_relaxed);
+            ResetDeadline();
             GRPC_TRACE_LOG(call, INFO)
                 << DebugTag() << "RecvStatusOnClient "
                 << server_trailing_metadata->DebugString();
@@ -401,18 +410,20 @@ char* ClientCall::GetPeer() {
   return gpr_strdup("unknown");
 }
 
-grpc_call* MakeClientCall(
-    grpc_call* parent_call, uint32_t propagation_mask,
-    grpc_completion_queue* cq, Slice path, absl::optional<Slice> authority,
-    bool registered_method, Timestamp deadline,
-    grpc_compression_options compression_options,
-    grpc_event_engine::experimental::EventEngine* event_engine,
-    RefCountedPtr<Arena> arena,
-    RefCountedPtr<UnstartedCallDestination> destination) {
+grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
+                          grpc_completion_queue* cq, Slice path,
+                          absl::optional<Slice> authority,
+                          bool registered_method, Timestamp deadline,
+                          grpc_compression_options compression_options,
+                          RefCountedPtr<Arena> arena,
+                          RefCountedPtr<UnstartedCallDestination> destination) {
+  DCHECK_NE(arena.get(), nullptr);
+  DCHECK_NE(arena->GetContext<grpc_event_engine::experimental::EventEngine>(),
+            nullptr);
   return arena
       ->New<ClientCall>(parent_call, propagation_mask, cq, std::move(path),
                         std::move(authority), registered_method, deadline,
-                        compression_options, event_engine, arena, destination)
+                        compression_options, arena, destination)
       ->c_ptr();
 }
 

data/src/core/lib/surface/client_call.h

@@ -64,7 +64,6 @@ class ClientCall final
              grpc_completion_queue* cq, Slice path,
              absl::optional<Slice> authority, bool registered_method,
              Timestamp deadline, grpc_compression_options compression_options,
-             grpc_event_engine::experimental::EventEngine* event_engine,
              RefCountedPtr<Arena> arena,
              RefCountedPtr<UnstartedCallDestination> destination);
 
@@ -82,8 +81,9 @@ class ClientCall final
   void InternalUnref(const char*) override { WeakUnref(); }
 
   void Orphaned() override {
-    // TODO(ctiller): only when we're not already finished
-    CancelWithError(absl::CancelledError());
+    if (!saw_trailing_metadata_.load(std::memory_order_relaxed)) {
+      CancelWithError(absl::CancelledError());
+    }
   }
 
   void SetCompletionQueue(grpc_completion_queue*) override {
@@ -150,7 +150,7 @@ class ClientCall final
   };
   std::atomic<uintptr_t> call_state_{kUnstarted};
   ClientMetadataHandle send_initial_metadata_{
-      Arena::MakePooled<ClientMetadata>()};
+      Arena::MakePooledForOverwrite<ClientMetadata>()};
   CallInitiator started_call_initiator_;
   // Status passed to CancelWithError;
   // if call_state_ == kCancelled then this is the authoritative status,
@@ -164,16 +164,16 @@ class ClientCall final
   ServerMetadataHandle received_initial_metadata_;
   ServerMetadataHandle received_trailing_metadata_;
   bool is_trailers_only_;
+  std::atomic<bool> saw_trailing_metadata_{false};
 };
 
-grpc_call* MakeClientCall(
-    grpc_call* parent_call, uint32_t propagation_mask,
-    grpc_completion_queue* cq, Slice path, absl::optional<Slice> authority,
-    bool registered_method, Timestamp deadline,
-    grpc_compression_options compression_options,
-    grpc_event_engine::experimental::EventEngine* event_engine,
-    RefCountedPtr<Arena> arena,
-    RefCountedPtr<UnstartedCallDestination> destination);
+grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
+                          grpc_completion_queue* cq, Slice path,
+                          absl::optional<Slice> authority,
+                          bool registered_method, Timestamp deadline,
+                          grpc_compression_options compression_options,
+                          RefCountedPtr<Arena> arena,
+                          RefCountedPtr<UnstartedCallDestination> destination);
 
 }  // namespace grpc_core