grpc 1.60.2 → 1.61.0.pre2

data/src/core/ext/transport/chttp2/transport/writing.cc

@@ -34,6 +34,7 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
+#include <grpc/support/time.h>
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
@@ -217,15 +218,12 @@ static void report_stall(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
         ":peer_initwin=%d:t_win=%" PRId64 ":s_win=%d:s_delta=%" PRId64 "]",
         std::string(t->peer_string.as_string_view()).c_str(), t, s->id, staller,
         s->flow_controlled_buffer.length, s->flow_controlled_bytes_flowed,
-        t->settings[GRPC_ACKED_SETTINGS]
-                   [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE],
+        t->settings.acked().initial_window_size(),
         t->flow_control.remote_window(),
         static_cast<uint32_t>(std::max(
-            int64_t{0},
-            s->flow_control.remote_window_delta() +
-                static_cast<int64_t>(
-                    t->settings[GRPC_PEER_SETTINGS]
-                               [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE]))),
+            int64_t{0}, s->flow_control.remote_window_delta() +
+                            static_cast<int64_t>(
+                                t->settings.peer().initial_window_size()))),
         s->flow_control.remote_window_delta());
   }
 }
@@ -265,23 +263,13 @@ class WriteContext {
   }
 
   void FlushSettings() {
-    const bool dirty =
-        t_->dirtied_local_settings ||
-        t_->settings[GRPC_SENT_SETTINGS]
-                    [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS] !=
-            t_->max_concurrent_streams_policy.AdvertiseValue();
-    if (dirty && !t_->sent_local_settings) {
-      t_->settings[GRPC_LOCAL_SETTINGS]
-                  [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS] =
-          t_->max_concurrent_streams_policy.AdvertiseValue();
-      grpc_slice_buffer_add(
-          t_->outbuf.c_slice_buffer(),
-          grpc_chttp2_settings_create(t_->settings[GRPC_SENT_SETTINGS],
-                                      t_->settings[GRPC_LOCAL_SETTINGS],
-                                      t_->force_send_settings,
-                                      GRPC_CHTTP2_NUM_SETTINGS));
-      if (grpc_core::IsSettingsTimeoutEnabled() &&
-          t_->keepalive_timeout != grpc_core::Duration::Infinity()) {
+    t_->settings.mutable_local().SetMaxConcurrentStreams(
+        t_->max_concurrent_streams_policy.AdvertiseValue());
+    auto update = t_->settings.MaybeSendUpdate();
+    if (update.has_value()) {
+      grpc_core::Http2Frame frame(std::move(*update));
+      Serialize(absl::Span<grpc_core::Http2Frame>(&frame, 1), t_->outbuf);
+      if (t_->keepalive_timeout != grpc_core::Duration::Infinity()) {
         GPR_ASSERT(
             t_->settings_ack_watchdog ==
             grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid);
@@ -294,9 +282,6 @@ class WriteContext {
               grpc_chttp2_settings_timeout(std::move(t));
             });
       }
-      t_->force_send_settings = false;
-      t_->dirtied_local_settings = false;
-      t_->sent_local_settings = true;
       t_->flow_control.FlushedSettings();
       t_->max_concurrent_streams_policy.FlushedSettings();
       grpc_core::global_stats().IncrementHttp2SettingsWrites();
@@ -336,8 +321,7 @@ class WriteContext {
 
   void EnactHpackSettings() {
     t_->hpack_compressor.SetMaxTableSize(
-        t_->settings[GRPC_PEER_SETTINGS]
-                    [GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE]);
+        t_->settings.peer().header_table_size());
   }
 
   void UpdateStreamsNoLongerStalled() {
@@ -410,17 +394,14 @@ class DataSendContext {
     return static_cast<uint32_t>(std::max(
         int64_t{0},
         s_->flow_control.remote_window_delta() +
-            static_cast<int64_t>(
-                t_->settings[GRPC_PEER_SETTINGS]
-                            [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE])));
+            static_cast<int64_t>(t_->settings.peer().initial_window_size())));
   }
 
   uint32_t max_outgoing() const {
     return grpc_core::Clamp<uint32_t>(
         std::min<int64_t>(
-            {t_->settings[GRPC_PEER_SETTINGS]
-                         [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
-             stream_remote_window(), t_->flow_control.remote_window(),
+            {t_->settings.peer().max_frame_size(), stream_remote_window(),
+             t_->flow_control.remote_window(),
              grpc_core::IsWriteSizeCapEnabled()
                  ? static_cast<int64_t>(write_context_->target_write_size())
                  : std::numeric_limits<uint32_t>::max()}),
@@ -494,14 +475,10 @@ class StreamWriteContext {
           grpc_core::HPackCompressor::EncodeHeaderOptions{
               s_->id,  // stream_id
               false,   // is_eof
-              t_->settings
-                      [GRPC_PEER_SETTINGS]
-                      [GRPC_CHTTP2_SETTINGS_GRPC_ALLOW_TRUE_BINARY_METADATA] !=
-                  0,  // use_true_binary_metadata
-              t_->settings
-                  [GRPC_PEER_SETTINGS]
-                  [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],  // max_frame_size
-              &s_->stats.outgoing                         // stats
+              t_->settings.peer()
+                  .allow_true_binary_metadata(),     // use_true_binary_metadata
+              t_->settings.peer().max_frame_size(),  // max_frame_size
+              &s_->stats.outgoing                    // stats
           },
           *s_->send_initial_metadata, t_->outbuf.c_slice_buffer());
       grpc_chttp2_reset_ping_clock(t_);
@@ -517,7 +494,7 @@ class StreamWriteContext {
     if (s_->call_tracer) {
       s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
           grpc_core::HttpAnnotation::Type::kHeadWritten,
-          grpc_core::Timestamp::Now(), s_->t->flow_control.stats(),
+          gpr_now(GPR_CLOCK_REALTIME), s_->t->flow_control.stats(),
           s_->flow_control.stats()));
     }
   }
@@ -596,14 +573,8 @@ class StreamWriteContext {
       }
       t_->hpack_compressor.EncodeHeaders(
           grpc_core::HPackCompressor::EncodeHeaderOptions{
-              s_->id, true,
-              t_->settings
-                      [GRPC_PEER_SETTINGS]
-                      [GRPC_CHTTP2_SETTINGS_GRPC_ALLOW_TRUE_BINARY_METADATA] !=
-                  0,
-              t_->settings[GRPC_PEER_SETTINGS]
-                          [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
-              &s_->stats.outgoing},
+              s_->id, true, t_->settings.peer().allow_true_binary_metadata(),
+              t_->settings.peer().max_frame_size(), &s_->stats.outgoing},
           *s_->send_trailing_metadata, t_->outbuf.c_slice_buffer());
     }
     write_context_->IncTrailingMetadataWrites();
@@ -649,7 +620,7 @@ class StreamWriteContext {
                                    absl::OkStatus());
     if (s_->call_tracer) {
       s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
-          grpc_core::HttpAnnotation::Type::kEnd, grpc_core::Timestamp::Now(),
+          grpc_core::HttpAnnotation::Type::kEnd, gpr_now(GPR_CLOCK_REALTIME),
           s_->t->flow_control.stats(), s_->flow_control.stats()));
     }
   }
