grpc 1.69.0 → 1.71.0

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

@@ -100,7 +100,7 @@ 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,
+                       Slice path, std::optional<Slice> authority,
                        bool registered_method, Timestamp deadline,
                        grpc_compression_options compression_options,
                        RefCountedPtr<Arena> arena,
@@ -318,7 +318,7 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
           return Map(
               started_call_initiator_.PullServerInitialMetadata(),
               [this,
-               array](ValueOrFailure<absl::optional<ServerMetadataHandle>> md) {
+               array](ValueOrFailure<std::optional<ServerMetadataHandle>> md) {
                 ServerMetadataHandle metadata;
                 if (!md.ok() || !md->has_value()) {
                   is_trailers_only_ = true;
@@ -335,9 +335,16 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
               });
         };
       });
-  auto primary_ops = AllOk<StatusFlag>(
-      TrySeq(std::move(send_message), std::move(send_close_from_client)),
-      TrySeq(std::move(recv_initial_metadata), std::move(recv_message)));
+  // We capture 'this' in the op handlers, but the call may be destroyed before
+  // the party owned by CallInitiator/CallHandler is destroyed -- meaning that
+  // op callbacks may happen after call destruction if we don't hold a ref.
+  // We do that via an implicitly captured one in a Map() here so that we don't
+  // need a ref held per batch operation -- they have the same lifetime always.
+  auto primary_ops = Map(
+      AllOk<StatusFlag>(
+          TrySeq(std::move(send_message), std::move(send_close_from_client)),
+          TrySeq(std::move(recv_initial_metadata), std::move(recv_message))),
+      [self = WeakRef()](StatusFlag x) { return x; });
   Party::WakeupHold wakeup_hold;
   if (const grpc_op* op = op_index.op(GRPC_OP_SEND_INITIAL_METADATA)) {
     wakeup_hold = StartCall(*op);
@@ -348,42 +355,19 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
     auto out_error_string = op->data.recv_status_on_client.error_string;
     auto out_trailing_metadata =
         op->data.recv_status_on_client.trailing_metadata;
-    auto make_read_trailing_metadata = [this, out_status, out_status_details,
-                                        out_error_string,
+    auto make_read_trailing_metadata = [self = WeakRef(), out_status,
+                                        out_status_details, out_error_string,
                                         out_trailing_metadata]() {
-      return Map(
-          started_call_initiator_.PullServerTrailingMetadata(),
-          [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();
-            const auto status =
-                server_trailing_metadata->get(GrpcStatusMetadata())
-                    .value_or(GRPC_STATUS_UNKNOWN);
-            *out_status = status;
-            Slice message_slice;
-            if (Slice* message = server_trailing_metadata->get_pointer(
-                    GrpcMessageMetadata())) {
-              message_slice = message->Ref();
-            }
-            *out_status_details = message_slice.TakeCSlice();
-            if (out_error_string != nullptr) {
-              if (status != GRPC_STATUS_OK) {
-                *out_error_string = gpr_strdup(
-                    MakeErrorString(server_trailing_metadata.get()).c_str());
-              } else {
-                *out_error_string = nullptr;
-              }
-            }
-            PublishMetadataArray(server_trailing_metadata.get(),
-                                 out_trailing_metadata, true);
-            received_trailing_metadata_ = std::move(server_trailing_metadata);
-            return Success{};
-          });
+      return Map(self->started_call_initiator_.PullServerTrailingMetadata(),
+                 [self, out_status, out_status_details, out_error_string,
+                  out_trailing_metadata](
+                     ServerMetadataHandle server_trailing_metadata) {
+                   self->OnReceivedStatus(std::move(server_trailing_metadata),
+                                          out_status, out_status_details,
+                                          out_error_string,
+                                          out_trailing_metadata);
+                   return Success{};
+                 });
     };
     ScheduleCommittedBatch(InfallibleBatch(
         std::move(primary_ops),
@@ -408,6 +392,37 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
   }
 }
 
+void ClientCall::OnReceivedStatus(ServerMetadataHandle server_trailing_metadata,
+                                  grpc_status_code* out_status,
+                                  grpc_slice* out_status_details,
+                                  const char** out_error_string,
+                                  grpc_metadata_array* out_trailing_metadata) {
+  saw_trailing_metadata_.store(true, std::memory_order_relaxed);
+  ResetDeadline();
+  GRPC_TRACE_LOG(call, INFO) << DebugTag() << "RecvStatusOnClient "
+                             << server_trailing_metadata->DebugString();
+  const auto status = server_trailing_metadata->get(GrpcStatusMetadata())
+                          .value_or(GRPC_STATUS_UNKNOWN);
+  *out_status = status;
+  Slice message_slice;
+  if (Slice* message =
+          server_trailing_metadata->get_pointer(GrpcMessageMetadata())) {
+    message_slice = message->Ref();
+  }
+  *out_status_details = message_slice.TakeCSlice();
+  if (out_error_string != nullptr) {
+    if (status != GRPC_STATUS_OK) {
+      *out_error_string =
+          gpr_strdup(MakeErrorString(server_trailing_metadata.get()).c_str());
+    } else {
+      *out_error_string = nullptr;
+    }
+  }
+  PublishMetadataArray(server_trailing_metadata.get(), out_trailing_metadata,
+                       true);
+  received_trailing_metadata_ = std::move(server_trailing_metadata);
+}
+
 char* ClientCall::GetPeer() {
   Slice peer_slice = GetPeerString();
   if (!peer_slice.empty()) {
@@ -423,7 +438,7 @@ char* ClientCall::GetPeer() {
 
 grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
                           grpc_completion_queue* cq, Slice path,
-                          absl::optional<Slice> authority,
+                          std::optional<Slice> authority,
                           bool registered_method, Timestamp deadline,
                           grpc_compression_options compression_options,
                           RefCountedPtr<Arena> arena,

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

@@ -59,7 +59,7 @@ class ClientCall final
  public:
   ClientCall(grpc_call* parent_call, uint32_t propagation_mask,
              grpc_completion_queue* cq, Slice path,
-             absl::optional<Slice> authority, bool registered_method,
+             std::optional<Slice> authority, bool registered_method,
              Timestamp deadline, grpc_compression_options compression_options,
              RefCountedPtr<Arena> arena,
              RefCountedPtr<UnstartedCallDestination> destination);
@@ -139,6 +139,11 @@ class ClientCall final
                                  UnstartedCallHandler& handler);
 
   std::string DebugTag() { return absl::StrFormat("CLIENT_CALL[%p]: ", this); }
+  void OnReceivedStatus(ServerMetadataHandle server_trailing_metadata,
+                        grpc_status_code* out_status,
+                        grpc_slice* out_status_details,
+                        const char** out_error_string,
+                        grpc_metadata_array* out_trailing_metadata);
 
   // call_state_ is one of:
   // 1. kUnstarted - call has not yet been started
@@ -176,7 +181,7 @@ class ClientCall final
 
 grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
                           grpc_completion_queue* cq, Slice path,
-                          absl::optional<Slice> authority,
+                          std::optional<Slice> authority,
                           bool registered_method, Timestamp deadline,
                           grpc_compression_options compression_options,
                           RefCountedPtr<Arena> arena,

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

@@ -816,16 +816,12 @@ static void cq_end_op_for_pluck(
   }
 }
 
-static void functor_callback(void* arg, grpc_error_handle error) {
-  auto* functor = static_cast<grpc_completion_queue_functor*>(arg);
-  functor->functor_run(functor, error.ok());
-}
-
 // Complete an event on a completion queue of type GRPC_CQ_CALLBACK
 static void cq_end_op_for_callback(
     grpc_completion_queue* cq, void* tag, grpc_error_handle error,
     void (*done)(void* done_arg, grpc_cq_completion* storage), void* done_arg,
     grpc_cq_completion* storage, bool internal) {
+  (void)internal;
   cq_callback_data* cqd = static_cast<cq_callback_data*> DATA_FROM_CQ(cq);
 
   if (GRPC_TRACE_FLAG_ENABLED(api) ||
@@ -851,32 +847,11 @@ static void cq_end_op_for_callback(
   }
 
   auto* functor = static_cast<grpc_completion_queue_functor*>(tag);
-  if (grpc_core::IsEventEngineApplicationCallbacksEnabled()) {
-    // Run the callback on EventEngine threads.
-    cqd->event_engine->Run(
-        [engine = cqd->event_engine, functor, ok = error.ok()]() {
-          grpc_core::ExecCtx exec_ctx;
-          (*functor->functor_run)(functor, ok);
-        });
-    return;
-  }
-  // If possible, schedule the callback onto an existing thread-local
-  // ApplicationCallbackExecCtx, which is a work queue. This is possible for:
-  // 1. The callback is internally-generated and there is an ACEC available
-  // 2. The callback is marked inlineable and there is an ACEC available
-  // 3. We are already running in a background poller thread (which always has
-  //    an ACEC available at the base of the stack).
-  if (((internal || functor->inlineable) &&
-       grpc_core::ApplicationCallbackExecCtx::Available()) ||
-      grpc_iomgr_is_any_background_poller_thread()) {
-    grpc_core::ApplicationCallbackExecCtx::Enqueue(functor, (error.ok()));
-    return;
-  }
-
-  // Schedule the callback on a closure if not internal or triggered
-  // from a background poller thread.
-  grpc_core::Executor::Run(
-      GRPC_CLOSURE_CREATE(functor_callback, functor, nullptr), error);
+  cqd->event_engine->Run(
+      [engine = cqd->event_engine, functor, ok = error.ok()]() {
+        grpc_core::ExecCtx exec_ctx;
+        (*functor->functor_run)(functor, ok);
+      });
 }
 
 void grpc_cq_end_op(grpc_completion_queue* cq, void* tag,
@@ -1347,23 +1322,10 @@ static void cq_finish_shutdown_callback(grpc_completion_queue* cq) {
 
   cq->poller_vtable->shutdown(POLLSET_FROM_CQ(cq), &cq->pollset_shutdown_done);
 
-  if (grpc_core::IsEventEngineApplicationCallbacksEnabled()) {
-    cqd->event_engine->Run([engine = cqd->event_engine, callback]() {
-      grpc_core::ExecCtx exec_ctx;
-      callback->functor_run(callback, /*true=*/1);
-    });
-    return;
-  }
-  if (grpc_iomgr_is_any_background_poller_thread()) {
-    grpc_core::ApplicationCallbackExecCtx::Enqueue(callback, true);
-    return;
-  }
-
-  // Schedule the callback on a closure if not internal or triggered
-  // from a background poller thread.
-  grpc_core::Executor::Run(
-      GRPC_CLOSURE_CREATE(functor_callback, callback, nullptr),
-      absl::OkStatus());
+  cqd->event_engine->Run([engine = cqd->event_engine, callback]() {
+    grpc_core::ExecCtx exec_ctx;
+    callback->functor_run(callback, /*true=*/1);
+  });
 }
 
 static void cq_shutdown_callback(grpc_completion_queue* cq) {
@@ -1395,7 +1357,6 @@ static void cq_shutdown_callback(grpc_completion_queue* cq) {
 // Shutdown simply drops a ref that we reserved at creation time; if we drop
 // to zero here, then enter shutdown mode and wake up any waiters
 void grpc_completion_queue_shutdown(grpc_completion_queue* cq) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_completion_queue_shutdown(cq=" << cq << ")";

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

@@ -27,7 +27,13 @@
 #include "absl/strings/str_join.h"
 
 static void addhdr(grpc_event* ev, std::vector<std::string>* buf) {
-  buf->push_back(absl::StrFormat("tag:%p", ev->tag));
+  if (reinterpret_cast<intptr_t>(ev->tag) < 1024 &&
+      reinterpret_cast<intptr_t>(ev->tag) > -1024) {
+    buf->push_back(
+        absl::StrFormat("tag:%d", reinterpret_cast<int64_t>(ev->tag)));
+  } else {
+    buf->push_back(absl::StrFormat("tag:%p", ev->tag));
+  }
 }
 
 static const char* errstr(int success) { return success ? "OK" : "ERROR"; }

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

@@ -263,7 +263,6 @@ void FilterStackCall::DestroyCall(void* call, grpc_error_handle /*error*/) {
 void FilterStackCall::ExternalUnref() {
   if (GPR_LIKELY(!ext_ref_.Unref())) return;
 
-  ApplicationCallbackExecCtx callback_exec_ctx;
   ExecCtx exec_ctx;
 
   GRPC_TRACE_LOG(api, INFO) << "grpc_call_unref(c=" << this << ")";
@@ -450,8 +449,7 @@ void FilterStackCall::RecvTrailingFilter(grpc_metadata_batch* b,
   if (!batch_error.ok()) {
     SetFinalStatus(batch_error);
   } else {
-    absl::optional<grpc_status_code> grpc_status =
-        b->Take(GrpcStatusMetadata());
+    std::optional<grpc_status_code> grpc_status = b->Take(GrpcStatusMetadata());
     if (grpc_status.has_value()) {
       grpc_status_code status_code = *grpc_status;
       grpc_error_handle error;
@@ -658,7 +656,7 @@ void FilterStackCall::BatchControl::ReceivingInitialMetadataReady(
     grpc_metadata_batch* md = &call->recv_initial_metadata_;
     call->RecvInitialFilter(md);
 
-    absl::optional<Timestamp> deadline = md->get(GrpcTimeoutMetadata());
+    std::optional<Timestamp> deadline = md->get(GrpcTimeoutMetadata());
     if (deadline.has_value() && !call->is_client()) {
       call_->set_send_deadline(*deadline);
     }

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

@@ -300,7 +300,7 @@ class FilterStackCall final : public Call {
   grpc_call_final_info final_info_;
 
   SliceBuffer send_slice_buffer_;
-  absl::optional<SliceBuffer> receiving_slice_buffer_;
+  std::optional<SliceBuffer> receiving_slice_buffer_;
   uint32_t receiving_stream_flags_;
   uint32_t test_only_last_message_flags_ = 0;
   // Compression algorithm for *incoming* data

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

@@ -72,12 +72,21 @@ static bool g_shutting_down ABSL_GUARDED_BY(g_init_mu) = false;
 
 namespace grpc_core {
 void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
-  builder->channel_init()
-      ->RegisterV2Filter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
-      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-  builder->channel_init()
-      ->RegisterV2Filter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
-      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  if (IsCallv3ClientAuthFilterEnabled()) {
+    builder->channel_init()
+        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+    builder->channel_init()
+        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  } else {
+    builder->channel_init()
+        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+    builder->channel_init()
+        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  }
   builder->channel_init()
       ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
       .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
@@ -168,14 +177,9 @@ void grpc_shutdown(void) {
   grpc_core::MutexLock lock(g_init_mu);
 
   if (--g_initializations == 0) {
-    grpc_core::ApplicationCallbackExecCtx* acec =
-        grpc_core::ApplicationCallbackExecCtx::Get();
     if (!grpc_iomgr_is_any_background_poller_thread() &&
         !grpc_event_engine::experimental::TimerManager::
             IsTimerManagerThread() &&
-        (acec == nullptr ||
-         (acec->Flags() & GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD) ==
-             0) &&
         grpc_core::ExecCtx::Get() == nullptr) {
       // just run clean-up when this is called on non-executor thread.
       VLOG(2) << "grpc_shutdown starts clean-up now";
@@ -229,7 +233,8 @@ bool grpc_wait_for_shutdown_with_timeout(absl::Duration timeout) {
   grpc_core::MutexLock lock(g_init_mu);
   while (g_initializations != 0) {
     if (g_shutting_down_cv->WaitWithDeadline(g_init_mu, deadline)) {
-      LOG(ERROR) << "grpc_wait_for_shutdown_with_timeout() timed out.";
+      GRPC_TRACE_LOG(api, ERROR)
+          << "grpc_wait_for_shutdown_with_timeout() timed out.";
       return false;
     }
   }

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

@@ -26,10 +26,21 @@ extern bool (*IsInitializedInternally)();
 
 class KeepsGrpcInitialized {
  public:
-  KeepsGrpcInitialized() { InitInternally(); }
-  ~KeepsGrpcInitialized() { ShutdownInternally(); }
+  explicit KeepsGrpcInitialized(bool enabled = true) : enabled_(enabled) {
+    if (enabled_) {
+      InitInternally();
+    }
+  }
+  ~KeepsGrpcInitialized() {
+    if (enabled_) {
+      ShutdownInternally();
+    }
+  }
   KeepsGrpcInitialized(const KeepsGrpcInitialized&) = delete;
   KeepsGrpcInitialized& operator=(const KeepsGrpcInitialized&) = delete;
+
+ private:
+  bool enabled_;
 };
 
 }  // namespace grpc_core

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

@@ -24,11 +24,12 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/config/core_configuration.h"
@@ -178,11 +179,13 @@ bool LegacyChannel::IsLame() const {
   return elem->filter == &LameClientFilter::kFilter;
 }
 
-grpc_call* LegacyChannel::CreateCall(
-    grpc_call* parent_call, uint32_t propagation_mask,
-    grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
-    Slice path, absl::optional<Slice> authority, Timestamp deadline,
-    bool registered_method) {
+grpc_call* LegacyChannel::CreateCall(grpc_call* parent_call,
+                                     uint32_t propagation_mask,
+                                     grpc_completion_queue* cq,
+                                     grpc_pollset_set* pollset_set_alternative,
+                                     Slice path, std::optional<Slice> authority,
+                                     Timestamp deadline,
+                                     bool registered_method) {
   CHECK(is_client_);
   CHECK(!(cq != nullptr && pollset_set_alternative != nullptr));
   grpc_call_create_args args;
@@ -286,7 +289,6 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
     MutexLock lock(&mu_);
     timer_handle_ =
         channel_->event_engine()->RunAfter(timeout, [self = Ref()]() mutable {
-          ApplicationCallbackExecCtx callback_exec_ctx;
           ExecCtx exec_ctx;
           self->TimeoutComplete();
           // StateWatcher deletion might require an active ExecCtx.
@@ -343,7 +345,7 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
   // timer callback fired immediately on an EventEngine thread before
   // RunAfter() returns.
   Mutex mu_;
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+  std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       timer_handle_ ABSL_GUARDED_BY(mu_);
   bool timer_fired_ = false;
 };

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

@@ -23,10 +23,10 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
@@ -61,7 +61,7 @@ class LegacyChannel final : public Channel {
   grpc_call* CreateCall(grpc_call* parent_call, uint32_t propagation_mask,
                         grpc_completion_queue* cq,
                         grpc_pollset_set* pollset_set_alternative, Slice path,
-                        absl::optional<Slice> authority, Timestamp deadline,
+                        std::optional<Slice> authority, Timestamp deadline,
                         bool registered_method) override;
 
   void StartCall(UnstartedCallHandler) override {