grpc 1.50.0.pre1 → 1.52.0.pre2

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::experimental::EventHandle* fd,
+               MemoryAllocator&& allocator,
+               const grpc_event_engine::experimental::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::experimental::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::experimental::EventHandle* fd_;
+  MemoryAllocator allocator_;
+  grpc_event_engine::experimental::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::experimental::Scheduler {
+ public:
+  explicit PosixEnginePollerManager(std::shared_ptr<ThreadPool> executor);
+  explicit PosixEnginePollerManager(
+      grpc_event_engine::experimental::PosixEventPoller* poller);
+  grpc_event_engine::experimental::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::experimental::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::experimental::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::experimental::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::experimental::PosixSocketWrapper sock,
+      OnConnectCallback on_connect, ResolvedAddress addr,
+      MemoryAllocator&& allocator,
+      const grpc_event_engine::experimental::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_;
+  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 experimental {
+
+// 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 experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_CLOSURE_H

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.cc

@@ -0,0 +1,236 @@
+// Copyright 2022 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+
+#include <errno.h>       // IWYU pragma: keep
+#include <sys/socket.h>  // IWYU pragma: keep
+#include <unistd.h>      // IWYU pragma: keep
+
+#include <string>
+#include <utility>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/event_engine/posix_engine/event_poller.h"
+#include "src/core/lib/event_engine/posix_engine/posix_endpoint.h"
+#include "src/core/lib/event_engine/posix_engine/posix_engine_listener.h"
+#include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/iomgr/socket_mutator.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+PosixEngineListenerImpl::PosixEngineListenerImpl(
+    EventEngine::Listener::AcceptCallback on_accept,
+    absl::AnyInvocable<void(absl::Status)> on_shutdown,
+    const grpc_event_engine::experimental::EndpointConfig& config,
+    std::unique_ptr<grpc_event_engine::experimental::MemoryAllocatorFactory>
+        memory_allocator_factory,
+    PosixEventPoller* poller, std::shared_ptr<EventEngine> engine)
+    : poller_(poller),
+      options_(TcpOptionsFromEndpointConfig(config)),
+      engine_(std::move(engine)),
+      acceptors_(this),
+      on_accept_(std::move(on_accept)),
+      on_shutdown_(std::move(on_shutdown)),
+      memory_allocator_factory_(std::move(memory_allocator_factory)) {}
+
+absl::StatusOr<int> PosixEngineListenerImpl::Bind(
+    const EventEngine::ResolvedAddress& addr) {
+  EventEngine::ResolvedAddress res_addr = addr;
+  EventEngine::ResolvedAddress addr6_v4mapped;
+  int requested_port = ResolvedAddressGetPort(res_addr);
+  absl::MutexLock lock(&this->mu_);
+  GPR_ASSERT(!this->started_);
+  GPR_ASSERT(addr.size() <= EventEngine::ResolvedAddress::MAX_SIZE_BYTES);
+  UnlinkIfUnixDomainSocket(addr);
+
+  /// Check if this is a wildcard port, and if so, try to keep the port the same
+  /// as some previously created listener socket.
+  for (auto it = acceptors_.begin();
+       requested_port == 0 && it != acceptors_.end(); it++) {
+    EventEngine::ResolvedAddress sockname_temp;
+    socklen_t len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
+    if (0 == getsockname((*it)->Socket().sock.Fd(),
+                         const_cast<sockaddr*>(sockname_temp.address()),
+                         &len)) {
+      int used_port = ResolvedAddressGetPort(sockname_temp);
+      if (used_port > 0) {
+        requested_port = used_port;
+        ResolvedAddressSetPort(res_addr, requested_port);
+        break;
+      }
+    }
+  }
+
+  auto used_port = ResolvedAddressIsWildcard(res_addr);
+  if (used_port.has_value()) {
+    requested_port = *used_port;
+    return ListenerContainerAddWildcardAddresses(acceptors_, options_,
+                                                 requested_port);
+  }
+  if (ResolvedAddressToV4Mapped(res_addr, &addr6_v4mapped)) {
+    res_addr = addr6_v4mapped;
+  }
+
+  auto result = CreateAndPrepareListenerSocket(options_, res_addr);
+  GRPC_RETURN_IF_ERROR(result.status());
+  acceptors_.Append(*result);
+  return result->port;
+}
+
+void PosixEngineListenerImpl::AsyncConnectionAcceptor::Start() {
+  Ref();
+  handle_->NotifyOnRead(notify_on_accept_);
+}
+
+void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
+    absl::Status status) {
+  if (!status.ok()) {
+    // Shutting down the acceptor. Unref the ref grabbed in
+    // AsyncConnectionAcceptor::Start().
+    Unref();
+    return;
+  }
+  // loop until accept4 returns EAGAIN, and then re-arm notification.
+  for (;;) {
+    EventEngine::ResolvedAddress addr;
+    memset(const_cast<sockaddr*>(addr.address()), 0, addr.size());
+    // Note: If we ever decide to return this address to the user, remember to
+    // strip off the ::ffff:0.0.0.0/96 prefix first.
+    int fd = Accept4(handle_->WrappedFd(), addr, 1, 1);
+    if (fd < 0) {
+      switch (errno) {
+        case EINTR:
+          continue;
+        case EAGAIN:
+        case ECONNABORTED:
+          handle_->NotifyOnRead(notify_on_accept_);
+          return;
+        default:
+          gpr_log(GPR_ERROR, "Closing acceptor. Failed accept4: %s",
+                  strerror(errno));
+          // Shutting down the acceptor. Unref the ref grabbed in
+          // AsyncConnectionAcceptor::Start().
+          Unref();
+          return;
+      }
+    }
+
+    // For UNIX sockets, the accept call might not fill up the member
+    // sun_path of sockaddr_un, so explicitly call getsockname to get it.
+    if (addr.address()->sa_family == AF_UNIX) {
+      socklen_t len = EventEngine::ResolvedAddress::MAX_SIZE_BYTES;
+      if (getsockname(fd, const_cast<sockaddr*>(addr.address()), &len) < 0) {
+        gpr_log(GPR_ERROR, "Closing acceptor. Failed getsockname: %s",
+                strerror(errno));
+        close(fd);
+        // Shutting down the acceptor. Unref the ref grabbed in
+        // AsyncConnectionAcceptor::Start().
+        Unref();
+        return;
+      }
+    }
+
+    PosixSocketWrapper sock(fd);
+    (void)sock.SetSocketNoSigpipeIfPossible();
+    auto result = sock.ApplySocketMutatorInOptions(
+        GRPC_FD_SERVER_CONNECTION_USAGE, listener_->options_);
+    if (!result.ok()) {
+      gpr_log(GPR_ERROR, "Closing acceptor. Failed to apply socket mutator: %s",
+              result.ToString().c_str());
+      // Shutting down the acceptor. Unref the ref grabbed in
+      // AsyncConnectionAcceptor::Start().
+      Unref();
+      return;
+    }
+
+    // Create an Endpoint here.
+    std::string peer_name = *ResolvedAddressToNormalizedString(addr);
+    auto endpoint = CreatePosixEndpoint(
+        /*handle=*/listener_->poller_->CreateHandle(
+            fd, peer_name, listener_->poller_->CanTrackErrors()),
+        /*on_shutdown=*/nullptr, /*engine=*/listener_->engine_,
+        // allocator=
+        listener_->memory_allocator_factory_->CreateMemoryAllocator(
+            absl::StrCat("endpoint-tcp-server-connection: ", peer_name)),
+        /*options=*/listener_->options_);
+    // Call on_accept_ and then resume accepting new connections by continuing
+    // the parent for-loop.
+    listener_->on_accept_(
+        std::move(endpoint),
+        listener_->memory_allocator_factory_->CreateMemoryAllocator(
+            absl::StrCat("on-accept-tcp-server-connection: ", peer_name)));
+  }
+  GPR_UNREACHABLE_CODE(return);
+}
+
+void PosixEngineListenerImpl::AsyncConnectionAcceptor::Shutdown() {
+  // The ShutdownHandle whould trigger any waiting notify_on_accept_ to get
+  // scheduled with the not-OK status.
+  handle_->ShutdownHandle(absl::InternalError("Shutting down acceptor"));
+  Unref();
+}
+
+absl::Status PosixEngineListenerImpl::Start() {
+  absl::MutexLock lock(&this->mu_);
+  // Start each asynchronous acceptor.
+  GPR_ASSERT(!this->started_);
+  this->started_ = true;
+  for (auto it = acceptors_.begin(); it != acceptors_.end(); it++) {
+    (*it)->Start();
+  }
+  return absl::OkStatus();
+}
+
+void PosixEngineListenerImpl::TriggerShutdown() {
+  // This would get invoked from the destructor of the parent
+  // PosixEngineListener object.
+  absl::MutexLock lock(&this->mu_);
+  for (auto it = acceptors_.begin(); it != acceptors_.end(); it++) {
+    // Trigger shutdown of each asynchronous acceptor. This in-turn calls
+    // ShutdownHandle on the associated poller event handle. It may also
+    // immediately delete the asynchronous acceptor if the acceptor was never
+    // started.
+    (*it)->Shutdown();
+  }
+}
+
+PosixEngineListenerImpl::~PosixEngineListenerImpl() {
+  // This should get invoked only after all the AsyncConnectionAcceptor's have
+  // been destroyed. This is because each AsyncConnectionAcceptor has a
+  // shared_ptr ref to the parent PosixEngineListenerImpl.
+  if (on_shutdown_ != nullptr) {
+    on_shutdown_(absl::InternalError("Shutting down listener"));
+  }
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_POSIX_SOCKET_TCP