@@ -734,9 +705,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
       t->keepalive_timeout != grpc_core::Duration::Infinity()) {
     // Set ping timeout after finishing write so we don't measure our own send
     // time.
-    const auto timeout = grpc_core::IsSeparatePingFromKeepaliveEnabled()
-                             ? t->ping_timeout
-                             : t->keepalive_timeout;
+    const auto timeout = t->ping_timeout;
     auto id = t->ping_callbacks.OnPingTimeout(
         timeout, t->event_engine.get(), [t = t->Ref()] {
           grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
@@ -750,8 +719,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
               id.value());
     }
 
-    if (grpc_core::IsSeparatePingFromKeepaliveEnabled() &&
-        t->keepalive_incoming_data_wanted &&
+    if (t->keepalive_incoming_data_wanted &&
         t->keepalive_timeout < t->ping_timeout &&
         t->keepalive_ping_timeout_handle !=
             grpc_event_engine::experimental::EventEngine::TaskHandle::

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

@@ -16,31 +16,183 @@
 
 #include "src/core/ext/transport/inproc/inproc_transport.h"
 
+#include <atomic>
+
+#include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/inproc/legacy_inproc_transport.h"
 #include "src/core/lib/experiments/experiments.h"
 #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/surface/server.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
 namespace {
+class InprocServerTransport final : public RefCounted<InprocServerTransport>,
+                                    public Transport,
+                                    public ServerTransport {
+ public:
+  void SetAcceptor(Acceptor* acceptor) override {
+    acceptor_ = acceptor;
+    ConnectionState expect = ConnectionState::kInitial;
+    state_.compare_exchange_strong(expect, ConnectionState::kReady,
+                                   std::memory_order_acq_rel,
+                                   std::memory_order_acquire);
+    MutexLock lock(&state_tracker_mu_);
+    state_tracker_.SetState(GRPC_CHANNEL_READY, absl::OkStatus(),
+                            "accept function set");
+  }
+
+  void Orphan() override { Unref(); }
+
+  FilterStackTransport* filter_stack_transport() override { return nullptr; }
+  ClientTransport* client_transport() override { return nullptr; }
+  ServerTransport* server_transport() override { return this; }
+  absl::string_view GetTransportName() const override { return "inproc"; }
+  void SetPollset(grpc_stream*, grpc_pollset*) override {}
+  void SetPollsetSet(grpc_stream*, grpc_pollset_set*) override {}
+  void PerformOp(grpc_transport_op* op) override {
+    gpr_log(GPR_INFO, "inproc server op: %s",
+            grpc_transport_op_string(op).c_str());
+    if (op->start_connectivity_watch != nullptr) {
+      MutexLock lock(&state_tracker_mu_);
+      state_tracker_.AddWatcher(op->start_connectivity_watch_state,
+                                std::move(op->start_connectivity_watch));
+    }
+    if (op->stop_connectivity_watch != nullptr) {
+      MutexLock lock(&state_tracker_mu_);
+      state_tracker_.RemoveWatcher(op->stop_connectivity_watch);
+    }
+    if (op->set_accept_stream) {
+      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;
+    disconnect_error_ = std::move(error);
+    state_.store(ConnectionState::kDisconnected, std::memory_order_relaxed);
+    MutexLock lock(&state_tracker_mu_);
+    state_tracker_.SetState(GRPC_CHANNEL_SHUTDOWN, disconnect_error_,
+                            "inproc transport disconnected");
+  }
+
+  absl::StatusOr<CallInitiator> AcceptCall(ClientMetadata& md) {
+    switch (state_.load(std::memory_order_acquire)) {
+      case ConnectionState::kInitial:
+        return absl::InternalError(
+            "inproc transport hasn't started accepting calls");
+      case ConnectionState::kDisconnected:
+        return absl::UnavailableError("inproc transport is disconnected");
+      case ConnectionState::kReady:
+        break;
+    }
+    return acceptor_->CreateCall(md, acceptor_->CreateArena());
+  }
+
+ private:
+  enum class ConnectionState : uint8_t { kInitial, kReady, kDisconnected };
+
+  std::atomic<ConnectionState> state_{ConnectionState::kInitial};
+  std::atomic<bool> disconnecting_{false};
+  Acceptor* acceptor_;
+  absl::Status disconnect_error_;
+  Mutex state_tracker_mu_;
+  ConnectivityStateTracker state_tracker_ ABSL_GUARDED_BY(state_tracker_mu_){
+      "inproc_server_transport", GRPC_CHANNEL_CONNECTING};
+};
+
+class InprocClientTransport final : public Transport, public ClientTransport {
+ public:
+  void StartCall(CallHandler call_handler) override {
+    call_handler.SpawnGuarded(
+        "pull_initial_metadata",
+        TrySeq(
+            call_handler.PullClientInitialMetadata(),
+            [server_transport = server_transport_,
+             call_handler](ClientMetadataHandle md) {
+              auto call_initiator = server_transport->AcceptCall(*md);
+              if (!call_initiator.ok()) return call_initiator.status();
+              ForwardCall(call_handler, std::move(*call_initiator),
+                          std::move(md));
+              return absl::OkStatus();
+            },
+            ImmediateOkStatus()));
+  }
+
+  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; }
+  absl::string_view GetTransportName() const override { return "inproc"; }
+  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 {
+    server_transport_->Disconnect(
+        absl::UnavailableError("Client transport closed"));
+  }
+
+  RefCountedPtr<InprocServerTransport> server_transport_ =
+      MakeRefCounted<InprocServerTransport>();
+};
+
 bool UsePromiseBasedTransport() {
   if (!IsPromiseBasedInprocTransportEnabled()) return false;
-  if (!IsPromiseBasedClientCallEnabled()) {
-    gpr_log(GPR_ERROR,
-            "Promise based inproc transport requested but promise based client "
-            "calls are disabled: using legacy implementation.");
-    return false;
-  }
-  if (!IsPromiseBasedServerCallEnabled()) {
-    gpr_log(GPR_ERROR,
-            "Promise based inproc transport requested but promise based server "
-            "calls are disabled: using legacy implementation.");
-    return false;
-  }
+  GPR_ASSERT(IsPromiseBasedClientCallEnabled());
+  GPR_ASSERT(IsPromiseBasedServerCallEnabled());
   return true;
 }
+
+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());
+  intptr_t integer;
+  grpc_status_code status = GRPC_STATUS_INTERNAL;
+  if (grpc_error_get_int(error, StatusIntProperty::kRpcStatus, &integer)) {
+    status = static_cast<grpc_status_code>(integer);
+  }
+  return RefCountedPtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
+      nullptr, status, std::string(why).c_str())));
+}
+
+RefCountedPtr<Channel> MakeInprocChannel(Server* server,
+                                         ChannelArgs client_channel_args) {
+  auto client_transport = MakeOrphanable<InprocClientTransport>();
+  auto server_transport = client_transport->GetServerTransport();
+  auto error =
+      server->SetupTransport(server_transport.get(), nullptr,
+                             server->channel_args()
+                                 .Remove(GRPC_ARG_MAX_CONNECTION_IDLE_MS)
+                                 .Remove(GRPC_ARG_MAX_CONNECTION_AGE_MS),
+                             nullptr);
+  if (!error.ok()) {
+    return MakeLameChannel("Failed to create server channel", std::move(error));
+  }
+  std::ignore = server_transport.release();  // consumed by SetupTransport
+  auto channel = Channel::Create(
+      "inproc",
+      client_channel_args.Set(GRPC_ARG_DEFAULT_AUTHORITY, "inproc.authority"),
+      GRPC_CLIENT_DIRECT_CHANNEL, client_transport.release());
+  if (!channel.ok()) {
+    return MakeLameChannel("Failed to create client channel", channel.status());
+  }
+  return std::move(*channel);
+}
 }  // namespace
 
 }  // namespace grpc_core
@@ -48,8 +200,15 @@ bool UsePromiseBasedTransport() {
 grpc_channel* grpc_inproc_channel_create(grpc_server* server,
                                          const grpc_channel_args* args,
                                          void* reserved) {
+  grpc_core::ApplicationCallbackExecCtx app_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   if (!grpc_core::UsePromiseBasedTransport()) {
     return grpc_legacy_inproc_channel_create(server, args, reserved);
   }
-  grpc_core::Crash("unimplemented");
+  return grpc_core::MakeInprocChannel(grpc_core::Server::FromC(server),
+                                      grpc_core::CoreConfiguration::Get()
+                                          .channel_args_preconditioning()
+                                          .PreconditionChannelArgs(args))
+      .release()
+      ->c_ptr();
 }