grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

data/src/core/lib/event_engine/posix_engine/posix_engine.h

@@ -15,13 +15,17 @@
 #define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_H
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
-
 #include <atomic>
+#include <cstdint>
 #include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
+#include "absl/hash/hash.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -29,36 +33,107 @@
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
-#include <grpc/event_engine/slice_buffer.h>
 
-#include "src/core/lib/event_engine/executor/threaded_executor.h"
 #include "src/core/lib/event_engine/handle_containers.h"
+#include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/thread_pool.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/surface/init_internally.h"
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+#include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+#include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
+#endif  // GRPC_POSIX_SOCKET_TCP
 
 namespace grpc_event_engine {
 namespace experimental {
 
+#ifdef GRPC_POSIX_SOCKET_TCP
+// A helper class to handle asynchronous connect operations.
+class AsyncConnect {
+ public:
+  AsyncConnect(EventEngine::OnConnectCallback on_connect,
+               std::shared_ptr<EventEngine> engine, ThreadPool* executor,
+               grpc_event_engine::posix_engine::EventHandle* fd,
+               MemoryAllocator&& allocator,
+               const grpc_event_engine::posix_engine::PosixTcpOptions& options,
+               std::string resolved_addr_str, int64_t connection_handle)
+      : on_connect_(std::move(on_connect)),
+        engine_(engine),
+        executor_(executor),
+        fd_(fd),
+        allocator_(std::move(allocator)),
+        options_(options),
+        resolved_addr_str_(resolved_addr_str),
+        connection_handle_(connection_handle),
+        connect_cancelled_(false) {}
+
+  void Start(EventEngine::Duration timeout);
+  ~AsyncConnect();
+
+ private:
+  friend class PosixEventEngine;
+  void OnTimeoutExpired(absl::Status status);
+
+  void OnWritable(absl::Status status) ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+  grpc_core::Mutex mu_;
+  grpc_event_engine::posix_engine::PosixEngineClosure* on_writable_ = nullptr;
+  EventEngine::OnConnectCallback on_connect_;
+  std::shared_ptr<EventEngine> engine_;
+  ThreadPool* executor_;
+  EventEngine::TaskHandle alarm_handle_;
+  int refs_{2};
+  grpc_event_engine::posix_engine::EventHandle* fd_;
+  MemoryAllocator allocator_;
+  grpc_event_engine::posix_engine::PosixTcpOptions options_;
+  std::string resolved_addr_str_;
+  int64_t connection_handle_;
+  bool connect_cancelled_;
+};
+
+// A helper class to manager lifetime of the poller associated with the
+// posix event engine.
+class PosixEnginePollerManager
+    : public grpc_event_engine::posix_engine::Scheduler {
+ public:
+  explicit PosixEnginePollerManager(std::shared_ptr<ThreadPool> executor);
+  explicit PosixEnginePollerManager(
+      grpc_event_engine::posix_engine::PosixEventPoller* poller);
+  grpc_event_engine::posix_engine::PosixEventPoller* Poller() {
+    return poller_;
+  }
+
+  ThreadPool* Executor() { return executor_.get(); }
+
+  void Run(experimental::EventEngine::Closure* closure) override;
+  void Run(absl::AnyInvocable<void()>) override;
+
+  bool IsShuttingDown() {
+    return poller_state_.load(std::memory_order_acquire) ==
+           PollerState::kShuttingDown;
+  }
+  void TriggerShutdown();
+
+  ~PosixEnginePollerManager() override;
+
+ private:
+  enum class PollerState { kExternal, kOk, kShuttingDown };
+  grpc_event_engine::posix_engine::PosixEventPoller* poller_ = nullptr;
+  std::atomic<PollerState> poller_state_{PollerState::kOk};
+  std::shared_ptr<ThreadPool> executor_;
+};
+#endif  // GRPC_POSIX_SOCKET_TCP
+
 // An iomgr-based Posix EventEngine implementation.
 // All methods require an ExecCtx to already exist on the thread's stack.
-class PosixEventEngine final : public EventEngine {
+// TODO(ctiller): KeepsGrpcInitialized is an interim measure to ensure that
+// event engine is shut down before we shut down iomgr.
+class PosixEventEngine final : public EventEngine,
+                               public grpc_core::KeepsGrpcInitialized {
  public:
-  class PosixEndpoint : public EventEngine::Endpoint {
-   public:
-    ~PosixEndpoint() override;
-    void Read(absl::AnyInvocable<void(absl::Status)> on_read,
-              SliceBuffer* buffer, const ReadArgs* args) override;
-    void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
-               SliceBuffer* data, const WriteArgs* args) override;
-    const ResolvedAddress& GetPeerAddress() const override;
-    const ResolvedAddress& GetLocalAddress() const override;
-  };
-  class PosixListener : public EventEngine::Listener {
-   public:
-    ~PosixListener() override;
-    absl::StatusOr<int> Bind(const ResolvedAddress& addr) override;
-    absl::Status Start() override;
-  };
   class PosixDNSResolver : public EventEngine::DNSResolver {
    public:
     ~PosixDNSResolver() override;
@@ -75,7 +150,17 @@ class PosixEventEngine final : public EventEngine {
     bool CancelLookup(LookupTaskHandle handle) override;
   };
 
-  PosixEventEngine() = default;
+#ifdef GRPC_POSIX_SOCKET_TCP
+  // Constructs an event engine which does not own the poller. Do not call this
+  // constructor directly. Instead use the MakeTestOnlyPosixEventEngine static
+  // method. Its expected to be used only in tests.
+  explicit PosixEventEngine(
+      grpc_event_engine::posix_engine::PosixEventPoller* poller);
+  PosixEventEngine();
+#else   // GRPC_POSIX_SOCKET_TCP
+  PosixEventEngine();
+#endif  // GRPC_POSIX_SOCKET_TCP
+
   ~PosixEventEngine() override;
 
   absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
@@ -102,17 +187,56 @@ class PosixEventEngine final : public EventEngine {
                       absl::AnyInvocable<void()> closure) override;
   bool Cancel(TaskHandle handle) override;
 
+#ifdef GRPC_POSIX_SOCKET_TCP
+  // The posix event engine returned by this method would not own the poller
+  // and would not be in-charge of driving the poller by calling its Work(..)
+  // method. Instead its upto the test to drive the poller. The returned posix
+  // event engine will also not attempt to shutdown the poller since it does not
+  // own it.
+  static std::shared_ptr<PosixEventEngine> MakeTestOnlyPosixEventEngine(
+      grpc_event_engine::posix_engine::PosixEventPoller* test_only_poller) {
+    return std::make_shared<PosixEventEngine>(test_only_poller);
+  }
+#endif  // GRPC_POSIX_SOCKET_TCP
+
  private:
   struct ClosureData;
   EventEngine::TaskHandle RunAfterInternal(Duration when,
                                            absl::AnyInvocable<void()> cb);
 
-  posix_engine::TimerManager timer_manager_;
-  ThreadedExecutor executor_{2};
+#ifdef GRPC_POSIX_SOCKET_TCP
+  friend class AsyncConnect;
+  struct ConnectionShard {
+    grpc_core::Mutex mu;
+    absl::flat_hash_map<int64_t, AsyncConnect*> pending_connections
+        ABSL_GUARDED_BY(&mu);
+  };
+
+  static void PollerWorkInternal(
+      std::shared_ptr<PosixEnginePollerManager> poller_manager);
+
+  ConnectionHandle ConnectInternal(
+      grpc_event_engine::posix_engine::PosixSocketWrapper sock,
+      OnConnectCallback on_connect, ResolvedAddress addr,
+      MemoryAllocator&& allocator,
+      const grpc_event_engine::posix_engine::PosixTcpOptions& options,
+      Duration timeout);
+
+  void OnConnectFinishInternal(int connection_handle);
+
+  std::vector<ConnectionShard> connection_shards_;
+  std::atomic<int64_t> last_connection_id_{1};
+
+#endif  // GRPC_POSIX_SOCKET_TCP
 
   grpc_core::Mutex mu_;
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
   std::atomic<intptr_t> aba_token_{0};
+  std::shared_ptr<ThreadPool> executor_;
+  posix_engine::TimerManager timer_manager_;
+#ifdef GRPC_POSIX_SOCKET_TCP
+  std::shared_ptr<PosixEnginePollerManager> poller_manager_;
+#endif  // GRPC_POSIX_SOCKET_TCP
 };
 
 }  // namespace experimental

data/src/core/lib/event_engine/posix_engine/posix_engine_closure.h

@@ -0,0 +1,80 @@
+// Copyright 2022 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_CLOSURE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_CLOSURE_H
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+// The callbacks for Endpoint read and write take an absl::Status as
+// argument - this is important for the tcp code to function correctly. We need
+// a custom closure type because the default EventEngine::Closure type doesn't
+// provide a way to pass a status when the callback is run.
+class PosixEngineClosure final
+    : public grpc_event_engine::experimental::EventEngine::Closure {
+ public:
+  PosixEngineClosure() = default;
+  PosixEngineClosure(absl::AnyInvocable<void(absl::Status)> cb,
+                     bool is_permanent)
+      : cb_(std::move(cb)),
+        is_permanent_(is_permanent),
+        status_(absl::OkStatus()) {}
+  ~PosixEngineClosure() final = default;
+  void SetStatus(absl::Status status) { status_ = status; }
+  void Run() override {
+    // We need to read the is_permanent_ variable before executing the
+    // enclosed callback. This is because a permanent closure may delete this
+    // object within the callback itself and thus reading this variable after
+    // the callback execution is not safe.
+    if (!is_permanent_) {
+      cb_(std::exchange(status_, absl::OkStatus()));
+      delete this;
+    } else {
+      cb_(std::exchange(status_, absl::OkStatus()));
+    }
+  }
+
+  // This closure clean doesn't itself up after execution by default. The caller
+  // should take care if its lifetime.
+  static PosixEngineClosure* ToPermanentClosure(
+      absl::AnyInvocable<void(absl::Status)> cb) {
+    return new PosixEngineClosure(std::move(cb), true);
+  }
+
+  // This closure clean's itself up after execution. It is expected to be
+  // used only in tests.
+  static PosixEngineClosure* TestOnlyToClosure(
+      absl::AnyInvocable<void(absl::Status)> cb) {
+    return new PosixEngineClosure(std::move(cb), false);
+  }
+
+ private:
+  absl::AnyInvocable<void(absl::Status)> cb_;
+  bool is_permanent_ = false;
+  absl::Status status_;
+};
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_CLOSURE_H