grpc 1.69.0 → 1.71.0

data/src/core/server/server.h

@@ -31,6 +31,7 @@
 #include <functional>
 #include <list>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -42,7 +43,6 @@
 #include "absl/random/random.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
@@ -53,7 +53,9 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/resource_quota/connection_quota.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
@@ -74,10 +76,48 @@
   "grpc.server.max_pending_requests_hard_limit"
 
 namespace grpc_core {
+
+class ServerConfigFetcher
+    : public CppImplOf<ServerConfigFetcher, grpc_server_config_fetcher> {
+ public:
+  class ConnectionManager
+      : public grpc_core::DualRefCounted<ConnectionManager> {
+   public:
+    virtual absl::StatusOr<grpc_core::ChannelArgs>
+    UpdateChannelArgsForConnection(const grpc_core::ChannelArgs& args,
+                                   grpc_endpoint* tcp) = 0;
+  };
+
+  class WatcherInterface {
+   public:
+    virtual ~WatcherInterface() = default;
+    // UpdateConnectionManager() is invoked by the config fetcher when a new
+    // config is available. Implementations should update the connection manager
+    // and start serving if not already serving.
+    virtual void UpdateConnectionManager(
+        grpc_core::RefCountedPtr<ConnectionManager> manager) = 0;
+    // Implementations should stop serving when this is called. Serving should
+    // only resume when UpdateConfig() is invoked.
+    virtual void StopServing() = 0;
+  };
+
+  virtual ~ServerConfigFetcher() = default;
+
+  virtual void StartWatch(std::string listening_address,
+                          std::unique_ptr<WatcherInterface> watcher) = 0;
+  virtual void CancelWatch(WatcherInterface* watcher) = 0;
+  virtual grpc_pollset_set* interested_parties() = 0;
+};
+
 namespace experimental {
 class PassiveListenerImpl;
 }  // namespace experimental
 
+namespace testing {
+class ServerTestPeer;
+class ListenerStateTestPeer;
+}  // namespace testing
+
 class Server : public ServerInterface,
                public InternallyRefCounted<Server>,
                public CppImplOf<Server, grpc_server> {
@@ -110,27 +150,171 @@ class Server : public ServerInterface,
     grpc_completion_queue* cq;
   };
 
+  class ListenerState;
+
   /// Interface for listeners.
-  /// Implementations must override the Orphan() method, which should stop
-  /// listening and initiate destruction of the listener.
   class ListenerInterface : public InternallyRefCounted<ListenerInterface> {
    public:
+    // State for a connection that is being managed by this listener.
+    // The LogicalConnection interface helps the server keep track of
+    // connections during handshake. If the server uses a config fetcher, the
+    // connection continues to be tracked by the server to drain connections on
+    // a config update. If not, the server stops the tracking after handshake is
+    // done. As such, implementations of `LogicalConnection` should cancel the
+    // handshake on `Orphan` if still in progress, but not close down the
+    // transport.
+    // Implementations are responsible for informing ListenerState about the
+    // following stages of a connection -
+    // 1) Invoke AddLogicalConnection() on accepting a new connection. Do not
+    // invoke if the connection is going to be closed immediately.
+    // 2) Invoke OnHandshakeDone() (irrespective of error) once handshake is
+    // done. No need to invoke if `RemoveLogicalConnection()` has already been
+    // invoked.
+    // 3) Invoke RemoveLogicalConnection() when the connection is closed. Do not
+    // invoke if the connection was never added.
+    // TODO(yashykt): In the case where there is no config fetcher, we remove
+    // the connection from our map and instead use `ChannelData` to keep track
+    // of the connections. This is much cheaper (8 bytes per connection) as
+    // compared to implementations of LogicalConnection which can be more than
+    // 24 bytes based on the chttp2 implementation. This complexity causes
+    // weirdness for our interfaces. Figure out a way to combine these two
+    // tracking systems, without increasing memory utilization.
+    class LogicalConnection : public InternallyRefCounted<LogicalConnection> {
+     public:
+      explicit LogicalConnection(const char* trace = nullptr)
+          : InternallyRefCounted(trace) {}
+      ~LogicalConnection() override = default;
+
+      // The following two methods are called in the context of a server config
+      // event.
+      virtual void SendGoAway() = 0;
+      virtual void DisconnectImmediately() = 0;
+    };
+
+    explicit ListenerInterface(const char* trace = nullptr)
+        : InternallyRefCounted(trace) {}
     ~ListenerInterface() override = default;
 
-    /// Starts listening. This listener may refer to the pollset object beyond
-    /// this call, so it is a pointer rather than a reference.
-    virtual void Start(Server* server,
-                       const std::vector<grpc_pollset*>* pollsets) = 0;
+    /// Starts listening.
+    virtual void Start() = 0;
 
     /// Returns the channelz node for the listen socket, or null if not
     /// supported.
     virtual channelz::ListenSocketNode* channelz_listen_socket_node() const = 0;
 
+    virtual void SetServerListenerState(
+        RefCountedPtr<ListenerState> listener_state) = 0;
+
+    virtual const grpc_resolved_address* resolved_address() const = 0;
+
     /// Sets a closure to be invoked by the listener when its destruction
     /// is complete.
     virtual void SetOnDestroyDone(grpc_closure* on_destroy_done) = 0;
   };
 
+  // Implements the connection management and config fetching mechanism for
+  // listeners.
+  // Note that an alternative implementation would have been to combine the
+  // ListenerInterface and ListenerState into a single parent class, but
+  // they are being separated to make code simpler to understand.
+  class ListenerState : public RefCounted<ListenerState> {
+   public:
+    explicit ListenerState(RefCountedPtr<Server> server,
+                           OrphanablePtr<ListenerInterface> l);
+
+    void Start();
+
+    void Stop();
+
+    ListenerInterface* listener() { return listener_.get(); }
+
+    Server* server() const { return server_.get(); }
+
+    // Adds a LogicalConnection to the listener and updates the channel args if
+    // needed, and returns ChannelArgs if successful.
+    std::optional<ChannelArgs> AddLogicalConnection(
+        OrphanablePtr<ListenerInterface::LogicalConnection> connection,
+        const ChannelArgs& args, grpc_endpoint* endpoint)
+        ABSL_LOCKS_EXCLUDED(mu_);
+
+    void OnHandshakeDone(ListenerInterface::LogicalConnection* connection);
+
+    // Removes the logical connection from being tracked. This could happen for
+    // reasons such as the connection being closed, or the connection has been
+    // established (including handshake) and doesn't have a server config
+    // fetcher.
+    void RemoveLogicalConnection(
+        ListenerInterface::LogicalConnection* connection);
+
+    const MemoryQuotaRefPtr& memory_quota() const { return memory_quota_; }
+
+    const ConnectionQuotaRefPtr& connection_quota() const {
+      return connection_quota_;
+    }
+
+    grpc_event_engine::experimental::EventEngine* event_engine() const {
+      return event_engine_;
+    }
+
+   private:
+    friend class grpc_core::testing::ListenerStateTestPeer;
+
+    class ConfigFetcherWatcher : public ServerConfigFetcher::WatcherInterface {
+     public:
+      explicit ConfigFetcherWatcher(ListenerState* listener_state)
+          : listener_state_(listener_state) {}
+
+      void UpdateConnectionManager(
+          RefCountedPtr<ServerConfigFetcher::ConnectionManager>
+              connection_manager) override;
+
+      void StopServing() override;
+
+     private:
+      // This doesn't need to be ref-counted since we start and stop config
+      // fetching as part of starting and stopping the listener.
+      ListenerState* const listener_state_;
+    };
+
+    struct ConnectionsToBeDrained {
+      absl::flat_hash_set<OrphanablePtr<ListenerInterface::LogicalConnection>>
+          connections;
+      grpc_core::Timestamp timestamp;
+    };
+
+    void DrainConnectionsLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+    void OnDrainGraceTimer();
+
+    void MaybeStartNewGraceTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+    void RemoveConnectionsToBeDrainedOnEmptyLocked(
+        std::deque<ConnectionsToBeDrained>::iterator it)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+    RefCountedPtr<Server> const server_;
+    MemoryQuotaRefPtr const memory_quota_;
+    ConnectionQuotaRefPtr connection_quota_;
+    grpc_event_engine::experimental::EventEngine* const event_engine_;
+    OrphanablePtr<ListenerInterface> listener_;
+    grpc_closure destroy_done_;
+    ConfigFetcherWatcher* config_fetcher_watcher_ = nullptr;
+    Mutex mu_;  // We could share this mutex with Listener implementations. It's
+                // a tradeoff between increased memory requirement and more
+                // granular critical regions.
+    RefCountedPtr<ServerConfigFetcher::ConnectionManager> connection_manager_
+        ABSL_GUARDED_BY(mu_);
+    bool is_serving_ ABSL_GUARDED_BY(mu_) = false;
+    bool started_ ABSL_GUARDED_BY(mu_) = false;
+    absl::flat_hash_set<OrphanablePtr<ListenerInterface::LogicalConnection>>
+        connections_ ABSL_GUARDED_BY(mu_);
+    std::deque<ConnectionsToBeDrained> connections_to_be_drained_list_
+        ABSL_GUARDED_BY(mu_);
+    grpc_event_engine::experimental::EventEngine::TaskHandle
+        drain_grace_timer_handle_ ABSL_GUARDED_BY(mu_) =
+            grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
+  };
+
   explicit Server(const ChannelArgs& args);
   ~Server() override;
 
@@ -146,16 +330,15 @@ class Server : public ServerInterface,
   // result is valid for the lifetime of the server.
   const std::vector<grpc_pollset*>& pollsets() const { return pollsets_; }
 
-  grpc_server_config_fetcher* config_fetcher() const {
-    return config_fetcher_.get();
-  }
+  ServerConfigFetcher* config_fetcher() const { return config_fetcher_.get(); }
 
   ServerCallTracerFactory* server_call_tracer_factory() const override {
     return server_call_tracer_factory_;
   }
 
-  void set_config_fetcher(
-      std::unique_ptr<grpc_server_config_fetcher> config_fetcher);
+  void set_config_fetcher(std::unique_ptr<ServerConfigFetcher> config_fetcher) {
+    config_fetcher_ = std::move(config_fetcher);
+  }
 
   bool HasOpenConnections() ABSL_LOCKS_EXCLUDED(mu_global_);
 
@@ -173,7 +356,8 @@ class Server : public ServerInterface,
   grpc_error_handle SetupTransport(
       Transport* transport, grpc_pollset* accepting_pollset,
       const ChannelArgs& args,
-      const RefCountedPtr<channelz::SocketNode>& socket_node);
+      const RefCountedPtr<channelz::SocketNode>& socket_node)
+      ABSL_LOCKS_EXCLUDED(mu_global_);
 
   void RegisterCompletionQueue(grpc_completion_queue* cq);
 
