grpc 1.69.0 → 1.70.1

data/src/core/server/server.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,167 @@ 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:
+      ~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;
+    };
+
     ~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.
+    absl::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 +326,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 +352,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 +405,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;
@@ -360,13 +543,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) {}
@@ -459,7 +635,7 @@ class Server : public ServerInterface,
 
   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 +691,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 +704,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