grpc 1.64.3 → 1.65.0

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -28,6 +28,7 @@
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/surface/channel_create.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server.h"
@@ -35,11 +36,22 @@
 namespace grpc_core {
 
 namespace {
-class InprocServerTransport final : public RefCounted<InprocServerTransport>,
-                                    public ServerTransport {
+class InprocClientTransport;
+
+class InprocServerTransport final : public ServerTransport {
  public:
-  void SetAcceptor(Acceptor* acceptor) override {
-    acceptor_ = acceptor;
+  explicit InprocServerTransport(const ChannelArgs& args)
+      : event_engine_(
+            args.GetObjectRef<grpc_event_engine::experimental::EventEngine>()),
+        call_arena_allocator_(MakeRefCounted<CallArenaAllocator>(
+            args.GetObject<ResourceQuota>()
+                ->memory_quota()
+                ->CreateMemoryAllocator("inproc_server"),
+            1024)) {}
+
+  void SetCallDestination(
+      RefCountedPtr<UnstartedCallDestination> unstarted_call_handler) override {
+    unstarted_call_handler_ = unstarted_call_handler;
     ConnectionState expect = ConnectionState::kInitial;
     state_.compare_exchange_strong(expect, ConnectionState::kReady,
                                    std::memory_order_acq_rel,
@@ -73,7 +85,6 @@ class InprocServerTransport final : public RefCounted<InprocServerTransport>,
       Crash("set_accept_stream not supported on inproc transport");
     }
   }
-  grpc_endpoint* GetEndpoint() override { return nullptr; }
 
   void Disconnect(absl::Status error) {
     if (disconnecting_.exchange(true, std::memory_order_relaxed)) return;
@@ -94,43 +105,54 @@ class InprocServerTransport final : public RefCounted<InprocServerTransport>,
       case ConnectionState::kReady:
         break;
     }
-    return acceptor_->CreateCall(std::move(md), acceptor_->CreateArena());
+    auto server_call = MakeCallPair(std::move(md), event_engine_.get(),
+                                    call_arena_allocator_->MakeArena());
+    unstarted_call_handler_->StartCall(std::move(server_call.handler));
+    return std::move(server_call.initiator);
   }
 
+  OrphanablePtr<InprocClientTransport> MakeClientTransport();
+
  private:
   enum class ConnectionState : uint8_t { kInitial, kReady, kDisconnected };
 
   std::atomic<ConnectionState> state_{ConnectionState::kInitial};
   std::atomic<bool> disconnecting_{false};
-  Acceptor* acceptor_;
+  RefCountedPtr<UnstartedCallDestination> unstarted_call_handler_;
   absl::Status disconnect_error_;
   Mutex state_tracker_mu_;
   ConnectivityStateTracker state_tracker_ ABSL_GUARDED_BY(state_tracker_mu_){
       "inproc_server_transport", GRPC_CHANNEL_CONNECTING};
+  const std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+      event_engine_;
+  const RefCountedPtr<CallArenaAllocator> call_arena_allocator_;
 };
 
 class InprocClientTransport final : public ClientTransport {
  public:
-  void StartCall(CallHandler call_handler) override {
-    call_handler.SpawnGuarded(
+  explicit InprocClientTransport(
+      RefCountedPtr<InprocServerTransport> server_transport)
+      : server_transport_(std::move(server_transport)) {}
+
+  void StartCall(CallHandler child_call_handler) override {
+    child_call_handler.SpawnGuarded(
         "pull_initial_metadata",
-        TrySeq(call_handler.PullClientInitialMetadata(),
+        TrySeq(child_call_handler.PullClientInitialMetadata(),
                [server_transport = server_transport_,
-                call_handler](ClientMetadataHandle md) {
-                 auto call_initiator =
+                child_call_handler](ClientMetadataHandle md) {
+                 auto server_call_initiator =
                      server_transport->AcceptCall(std::move(md));
-                 if (!call_initiator.ok()) return call_initiator.status();
-                 ForwardCall(call_handler, std::move(*call_initiator));
+                 if (!server_call_initiator.ok()) {
+                   return server_call_initiator.status();
+                 }
+                 ForwardCall(child_call_handler,
+                             std::move(*server_call_initiator));
                  return absl::OkStatus();
                }));
   }
 
   void Orphan() override { delete this; }
 
-  OrphanablePtr<Transport> GetServerTransport() {
-    return OrphanablePtr<Transport>(server_transport_->Ref().release());
-  }
-
   FilterStackTransport* filter_stack_transport() override { return nullptr; }
   ClientTransport* client_transport() override { return this; }
   ServerTransport* server_transport() override { return nullptr; }
@@ -138,7 +160,6 @@ class InprocClientTransport final : public ClientTransport {
   void SetPollset(grpc_stream*, grpc_pollset*) override {}
   void SetPollsetSet(grpc_stream*, grpc_pollset_set*) override {}
   void PerformOp(grpc_transport_op*) override { Crash("unimplemented"); }
-  grpc_endpoint* GetEndpoint() override { return nullptr; }
 
  private:
   ~InprocClientTransport() override {
@@ -146,18 +167,20 @@ class InprocClientTransport final : public ClientTransport {
         absl::UnavailableError("Client transport closed"));
   }
 
-  RefCountedPtr<InprocServerTransport> server_transport_ =
-      MakeRefCounted<InprocServerTransport>();
+  const RefCountedPtr<InprocServerTransport> server_transport_;
 };
 
 bool UsePromiseBasedTransport() {
-  if (!IsPromiseBasedInprocTransportEnabled()) return false;
-  CHECK(IsPromiseBasedClientCallEnabled());
-  CHECK(IsPromiseBasedServerCallEnabled());
-  return true;
+  return IsPromiseBasedInprocTransportEnabled();
+}
+
+OrphanablePtr<InprocClientTransport>
+InprocServerTransport::MakeClientTransport() {
+  return MakeOrphanable<InprocClientTransport>(
+      RefAsSubclass<InprocServerTransport>());
 }
 
-OrphanablePtr<Channel> MakeLameChannel(absl::string_view why,
+RefCountedPtr<Channel> MakeLameChannel(absl::string_view why,
                                        absl::Status error) {
   gpr_log(GPR_ERROR, "%s: %s", std::string(why).c_str(),
           std::string(error.message()).c_str());
@@ -166,13 +189,13 @@ OrphanablePtr<Channel> MakeLameChannel(absl::string_view why,
   if (grpc_error_get_int(error, StatusIntProperty::kRpcStatus, &integer)) {
     status = static_cast<grpc_status_code>(integer);
   }
-  return OrphanablePtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
+  return RefCountedPtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
       nullptr, status, std::string(why).c_str())));
 }
 
-OrphanablePtr<Channel> MakeInprocChannel(Server* server,
+RefCountedPtr<Channel> MakeInprocChannel(Server* server,
                                          ChannelArgs client_channel_args) {
-  auto transports = MakeInProcessTransportPair();
+  auto transports = MakeInProcessTransportPair(server->channel_args());
   auto client_transport = std::move(transports.first);
   auto server_transport = std::move(transports.second);
   auto error =
@@ -197,9 +220,10 @@ OrphanablePtr<Channel> MakeInprocChannel(Server* server,
 }  // namespace
 
 std::pair<OrphanablePtr<Transport>, OrphanablePtr<Transport>>
-MakeInProcessTransportPair() {
-  auto client_transport = MakeOrphanable<InprocClientTransport>();
-  auto server_transport = client_transport->GetServerTransport();
+MakeInProcessTransportPair(const ChannelArgs& server_channel_args) {
+  auto server_transport =
+      MakeOrphanable<InprocServerTransport>(server_channel_args);
+  auto client_transport = server_transport->MakeClientTransport();
   return std::make_pair(std::move(client_transport),
                         std::move(server_transport));
 }

data/src/core/ext/transport/inproc/inproc_transport.h

@@ -25,12 +25,10 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
                                          const grpc_channel_args* args,
                                          void* reserved);
 
-extern grpc_core::TraceFlag grpc_inproc_trace;
-
 namespace grpc_core {
 
 std::pair<OrphanablePtr<Transport>, OrphanablePtr<Transport>>
-MakeInProcessTransportPair();
+MakeInProcessTransportPair(const ChannelArgs& server_channel_args);
 
 }
 

data/src/core/ext/transport/inproc/legacy_inproc_transport.cc

@@ -28,6 +28,7 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -68,11 +69,11 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server.h"
 
-#define INPROC_LOG(...)                               \
-  do {                                                \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) { \
-      gpr_log(__VA_ARGS__);                           \
-    }                                                 \
+#define INPROC_LOG(...)                    \
+  do {                                     \
+    if (GRPC_TRACE_FLAG_ENABLED(inproc)) { \
+      gpr_log(__VA_ARGS__);                \
+    }                                      \
   } while (0)
 
 namespace {
@@ -134,7 +135,6 @@ struct inproc_transport final : public grpc_core::FilterStackTransport {
   void SetPollsetSet(grpc_stream* stream,
                      grpc_pollset_set* pollset_set) override;
   void PerformOp(grpc_transport_op* op) override;
-  grpc_endpoint* GetEndpoint() override;
 
   size_t SizeOfStream() const override;
   bool HackyDisableStreamOpBatchCoalescingInConnectedChannel() const override {
@@ -319,7 +319,7 @@ void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
   std::string prefix = absl::StrCat(
       "INPROC:", is_initial ? "HDR:" : "TRL:", is_client ? "CLI:" : "SVR:");
   md_batch->Log([&prefix](absl::string_view key, absl::string_view value) {
-    gpr_log(GPR_INFO, "%s", absl::StrCat(prefix, key, ": ", value).c_str());
+    LOG(INFO) << absl::StrCat(prefix, key, ": ", value);
   });
 }
 
@@ -352,7 +352,7 @@ class CopySink {
 
 void fill_in_metadata(inproc_stream* s, const grpc_metadata_batch* metadata,
                       grpc_metadata_batch* out_md, bool* markfilled) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(inproc)) {
     log_metadata(metadata, s->t->is_client,
                  metadata->get_pointer(grpc_core::WaitForReady()) != nullptr);
   }
@@ -949,7 +949,7 @@ void inproc_transport::PerformStreamOp(grpc_stream* gs,
   gpr_mu* mu = &s->t->mu->mu;  // save aside in case s gets closed
   gpr_mu_lock(mu);
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(inproc)) {
     if (op->send_initial_metadata) {
       log_metadata(op->payload->send_initial_metadata.send_initial_metadata,
                    s->t->is_client, true);
@@ -1213,8 +1213,6 @@ void inproc_transport::SetPollsetSet(grpc_stream* /*gs*/,
   // Nothing to do here
 }
 
-grpc_endpoint* inproc_transport::GetEndpoint() { return nullptr; }
-
 //******************************************************************************
 // Main inproc transport functions
 //
@@ -1268,8 +1266,8 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
         "inproc", client_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
     if (!new_channel.ok()) {
       CHECK(!channel);
-      gpr_log(GPR_ERROR, "Failed to create client channel: %s",
-              grpc_core::StatusToString(error).c_str());
+      LOG(ERROR) << "Failed to create client channel: "
+                 << grpc_core::StatusToString(error);
       intptr_t integer;
       grpc_status_code status = GRPC_STATUS_INTERNAL;
       if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
@@ -1286,8 +1284,8 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
     }
   } else {
     CHECK(!channel);
-    gpr_log(GPR_ERROR, "Failed to create server channel: %s",
-            grpc_core::StatusToString(error).c_str());
+    LOG(ERROR) << "Failed to create server channel: "
+               << grpc_core::StatusToString(error);
     intptr_t integer;
     grpc_status_code status = GRPC_STATUS_INTERNAL;
     if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,

data/src/core/ext/transport/inproc/legacy_inproc_transport.h

@@ -24,6 +24,4 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
                                                 const grpc_channel_args* args,
                                                 void* reserved);
 
-extern grpc_core::TraceFlag grpc_inproc_trace;
-
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_LEGACY_INPROC_TRANSPORT_H

data/src/core/handshaker/handshaker.cc

@@ -43,8 +43,6 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_handshaker_trace(false, "handshaker");
-
 namespace {
 
 using ::grpc_event_engine::experimental::EventEngine;
@@ -62,13 +60,12 @@ std::string HandshakerArgsString(HandshakerArgs* args) {
 }  // namespace
 
 HandshakeManager::HandshakeManager()
-    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)
-                     ? "HandshakeManager"
-                     : nullptr) {}
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(handshaker) ? "HandshakeManager"
+                                                     : nullptr) {}
 
 void HandshakeManager::Add(RefCountedPtr<Handshaker> handshaker) {
   MutexLock lock(&mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
     gpr_log(
         GPR_INFO,
         "handshake_manager %p: adding handshaker %s [%p] at index %" PRIuPTR,
@@ -94,7 +91,7 @@ void HandshakeManager::Shutdown(grpc_error_handle why) {
 // on_handshake_done callback.
 // Returns true if we've scheduled the on_handshake_done callback.
 bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
     gpr_log(GPR_INFO,
             "handshake_manager %p: error=%s shutdown=%d index=%" PRIuPTR
             ", args=%s",
@@ -113,11 +110,6 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
       // a shutdown call while this callback was sitting on the ExecCtx
       // with no error.
       if (args_.endpoint != nullptr) {
-        // TODO(roth): It is currently necessary to shutdown endpoints
-        // before destroying then, even when we know that there are no
-        // pending read/write callbacks.  This should be fixed, at which
-        // point this can be removed.
-        grpc_endpoint_shutdown(args_.endpoint, error);
         grpc_endpoint_destroy(args_.endpoint);
         args_.endpoint = nullptr;
       }
@@ -128,7 +120,7 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
       }
       args_.args = ChannelArgs();
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
       gpr_log(GPR_INFO,
               "handshake_manager %p: handshaking complete -- scheduling "
               "on_handshake_done with error=%s",
@@ -141,7 +133,7 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
     is_shutdown_ = true;
   } else {
     auto handshaker = handshakers_[index_];
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
       gpr_log(
           GPR_INFO,
           "handshake_manager %p: calling handshaker %s [%p] at index %" PRIuPTR,

data/src/core/handshaker/http_connect/http_connect_handshaker.cc

@@ -41,18 +41,18 @@
 #include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/http/format_request.h"
-#include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/util/http_client/format_request.h"
+#include "src/core/util/http_client/parser.h"
+#include "src/core/util/string.h"
 
 namespace grpc_core {
 
@@ -80,8 +80,7 @@ class HttpConnectHandshaker : public Handshaker {
   Mutex mu_;
 
   bool is_shutdown_ ABSL_GUARDED_BY(mu_) = false;
-  // Endpoint and read buffer to destroy after a shutdown.
-  grpc_endpoint* endpoint_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
+  // Read buffer to destroy after a shutdown.
   grpc_slice_buffer* read_buffer_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
 
   // State saved while performing the handshake.
@@ -97,9 +96,6 @@ class HttpConnectHandshaker : public Handshaker {
 };
 
 HttpConnectHandshaker::~HttpConnectHandshaker() {
-  if (endpoint_to_destroy_ != nullptr) {
-    grpc_endpoint_destroy(endpoint_to_destroy_);
-  }
   if (read_buffer_to_destroy_ != nullptr) {
     grpc_slice_buffer_destroy(read_buffer_to_destroy_);
     gpr_free(read_buffer_to_destroy_);
@@ -112,8 +108,6 @@ HttpConnectHandshaker::~HttpConnectHandshaker() {
 // Set args fields to nullptr, saving the endpoint and read buffer for
 // later destruction.
 void HttpConnectHandshaker::CleanupArgsForFailureLocked() {
-  endpoint_to_destroy_ = args_->endpoint;
-  args_->endpoint = nullptr;
   read_buffer_to_destroy_ = args_->read_buffer;
   args_->read_buffer = nullptr;
   args_->args = ChannelArgs();
@@ -129,13 +123,10 @@ void HttpConnectHandshaker::HandshakeFailedLocked(grpc_error_handle error) {
     error = GRPC_ERROR_CREATE("Handshaker shutdown");
   }
   if (!is_shutdown_) {
-    // TODO(ctiller): It is currently necessary to shutdown endpoints
-    // before destroying them, even if we know that there are no
-    // pending read/write callbacks.  This should be fixed, at which
-    // point this can be removed.
-    grpc_endpoint_shutdown(args_->endpoint, error);
     // Not shutting down, so the handshake failed.  Clean up before
     // invoking the callback.
+    grpc_endpoint_destroy(args_->endpoint);
+    args_->endpoint = nullptr;
     CleanupArgsForFailureLocked();
     // Set shutdown to true so that subsequent calls to
     // http_connect_handshaker_shutdown() do nothing.
@@ -276,12 +267,13 @@ done:
 // Public handshaker methods
 //
 
-void HttpConnectHandshaker::Shutdown(grpc_error_handle why) {
+void HttpConnectHandshaker::Shutdown(grpc_error_handle /*why*/) {
   {
     MutexLock lock(&mu_);
     if (!is_shutdown_) {
       is_shutdown_ = true;
-      grpc_endpoint_shutdown(args_->endpoint, why);
+      grpc_endpoint_destroy(args_->endpoint);
+      args_->endpoint = nullptr;
       CleanupArgsForFailureLocked();
     }
   }

data/src/core/handshaker/http_connect/http_proxy_mapper.cc

@@ -26,6 +26,7 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
@@ -47,12 +48,12 @@
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/uri/uri_parser.h"
+#include "src/core/util/string.h"
 
 namespace grpc_core {
 namespace {
@@ -150,7 +151,7 @@ absl::optional<std::string> GetHttpProxyServer(
     // User cred found
     *user_cred = authority_strs[0];
     proxy_name = authority_strs[1];
-    gpr_log(GPR_DEBUG, "userinfo found in proxy URI");
+    VLOG(2) << "userinfo found in proxy URI";
   } else {
     // Bad authority
     proxy_name = absl::nullopt;