@@ -225,6 +409,9 @@ class Server : public ServerInterface,
       grpc_core::Server* server, grpc_server_credentials* credentials,
       std::shared_ptr<grpc_core::experimental::PassiveListenerImpl>
           passive_listener);
+
+  friend class grpc_core::testing::ServerTestPeer;
+
   struct RequestedCall;
 
   class RequestMatcherInterface;
@@ -266,7 +453,7 @@ class Server : public ServerInterface,
     // The index into Server::cqs_ of the CQ used as a starting point for
     // where to publish new incoming calls.
     size_t cq_idx_;
-    absl::optional<std::list<ChannelData*>::iterator> list_position_;
+    std::optional<std::list<ChannelData*>::iterator> list_position_;
     grpc_closure finish_destroy_channel_closure_;
     intptr_t channelz_socket_uuid_;
   };
@@ -330,8 +517,8 @@ class Server : public ServerInterface,
 
     std::atomic<CallState> state_{CallState::NOT_STARTED};
 
-    absl::optional<Slice> path_;
-    absl::optional<Slice> host_;
+    std::optional<Slice> path_;
+    std::optional<Slice> host_;
     Timestamp deadline_ = Timestamp::InfFuture();
 
     grpc_completion_queue* cq_new_ = nullptr;
@@ -360,13 +547,6 @@ class Server : public ServerInterface,
     CallCombiner* call_combiner_;
   };
 
