grpc 1.69.0 → 1.70.1

data/src/core/ext/transport/chttp2/server/chttp2_server.h

@@ -19,36 +19,212 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_SERVER_CHTTP2_SERVER_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_SERVER_CHTTP2_SERVER_H
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/passive_listener.h>
 #include <grpc/support/port_platform.h>
 
 #include <functional>
 
+#include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/server/server.h"
 
 namespace grpc_core {
 
-// A function to modify channel args for a listening addr:port. Note that this
-// is used to create a security connector for listeners when the servers are
-// configured with a config fetcher. Not invoked if there is no config fetcher
-// added to the server. On failure, the error parameter will be set.
-using Chttp2ServerArgsModifier =
-    std::function<ChannelArgs(const ChannelArgs&, grpc_error_handle*)>;
-
-/// Adds a port to \a server.  Sets \a port_num to the port number.
-/// Takes ownership of \a args.
-grpc_error_handle Chttp2ServerAddPort(
-    Server* server, const char* addr, const ChannelArgs& args,
-    Chttp2ServerArgsModifier connection_args_modifier, int* port_num);
+struct AcceptorDeleter {
+  void operator()(grpc_tcp_server_acceptor* acceptor) const {
+    gpr_free(acceptor);
+  }
+};
 
 class Chttp2ServerListener;
+
+namespace testing {
+class Chttp2ServerListenerTestPeer;
+class ActiveConnectionTestPeer;
+class HandshakingStateTestPeer;
+}  // namespace testing
+
+// New ChttpServerListener used if experiment "server_listener" is enabled
+class NewChttp2ServerListener : public Server::ListenerInterface {
+ public:
+  using AcceptorPtr =
+      std::unique_ptr<grpc_tcp_server_acceptor, AcceptorDeleter>;
+
+  // Keeps state for an individual connection. Lifetime: Internally refcounted
+  // and owned by Server::ListenerState.
+  class ActiveConnection : public LogicalConnection {
+   public:
+    // State for handshake. Lifetime: Owned by ActiveConnection and lasts while
+    // the handshake is ongoing.
+    class HandshakingState : public InternallyRefCounted<HandshakingState> {
+     public:
+      HandshakingState(RefCountedPtr<ActiveConnection> connection_ref,
+                       grpc_tcp_server* tcp_server,
+                       grpc_pollset* accepting_pollset, AcceptorPtr acceptor,
+                       const ChannelArgs& args,
+                       OrphanablePtr<grpc_endpoint> endpoint);
+
+      ~HandshakingState() override;
+
+      void Orphan() override;
+
+      void StartLocked(const ChannelArgs& args);
+
+      void ShutdownLocked(absl::Status status);
+
+     private:
+      friend class grpc_core::testing::HandshakingStateTestPeer;
+
+      void OnTimeoutLocked();
+      static void OnReceiveSettings(void* arg, grpc_error_handle /* error */);
+      void OnHandshakeDoneLocked(absl::StatusOr<HandshakerArgs*> result);
+
+      RefCountedPtr<ActiveConnection> const connection_;
+      grpc_tcp_server* const tcp_server_;
+      grpc_pollset* const accepting_pollset_;
+      const AcceptorPtr acceptor_;
+      grpc_pollset_set* const interested_parties_;
+      Timestamp const deadline_;
+      OrphanablePtr<grpc_endpoint> endpoint_;
+      // Following fields are protected by WorkSerializer.
+      RefCountedPtr<HandshakeManager> handshake_mgr_;
+      // State for enforcing handshake timeout on receiving HTTP/2 settings.
+      absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+          timer_handle_;
+      grpc_closure on_receive_settings_;
+    };
+
+    ActiveConnection(RefCountedPtr<Server::ListenerState> listener_state,
+                     grpc_tcp_server* tcp_server,
+                     grpc_pollset* accepting_pollset, AcceptorPtr acceptor,
+                     const ChannelArgs& args, MemoryOwner memory_owner,
+                     OrphanablePtr<grpc_endpoint> endpoint);
+    void Start(const ChannelArgs& args);
+
+    void SendGoAway() override;
+    void DisconnectImmediately() override;
+
+    void Orphan() override;
+
+    // Needed to be able to grab an external weak ref in
+    // NewChttp2ServerListener::OnAccept()
+    using InternallyRefCounted<LogicalConnection>::RefAsSubclass;
+
+   private:
+    friend class grpc_core::testing::ActiveConnectionTestPeer;
+    friend class grpc_core::testing::HandshakingStateTestPeer;
+
+    static void OnClose(void* arg, grpc_error_handle error);
+
+    void SendGoAwayImplLocked();
+    void DisconnectImmediatelyImplLocked();
+
+    RefCountedPtr<Server::ListenerState> const listener_state_;
+    WorkSerializer work_serializer_;
+    // Following fields are protected by WorkSerializer.
+    // Set by HandshakingState before the handshaking begins and set to a valid
+    // transport when handshaking is done successfully.
+    absl::variant<OrphanablePtr<HandshakingState>,
+                  RefCountedPtr<grpc_chttp2_transport>>
+        state_;
+    grpc_closure on_close_;
+    bool shutdown_ = false;
+  };
+
+  static grpc_error_handle Create(
+      Server* server,
+      const grpc_event_engine::experimental::EventEngine::ResolvedAddress& addr,
+      const ChannelArgs& args, int* port_num);
+
+  static grpc_error_handle CreateWithAcceptor(Server* server, const char* name,
+                                              const ChannelArgs& args);
+
+  static NewChttp2ServerListener* CreateForPassiveListener(
+      Server* server, const ChannelArgs& args,
+      std::shared_ptr<experimental::PassiveListenerImpl> passive_listener);
+
+  // Do not instantiate directly.  Use one of the factory methods above.
+  explicit NewChttp2ServerListener(
+      const ChannelArgs& args,
+      std::shared_ptr<experimental::PassiveListenerImpl> passive_listener =
+          nullptr);
+  ~NewChttp2ServerListener() override;
+
+  void AcceptConnectedEndpoint(
+      std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+          endpoint);
+
+  channelz::ListenSocketNode* channelz_listen_socket_node() const override {
+    return channelz_listen_socket_.get();
+  }
+
+  void SetServerListenerState(
+      RefCountedPtr<Server::ListenerState> listener_state) override {
+    listener_state_ = std::move(listener_state);
+  }
+
+  const grpc_resolved_address* resolved_address() const override {
+    return &resolved_address_;
+  }
+
+  void SetOnDestroyDone(grpc_closure* on_destroy_done) override;
+
+  void Orphan() override;
+
+ private:
+  friend class experimental::PassiveListenerImpl;
+
+  // To allow access to RefCounted<> like interface.
+  friend class RefCountedPtr<NewChttp2ServerListener>;
+
+  friend class grpc_core::testing::Chttp2ServerListenerTestPeer;
+
+  // Should only be called once so as to start the TCP server. This should
+  // only be called by the config fetcher.
+  void Start() override;
+
+  static void OnAccept(void* arg, grpc_endpoint* tcp,
+                       grpc_pollset* accepting_pollset,
+                       grpc_tcp_server_acceptor* acceptor);
+
+  static void TcpServerShutdownComplete(void* arg, grpc_error_handle error);
+
+  static void DestroyListener(Server* /*server*/, void* arg,
+                              grpc_closure* destroy_done);
+
+  grpc_event_engine::experimental::EventEngine* event_engine() const {
+    return listener_state_->server()
+        ->channel_args()
+        .GetObject<grpc_event_engine::experimental::EventEngine>();
+  }
+
+  grpc_tcp_server* tcp_server_ = nullptr;
+  grpc_resolved_address resolved_address_;
+  RefCountedPtr<Server::ListenerState> listener_state_;
+  ChannelArgs args_;
+  Mutex mu_;
+  bool add_port_on_start_ ABSL_GUARDED_BY(mu_) = false;
+  // Signals whether the application has triggered shutdown.
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  grpc_closure tcp_server_shutdown_complete_ ABSL_GUARDED_BY(mu_);
+  grpc_closure* on_destroy_done_ ABSL_GUARDED_BY(mu_) = nullptr;
+  RefCountedPtr<channelz::ListenSocketNode> channelz_listen_socket_;
+  // TODO(yashykt): consider using absl::variant<> to minimize memory usage for
+  // disjoint cases where different fields are used.
+  std::shared_ptr<experimental::PassiveListenerImpl> passive_listener_;
+};
+
 namespace experimental {
 
 // An implementation of the public C++ passive listener interface.
 // The server builder holds a weak_ptr to one of these objects, and the
 // application owns the instance.
+// TODO(yashykt): Move this to C-Core since this should be transport agnostic.
+// Refer to https://github.com/grpc/grpc/pull/37601/files#r1803547924 for
+// details.
 class PassiveListenerImpl final : public PassiveListener {
  public:
   absl::Status AcceptConnectedEndpoint(
@@ -71,7 +247,7 @@ class PassiveListenerImpl final : public PassiveListener {
   Mutex mu_;
   // Data members will be populated when initialized.
   RefCountedPtr<Server> server_;
-  Chttp2ServerListener* listener_;
+  absl::variant<Chttp2ServerListener*, NewChttp2ServerListener*> listener_;
 };
 
 }  // namespace experimental

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

@@ -589,6 +589,7 @@ static void init_keepalive_pings_if_enabled_locked(
 
 // TODO(alishananda): add unit testing as part of chttp2 promise conversion work
 void grpc_chttp2_transport::WriteSecurityFrame(grpc_core::SliceBuffer* data) {
+  grpc_core::ExecCtx exec_ctx;
   combiner->Run(grpc_core::NewClosure(
                     [transport = Ref(), data](grpc_error_handle) mutable {
                       transport->WriteSecurityFrameLocked(data);

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

@@ -39,7 +39,7 @@ absl::Status grpc_chttp2_security_frame_parser_parse(void* parser,
 
   grpc_chttp2_security_frame_parser* p =
       static_cast<grpc_chttp2_security_frame_parser*>(parser);
-  p->payload.Append(grpc_core::Slice(slice));
+  p->payload.Append(grpc_core::Slice(grpc_core::CSliceRef(slice)));
 
   if (is_last) {
     // Send security frame payload to endpoint.
@@ -59,8 +59,6 @@ absl::Status grpc_chttp2_security_frame_parser_begin_frame(
 void grpc_chttp2_security_frame_create(grpc_slice_buffer* payload,
                                        uint32_t length,
                                        grpc_slice_buffer* frame) {
-  // does this frame need padding for security?
-  // do we need to worry about max frame size? it's 16 bytes
   grpc_slice hdr;
   uint8_t* p;
   static const size_t header_size = 9;

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

@@ -25,6 +25,7 @@
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/util/bitset.h"
 
 static const char* stream_list_id_string(grpc_chttp2_stream_list_id id) {
@@ -127,6 +128,26 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
       << "]: add to " << stream_list_id_string(id);
 }
 
+static void stream_list_add_head(grpc_chttp2_transport* t,
+                                 grpc_chttp2_stream* s,
+                                 grpc_chttp2_stream_list_id id) {
+  grpc_chttp2_stream* old_head;
+  CHECK(!s->included.is_set(id));
+  old_head = t->lists[id].head;
+  s->links[id].next = old_head;
+  s->links[id].prev = nullptr;
+  if (old_head) {
+    old_head->links[id].prev = s;
+  } else {
+    t->lists[id].tail = s;
+  }
+  t->lists[id].head = s;
+  s->included.set(id);
+  GRPC_TRACE_LOG(http2_stream_state, INFO)
+      << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
+      << "]: add to " << stream_list_id_string(id);
+}
+
 static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                             grpc_chttp2_stream_list_id id) {
   if (s->included.is_set(id)) {
@@ -136,11 +157,24 @@ static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
   return true;
 }
 
+static bool stream_list_prepend(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
+                                grpc_chttp2_stream_list_id id) {
+  if (s->included.is_set(id)) {
+    return false;
+  }
+  stream_list_add_head(t, s, id);
+  return true;
+}
+
 // wrappers for specializations
 
 bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport* t,
                                           grpc_chttp2_stream* s) {
   CHECK_NE(s->id, 0u);
+  if (grpc_core::IsPrioritizeFinishedRequestsEnabled() &&
+      s->send_trailing_metadata != nullptr) {
+    return stream_list_prepend(t, s, GRPC_CHTTP2_LIST_WRITABLE);
+  }
   return stream_list_add(t, s, GRPC_CHTTP2_LIST_WRITABLE);
 }
 
@@ -185,7 +219,12 @@ void grpc_chttp2_list_remove_waiting_for_concurrency(grpc_chttp2_transport* t,
 
 void grpc_chttp2_list_add_stalled_by_transport(grpc_chttp2_transport* t,
                                                grpc_chttp2_stream* s) {
-  stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
+  if (grpc_core::IsPrioritizeFinishedRequestsEnabled() &&
+      s->send_trailing_metadata != nullptr) {
+    stream_list_prepend(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
+  } else {
+    stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
+  }
 }
 
 bool grpc_chttp2_list_pop_stalled_by_transport(grpc_chttp2_transport* t,

data/src/core/ext/upb-gen/envoy/admin/v3/config_dump_shared.upb.h

@@ -52,7 +52,9 @@ typedef enum {
   envoy_admin_v3_REQUESTED = 1,
   envoy_admin_v3_DOES_NOT_EXIST = 2,
   envoy_admin_v3_ACKED = 3,
-  envoy_admin_v3_NACKED = 4
+  envoy_admin_v3_NACKED = 4,
+  envoy_admin_v3_RECEIVED_ERROR = 5,
+  envoy_admin_v3_TIMEOUT = 6
 } envoy_admin_v3_ClientResourceStatus;