grpc 1.50.0.pre1 → 1.51.0

data/src/core/lib/channel/channel_stack.h

@@ -49,13 +49,16 @@
 #include <stddef.h>
 
 #include <functional>
+#include <memory>
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
@@ -201,7 +204,6 @@ struct grpc_call_element {
    guarantees they live within a single malloc() allocation */
 struct grpc_channel_stack {
   grpc_stream_refcount refcount;
-  bool is_client;
   size_t count;
   /* Memory required for a call stack (computed at channel stack
      initialization) */
@@ -212,6 +214,14 @@ struct grpc_channel_stack {
   // should look like and this can go.
   grpc_core::ManualConstructor<std::function<void()>> on_destroy;
 
+  grpc_core::ManualConstructor<
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>>
+      event_engine;
+
+  grpc_event_engine::experimental::EventEngine* EventEngine() const {
+    return event_engine->get();
+  }
+
   // Minimal infrastructure to act like a RefCounted thing without converting
   // everything.
   // It's likely that we'll want to replace grpc_channel_stack with something
@@ -224,8 +234,10 @@ struct grpc_channel_stack {
     return grpc_core::RefCountedPtr<grpc_channel_stack>(this);
   }
 
-  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> MakeCallPromise(
-      grpc_core::CallArgs call_args);
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
+  MakeClientCallPromise(grpc_core::CallArgs call_args);
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
+  MakeServerCallPromise(grpc_core::CallArgs call_args);
 };
 
 /* A call stack tracks a set of related filters for one call, and guarantees
@@ -272,7 +284,8 @@ size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
-    const grpc_channel_args* args, const char* name, grpc_channel_stack* stack);
+    const grpc_core::ChannelArgs& args, const char* name,
+    grpc_channel_stack* stack);
 /* Destroy a channel stack */
 void grpc_channel_stack_destroy(grpc_channel_stack* stack);
 

data/src/core/lib/channel/channel_stack_builder.cc

@@ -26,7 +26,10 @@
 
 namespace grpc_core {
 
-ChannelStackBuilder::~ChannelStackBuilder() = default;
+ChannelStackBuilder::ChannelStackBuilder(const char* name,
+                                         grpc_channel_stack_type type,
+                                         const ChannelArgs& channel_args)
+    : name_(name), type_(type), args_(channel_args) {}
 
 ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   if (target == nullptr) {
@@ -37,12 +40,6 @@ ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   return *this;
 }
 
-ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(
-    const ChannelArgs& args) {
-  args_ = args;
-  return *this;
-}
-
 void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter) {
   stack_.insert(stack_.begin(), filter);
 }

data/src/core/lib/channel/channel_stack_builder.h

@@ -41,8 +41,9 @@ namespace grpc_core {
 class ChannelStackBuilder {
  public:
   // Initialize with a name.
-  ChannelStackBuilder(const char* name, grpc_channel_stack_type type)
-      : name_(name), type_(type) {}
+  // channel_args *must be* preconditioned already.
+  ChannelStackBuilder(const char* name, grpc_channel_stack_type type,
+                      const ChannelArgs& channel_args);
 
   const char* name() const { return name_; }
 
@@ -62,15 +63,17 @@ class ChannelStackBuilder {
   // Query the transport.
   grpc_transport* transport() const { return transport_; }
 
-  // Set channel args.
-  ChannelStackBuilder& SetChannelArgs(const ChannelArgs& args);
-
   // Query the channel args.
   const ChannelArgs& channel_args() const { return args_; }
 
   // Mutable vector of proposed stack entries.
   std::vector<const grpc_channel_filter*>* mutable_stack() { return &stack_; }
 
+  // Immutable vector of proposed stack entries.
+  const std::vector<const grpc_channel_filter*>& stack() const {
+    return stack_;
+  }
+
   // The type of channel stack being built.
   grpc_channel_stack_type channel_stack_type() const { return type_; }
 
@@ -80,6 +83,11 @@ class ChannelStackBuilder {
   // Helper to add a filter to the end of the stack.
   void AppendFilter(const grpc_channel_filter* filter);
 
+  // Determine whether a promise-based call stack is able to be built.
+  // Iterates each filter and ensures that there's a promise factory there.
+  // This will go away once the promise conversion is completed.
+  virtual bool IsPromising() const = 0;
+
   // Build the channel stack.
   // After success, *result holds the new channel stack,
   // prefix_bytes are allocated before the channel stack,
@@ -88,7 +96,7 @@ class ChannelStackBuilder {
   virtual absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() = 0;
 
  protected:
-  ~ChannelStackBuilder();
+  ~ChannelStackBuilder() = default;
 
  private:
   static std::string unknown_target() { return "unknown"; }

data/src/core/lib/channel/channel_stack_builder_impl.cc

@@ -22,6 +22,7 @@
 
 #include <string.h>
 
+#include <algorithm>
 #include <vector>
 
 #include "absl/status/status.h"
@@ -30,21 +31,39 @@
 #include <grpc/support/alloc.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"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
+bool ChannelStackBuilderImpl::IsPromising() const {
+  for (const auto* filter : stack()) {
+    if (filter->make_call_promise == nullptr) return false;
+  }
+  return true;
+}
+
 absl::StatusOr<RefCountedPtr<grpc_channel_stack>>
 ChannelStackBuilderImpl::Build() {
-  auto* stack = mutable_stack();
+  std::vector<const grpc_channel_filter*> stack;
+  const bool is_promising = IsPromising();
+
+  for (const auto* filter : this->stack()) {
+    if (is_promising && grpc_call_trace.enabled()) {
+      stack.push_back(PromiseTracingFilterFor(filter));
+    }
+    stack.push_back(filter);
+  }
 
   // calculate the size of the channel stack
   size_t channel_stack_size =
-      grpc_channel_stack_size(stack->data(), stack->size());
+      grpc_channel_stack_size(stack.data(), stack.size());
 
   // allocate memory
   auto* channel_stack =
@@ -72,19 +91,18 @@ ChannelStackBuilderImpl::Build() {
         grpc_channel_stack_destroy(stk);
         gpr_free(stk);
       },
-      channel_stack, stack->data(), stack->size(), final_args.ToC().get(),
-      name(), channel_stack);
+      channel_stack, stack.data(), stack.size(), final_args, name(),
+      channel_stack);
 
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     grpc_channel_stack_destroy(channel_stack);
     gpr_free(channel_stack);
     auto status = grpc_error_to_absl_status(error);
-    GRPC_ERROR_UNREF(error);
     return status;
   }
 
   // run post-initialization functions
-  for (size_t i = 0; i < stack->size(); i++) {
+  for (size_t i = 0; i < stack.size(); i++) {
     auto* elem = grpc_channel_stack_element(channel_stack, i);
     elem->filter->post_init_channel_elem(channel_stack, elem);
   }

data/src/core/lib/channel/channel_stack_builder_impl.h

@@ -34,6 +34,8 @@ class ChannelStackBuilderImpl final : public ChannelStackBuilder {
  public:
   using ChannelStackBuilder::ChannelStackBuilder;
 
+  bool IsPromising() const override;
+
   // Build the channel stack.
   // After success, *result holds the new channel stack,
   // prefix_bytes are allocated before the channel stack,

data/src/core/lib/channel/channel_trace.cc

@@ -21,7 +21,6 @@
 #include "src/core/lib/channel/channel_trace.h"
 
 #include <algorithm>
-#include <map>
 #include <string>
 #include <utility>
 
@@ -30,8 +29,8 @@
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_refcount.h"
 
 namespace grpc_core {
 namespace channelz {
@@ -52,7 +51,7 @@ ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data)
       next_(nullptr),
       memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)) {}
 
-ChannelTrace::TraceEvent::~TraceEvent() { grpc_slice_unref_internal(data_); }
+ChannelTrace::TraceEvent::~TraceEvent() { CSliceUnref(data_); }
 
 ChannelTrace::ChannelTrace(size_t max_event_memory)
     : num_events_logged_(0),
@@ -103,7 +102,7 @@ void ChannelTrace::AddTraceEventHelper(TraceEvent* new_trace_event) {
 
 void ChannelTrace::AddTraceEvent(Severity severity, const grpc_slice& data) {
   if (max_event_memory_ == 0) {
-    grpc_slice_unref_internal(data);
+    CSliceUnref(data);
     return;  // tracing is disabled if max_event_memory_ == 0
   }
   AddTraceEventHelper(new TraceEvent(severity, data));
@@ -113,7 +112,7 @@ void ChannelTrace::AddTraceEventWithReference(
     Severity severity, const grpc_slice& data,
     RefCountedPtr<BaseNode> referenced_entity) {
   if (max_event_memory_ == 0) {
-    grpc_slice_unref_internal(data);
+    CSliceUnref(data);
     return;  // tracing is disabled if max_event_memory_ == 0
   }
   // create and fill up the new event

data/src/core/lib/channel/channelz.cc

@@ -22,7 +22,6 @@
 
 #include <algorithm>
 #include <atomic>
-#include <memory>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
@@ -40,6 +39,7 @@
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/uri/uri_parser.h"