-  struct Listener {
-    explicit Listener(OrphanablePtr<ListenerInterface> l)
-        : listener(std::move(l)) {}
-    OrphanablePtr<ListenerInterface> listener;
-    grpc_closure destroy_done;
-  };
-
   struct ShutdownTag {
     ShutdownTag(void* tag_arg, grpc_completion_queue* cq_arg)
         : tag(tag_arg), cq(cq_arg) {}
@@ -453,13 +633,20 @@ class Server : public ServerInterface,
     return shutdown_refs_.load(std::memory_order_acquire) == 0;
   }
 
+  // Returns a promise that resolves to
+  // tuple<
+  //     optional<MessageHandle>,
+  //     RequestMatcherInterface::MatchResult,
+  //     ClientMetadataHandle>
+  auto MatchRequestAndMaybeReadFirstMessage(CallHandler call_handler,
+                                            ClientMetadataHandle md);
   auto MatchAndPublishCall(CallHandler call_handler);
   absl::StatusOr<RefCountedPtr<UnstartedCallDestination>> MakeCallDestination(
       const ChannelArgs& args);
 
   ChannelArgs const channel_args_;
   RefCountedPtr<channelz::ServerNode> channelz_node_;
-  std::unique_ptr<grpc_server_config_fetcher> config_fetcher_;
+  std::unique_ptr<ServerConfigFetcher> config_fetcher_;
   ServerCallTracerFactory* const server_call_tracer_factory_;
 
   std::vector<grpc_completion_queue*> cqs_;
