grpc 1.63.0 → 1.66.0

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

@@ -19,26 +19,23 @@
 #ifndef GRPC_SRC_CORE_LIB_SURFACE_CALL_H
 #define GRPC_SRC_CORE_LIB_SURFACE_CALL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/functional/function_ref.h"
+#include "absl/log/check.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
 #include <grpc/impl/compression_types.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -48,10 +45,10 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
-#include "src/core/lib/surface/server_interface.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/server/server_interface.h"
+#include "src/core/util/time_precise.h"
 
 typedef void (*grpc_ioreq_completion_func)(grpc_call* call, int success,
                                            void* user_data);
@@ -77,91 +74,165 @@ typedef struct grpc_call_create_args {
 } grpc_call_create_args;
 
 namespace grpc_core {
-class BasicPromiseBasedCall;
-class ServerPromiseBasedCall;
-
-class ServerCallContext {
- public:
-  virtual void PublishInitialMetadata(
-      ClientMetadataHandle metadata,
-      grpc_metadata_array* publish_initial_metadata) = 0;
-
-  // Construct the top of the server call promise for the v2 filter stack.
-  // TODO(ctiller): delete when v3 is available.
-  virtual ArenaPromise<ServerMetadataHandle> MakeTopOfServerCallPromise(
-      CallArgs call_args, grpc_completion_queue* cq,
-      absl::FunctionRef<void(grpc_call* call)> publish) = 0;
-
-  // Server stream data as supplied by the transport (so we can link the
-  // transport stream up with the call again).
-  // TODO(ctiller): legacy API - once we move transports to promises we'll
-  // create the promise directly and not need to pass around this token.
-  virtual const void* server_stream_data() = 0;
 
- protected:
-  ~ServerCallContext() = default;
+template <>
+struct ArenaContextType<census_context> {
+  static void Destroy(census_context*) {}
 };
 
-// TODO(ctiller): move more call things into this type
-class CallContext {
+class Call : public CppImplOf<Call, grpc_call>,
+             public grpc_event_engine::experimental::EventEngine::
+                 Closure /* for deadlines */ {
  public:
-  explicit CallContext(BasicPromiseBasedCall* call) : call_(call) {}
+  Arena* arena() const { return arena_.get(); }
+  bool is_client() const { return is_client_; }
+
+  virtual bool Completed() = 0;
+  void CancelWithStatus(grpc_status_code status, const char* description);
+  virtual void CancelWithError(grpc_error_handle error) = 0;
+  virtual void SetCompletionQueue(grpc_completion_queue* cq) = 0;
+  virtual char* GetPeer() = 0;
+  virtual grpc_call_error StartBatch(const grpc_op* ops, size_t nops,
+                                     void* notify_tag,
+                                     bool is_notify_tag_closure) = 0;
+  virtual bool failed_before_recv_message() const = 0;
+  virtual bool is_trailers_only() const = 0;
+  virtual absl::string_view GetServerAuthority() const = 0;
+  virtual void ExternalRef() = 0;
+  virtual void ExternalUnref() = 0;
+  virtual void InternalRef(const char* reason) = 0;
+  virtual void InternalUnref(const char* reason) = 0;
+
+  void UpdateDeadline(Timestamp deadline) ABSL_LOCKS_EXCLUDED(deadline_mu_);
+  void ResetDeadline() ABSL_LOCKS_EXCLUDED(deadline_mu_);
+  Timestamp deadline() {
+    MutexLock lock(&deadline_mu_);
+    return deadline_;
+  }
 
-  // Update the deadline (if deadline < the current deadline).
-  void UpdateDeadline(Timestamp deadline);
-  Timestamp deadline() const;
+  virtual uint32_t test_only_message_flags() = 0;
+  CompressionAlgorithmSet encodings_accepted_by_peer() {
+    return encodings_accepted_by_peer_;
+  }
 
-  // Run some action in the call activity context. This is needed to adapt some
-  // legacy systems to promises, and will likely disappear once that conversion
-  // is complete.
-  void RunInContext(absl::AnyInvocable<void()> fn);
+  // This should return nullptr for the promise stack (and alternative means
+  // for that functionality be invented)
+  virtual grpc_call_stack* call_stack() = 0;
 
-  // TODO(ctiller): remove this once transport APIs are promise based
-  void IncrementRefCount(const char* reason = "call_context");
+  // Implementation of EventEngine::Closure, called when deadline expires
+  void Run() final;
 
-  // TODO(ctiller): remove this once transport APIs are promise based
-  void Unref(const char* reason = "call_context");
+  gpr_cycle_counter start_time() const { return start_time_; }
 
-  RefCountedPtr<CallContext> Ref() {
-    IncrementRefCount();
-    return RefCountedPtr<CallContext>(this);
+  void set_traced(bool traced) { traced_ = traced; }
+  bool traced() const { return traced_; }
+
+  virtual grpc_compression_algorithm incoming_compression_algorithm() = 0;
+
+ protected:
+  // The maximum number of concurrent batches possible.
+  // Based upon the maximum number of individually queueable ops in the batch
+  // api:
+  //    - initial metadata send
+  //    - message send
+  //    - status/close send (depending on client/server)
+  //    - initial metadata recv
+  //    - message recv
+  //    - status/close recv (depending on client/server)
+  static constexpr size_t kMaxConcurrentBatches = 6;
+
+  struct ParentCall {
+    Mutex child_list_mu;
+    Call* first_child ABSL_GUARDED_BY(child_list_mu) = nullptr;
+  };
+
+  struct ChildCall {
+    explicit ChildCall(Call* parent) : parent(parent) {}
+    Call* parent;
+    /// siblings: children of the same parent form a list, and this list is
+    /// protected under
+    /// parent->mu
+    Call* sibling_next = nullptr;
+    Call* sibling_prev = nullptr;
+  };
+
+  Call(bool is_client, Timestamp send_deadline, RefCountedPtr<Arena> arena);
+  ~Call() override = default;
+
+  ParentCall* GetOrCreateParentCall();
+  ParentCall* parent_call();
+
+  absl::Status InitParent(Call* parent, uint32_t propagation_mask);
+  void PublishToParent(Call* parent);
+  void MaybeUnpublishFromParent();
+  void PropagateCancellationToChildren();
+
+  Timestamp send_deadline() const { return send_deadline_; }
+  void set_send_deadline(Timestamp send_deadline) {
+    send_deadline_ = send_deadline;
   }
 
-  grpc_call_stats* call_stats() { return &call_stats_; }
-  gpr_atm* peer_string_atm_ptr();
-  gpr_cycle_counter call_start_time() { return start_time_; }
+  Slice GetPeerString() const {
+    MutexLock lock(&peer_mu_);
+    return peer_string_.Ref();
+  }
 
-  ServerCallContext* server_call_context();
+  void SetPeerString(Slice peer_string) {
+    MutexLock lock(&peer_mu_);
+    peer_string_ = std::move(peer_string);
+  }
 
-  void set_traced(bool traced) { traced_ = traced; }
-  bool traced() const { return traced_; }
+  void ClearPeerString() { SetPeerString(Slice(grpc_empty_slice())); }
+
+  // TODO(ctiller): cancel_func is for cancellation of the call - filter stack
+  // holds no mutexes here, promise stack does, and so locking is different.
+  // Remove this and cancel directly once promise conversion is done.
+  void ProcessIncomingInitialMetadata(grpc_metadata_batch& md);
+  // Fixup outgoing metadata before sending - adds compression, protects
+  // internal headers against external modification.
+  void PrepareOutgoingInitialMetadata(const grpc_op& op,
+                                      grpc_metadata_batch& md);
+
+  void HandleCompressionAlgorithmDisabled(
+      grpc_compression_algorithm compression_algorithm) GPR_ATTRIBUTE_NOINLINE;
+  void HandleCompressionAlgorithmNotAccepted(
+      grpc_compression_algorithm compression_algorithm) GPR_ATTRIBUTE_NOINLINE;
 
-  // TEMPORARY HACK
-  // Create a call spine object for this call.
-  // Said object should only be created once.
-  // Allows interop between the v2 call stack and the v3 (which is required by
-  // transports).
-  RefCountedPtr<CallSpineInterface> MakeCallSpine(CallArgs call_args);
-  grpc_call* c_call();
+  virtual grpc_compression_options compression_options() = 0;
+
+  virtual void SetIncomingCompressionAlgorithm(
+      grpc_compression_algorithm algorithm) = 0;
 
  private:
-  friend class PromiseBasedCall;
-  // Call final info.
-  grpc_call_stats call_stats_;
-  // TODO(ctiller): remove this once transport APIs are promise based and we
-  // don't need refcounting here.
-  BasicPromiseBasedCall* const call_;
-  gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
+  const RefCountedPtr<Arena> arena_;
+  std::atomic<ParentCall*> parent_call_{nullptr};
+  ChildCall* child_ = nullptr;
+  Timestamp send_deadline_;
+  const bool is_client_;
+  // flag indicating that cancellation is inherited
+  bool cancellation_is_inherited_ = false;
   // Is this call traced?
   bool traced_ = false;
+  // Supported encodings (compression algorithms), a bitset.
+  // Always support no compression.
+  CompressionAlgorithmSet encodings_accepted_by_peer_{GRPC_COMPRESS_NONE};
+  // Peer name is protected by a mutex because it can be accessed by the
+  // application at the same moment as it is being set by the completion
+  // of the recv_initial_metadata op.  The mutex should be mostly uncontended.
+  mutable Mutex peer_mu_;
+  Slice peer_string_;
+  // Current deadline.
+  Mutex deadline_mu_;
+  Timestamp deadline_ ABSL_GUARDED_BY(deadline_mu_) = Timestamp::InfFuture();
+  grpc_event_engine::experimental::EventEngine::TaskHandle ABSL_GUARDED_BY(
+      deadline_mu_) deadline_task_;
+  gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
 };
 
 template <>
-struct ContextType<CallContext> {};
-
-RefCountedPtr<CallSpineInterface> MakeServerCall(ServerInterface* server,
-                                                 Channel* channel,
-                                                 Arena* arena);
+struct ArenaContextType<Call> {
+  static void Destroy(Call*) {}
+};
 
 }  // namespace grpc_core
 
@@ -189,30 +260,40 @@ void grpc_call_cancel_internal(grpc_call* call);
 // Given the top call_element, get the call object.
 grpc_call* grpc_call_from_top_element(grpc_call_element* surface_element);
 
-void grpc_call_log_batch(const char* file, int line, gpr_log_severity severity,
-                         const grpc_op* ops, size_t nops);
-
-// Set a context pointer.
-// No thread safety guarantees are made wrt this value.
-// TODO(#9731): add exec_ctx to destroy
-void grpc_call_context_set(grpc_call* call, grpc_context_index elem,
-                           void* value, void (*destroy)(void* value));
-// Get a context pointer.
-void* grpc_call_context_get(grpc_call* call, grpc_context_index elem);
-
-#define GRPC_CALL_LOG_BATCH(sev, ops, nops)        \
-  do {                                             \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace)) { \
-      grpc_call_log_batch(sev, ops, nops);         \
-    }                                              \
+void grpc_call_log_batch(const char* file, int line, const grpc_op* ops,
+                         size_t nops);
+
+void grpc_call_tracer_set(grpc_call* call, grpc_core::ClientCallTracer* tracer);
+
+// Sets call tracer on the call and manages its life by using the call's arena.
+// When using this API, the tracer will be destroyed by grpc_call arena when
+// grpc_call is about to be destroyed. The caller of this API SHOULD NOT
+// manually destroy the tracer. This API is used by Python as a way of using
+// Arena to manage the lifetime of the call tracer. Python needs this API
+// because the tracer was created within a separate shared object library which
+// doesn't have access to core functions like arena->ManagedNew<>.
+void grpc_call_tracer_set_and_manage(grpc_call* call,
+                                     grpc_core::ClientCallTracer* tracer);
+
+void* grpc_call_tracer_get(grpc_call* call);
+
+#define GRPC_CALL_LOG_BATCH(ops, nops)                    \
+  do {                                                    \
+    if (GRPC_TRACE_FLAG_ENABLED(api)) {                   \
+      grpc_call_log_batch(__FILE__, __LINE__, ops, nops); \
+    }                                                     \
   } while (0)
 
 uint8_t grpc_call_is_client(grpc_call* call);
 
-// Get the estimated memory size for a call BESIDES the call stack. Combined
-// with the size of the call stack, it helps estimate the arena size for the
-// initial call.
-size_t grpc_call_get_initial_size_estimate();
+class ClientCallTracerWrapper {
+ public:
+  explicit ClientCallTracerWrapper(grpc_core::ClientCallTracer* tracer)
+      : tracer_(tracer) {}
+
+ private:
+  std::unique_ptr<grpc_core::ClientCallTracer> tracer_;
+};
 
 // Return an appropriate compression algorithm for the requested compression \a
 // level in the context of \a call.
@@ -227,7 +308,4 @@ bool grpc_call_is_trailers_only(const grpc_call* call);
 // Returns the authority for the call, as seen on the server side.
 absl::string_view grpc_call_server_authority(const grpc_call* call);
 
-extern grpc_core::TraceFlag grpc_call_error_trace;
-extern grpc_core::TraceFlag grpc_compression_trace;
-
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_CALL_H

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

@@ -16,24 +16,24 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/api_trace.h"
 
 void grpc_call_details_init(grpc_call_details* details) {
-  GRPC_API_TRACE("grpc_call_details_init(details=%p)", 1, (details));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_call_details_init(details=" << details << ")";
   details->method = grpc_empty_slice();
   details->host = grpc_empty_slice();
 }
 
 void grpc_call_details_destroy(grpc_call_details* details) {
-  GRPC_API_TRACE("grpc_call_details_destroy(details=%p)", 1, (details));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_call_details_destroy(details=" << details << ")";
   grpc_core::ExecCtx exec_ctx;
   grpc_core::CSliceUnref(details->method);
   grpc_core::CSliceUnref(details->host);

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 #include <stddef.h>
 
@@ -30,12 +28,12 @@
 
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/call.h"
+#include "src/core/util/string.h"
 
 static void add_metadata(const grpc_metadata* md, size_t count,
                          std::vector<std::string>* b) {
@@ -107,10 +105,10 @@ static std::string grpc_op_string(const grpc_op* op) {
   return absl::StrJoin(parts, "");
 }
 
-void grpc_call_log_batch(const char* file, int line, gpr_log_severity severity,
-                         const grpc_op* ops, size_t nops) {
+void grpc_call_log_batch(const char* file, int line, const grpc_op* ops,
+                         size_t nops) {
   for (size_t i = 0; i < nops; i++) {
-    gpr_log(file, line, severity, "ops[%" PRIuPTR "]: %s", i,
-            grpc_op_string(&ops[i]).c_str());
+    LOG(INFO).AtLocation(file, line)
+        << "ops[" << i << "]: " << grpc_op_string(&ops[i]);
   }
 }

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

@@ -19,12 +19,11 @@
 #ifndef GRPC_SRC_CORE_LIB_SURFACE_CALL_TEST_ONLY_H
 #define GRPC_SRC_CORE_LIB_SURFACE_CALL_TEST_ONLY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <grpc/grpc.h>
 #include <grpc/impl/compression_types.h>
+#include <grpc/support/port_platform.h>
 
 /// Return the message compression algorithm from \a call.
 ///