@@ -515,9 +702,11 @@ class Server : public ServerInterface,
   std::list<ChannelData*> channels_;
   absl::flat_hash_set<OrphanablePtr<ServerTransport>> connections_
       ABSL_GUARDED_BY(mu_global_);
+  RefCountedPtr<ServerConfigFetcher::ConnectionManager> connection_manager_
+      ABSL_GUARDED_BY(mu_global_);
   size_t connections_open_ ABSL_GUARDED_BY(mu_global_) = 0;
 
-  std::list<Listener> listeners_;
+  std::list<RefCountedPtr<ListenerState>> listener_states_;
   size_t listeners_destroyed_ = 0;
 
   // The last time we printed a shutdown progress message.
@@ -526,44 +715,4 @@ class Server : public ServerInterface,
 
 }  // namespace grpc_core
 
-struct grpc_server_config_fetcher {
- public:
-  class ConnectionManager
-      : public grpc_core::DualRefCounted<ConnectionManager> {
-   public:
-    virtual absl::StatusOr<grpc_core::ChannelArgs>
-    UpdateChannelArgsForConnection(const grpc_core::ChannelArgs& args,
-                                   grpc_endpoint* tcp) = 0;
-  };
-
-  class WatcherInterface {
-   public:
-    virtual ~WatcherInterface() = default;
-    // UpdateConnectionManager() is invoked by the config fetcher when a new
-    // config is available. Implementations should update the connection manager
-    // and start serving if not already serving.
-    virtual void UpdateConnectionManager(
-        grpc_core::RefCountedPtr<ConnectionManager> manager) = 0;
-    // Implementations should stop serving when this is called. Serving should
-    // only resume when UpdateConfig() is invoked.
-    virtual void StopServing() = 0;
-  };
-
-  virtual ~grpc_server_config_fetcher() = default;
-
-  virtual void StartWatch(std::string listening_address,
-                          std::unique_ptr<WatcherInterface> watcher) = 0;
-  virtual void CancelWatch(WatcherInterface* watcher) = 0;
-  virtual grpc_pollset_set* interested_parties() = 0;
-};
-
-namespace grpc_core {
-
-inline void Server::set_config_fetcher(
-    std::unique_ptr<grpc_server_config_fetcher> config_fetcher) {
-  config_fetcher_ = std::move(config_fetcher);
-}
-
-}  // namespace grpc_core
-
 #endif  // GRPC_SRC_CORE_SERVER_SERVER_H

data/src/core/server/server_call_tracer_filter.cc

@@ -87,16 +87,12 @@ class ServerCallTracerFilter
       call_tracer->RecordSendTrailingMetadata(&server_trailing_metadata);
     }
 
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
   };
 };
 
-const NoInterceptor ServerCallTracerFilter::Call::OnClientToServerMessage;
-const NoInterceptor ServerCallTracerFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ServerCallTracerFilter::Call::OnServerToClientMessage;
-
 const grpc_channel_filter ServerCallTracerFilter::kFilter =
     MakePromiseBasedFilter<ServerCallTracerFilter, FilterEndpoint::kServer,
                            kFilterExaminesServerInitialMetadata>();

data/src/core/server/server_config_selector_filter.cc

@@ -18,13 +18,13 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
@@ -71,12 +71,12 @@ class ServerConfigSelectorFilter final
    public:
     absl::Status OnClientInitialMetadata(ClientMetadata& md,
                                          ServerConfigSelectorFilter* filter);
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
   };
 
   absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
@@ -103,7 +103,7 @@ class ServerConfigSelectorFilter final
 
   RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
   Mutex mu_;
-  absl::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
+  std::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
       config_selector_ ABSL_GUARDED_BY(mu_);
 };
 
@@ -159,13 +159,6 @@ absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
   return absl::OkStatus();
 }
 
-const NoInterceptor ServerConfigSelectorFilter::Call::OnServerInitialMetadata;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnClientToServerMessage;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnServerToClientMessage;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnFinalize;
-
 }  // namespace
 
 const grpc_channel_filter kServerConfigSelectorFilter =