grpc 1.46.3 → 1.53.1

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -0,0 +1,388 @@
+// 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.
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include <memory>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#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/channel_args_endpoint_config.h"
+#include "src/core/lib/event_engine/common_closures.h"
+#include "src/core/lib/event_engine/executor/executor.h"
+#include "src/core/lib/event_engine/handle_containers.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/trace.h"
+#include "src/core/lib/event_engine/utils.h"
+#include "src/core/lib/event_engine/windows/iocp.h"
+#include "src/core/lib/event_engine/windows/windows_endpoint.h"
+#include "src/core/lib/event_engine/windows/windows_engine.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// ---- IOCPWorkClosure ----
+
+WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(Executor* executor,
+                                                     IOCP* iocp)
+    : executor_(executor), iocp_(iocp) {
+  executor_->Run(this);
+}
+
+void WindowsEventEngine::IOCPWorkClosure::Run() {
+  auto result = iocp_->Work(std::chrono::seconds(60), [this] {
+    workers_.fetch_add(1);
+    executor_->Run(this);
+  });
+  if (result == Poller::WorkResult::kDeadlineExceeded) {
+    // iocp received no messages. restart the worker
+    workers_.fetch_add(1);
+    executor_->Run(this);
+  }
+  if (workers_.fetch_sub(1) == 1) done_signal_.Notify();
+}
+
+void WindowsEventEngine::IOCPWorkClosure::WaitForShutdown() {
+  done_signal_.WaitForNotification();
+}
+
+// ---- WindowsEventEngine ----
+
+// TODO(hork): The iomgr timer and execution engine can be reused. It should
+// be separated out from the posix_engine and instantiated as components. It is
+// effectively copied below.
+
+struct WindowsEventEngine::TimerClosure final : public EventEngine::Closure {
+  absl::AnyInvocable<void()> cb;
+  Timer timer;
+  WindowsEventEngine* engine;
+  EventEngine::TaskHandle handle;
+
+  void Run() override {
+    GRPC_EVENT_ENGINE_TRACE(
+        "WindowsEventEngine:%p executing callback:%s", engine,
+        HandleToString<EventEngine::TaskHandle>(handle).c_str());
+    {
+      grpc_core::MutexLock lock(&engine->task_mu_);
+      engine->known_handles_.erase(handle);
+    }
+    cb();
+    delete this;
+  }
+};
+
+WindowsEventEngine::WindowsEventEngine()
+    : executor_(std::make_shared<ThreadPool>()),
+      iocp_(executor_.get()),
+      timer_manager_(executor_),
+      iocp_worker_(executor_.get(), &iocp_) {
+  WSADATA wsaData;
+  int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
+  GPR_ASSERT(status == 0);
+}
+
+WindowsEventEngine::~WindowsEventEngine() {
+  {
+    grpc_core::MutexLock lock(&task_mu_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+      for (auto handle : known_handles_) {
+        gpr_log(GPR_ERROR,
+                "WindowsEventEngine:%p uncleared TaskHandle at shutdown:%s",
+                this, HandleToString<EventEngine::TaskHandle>(handle).c_str());
+      }
+    }
+    GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+  }
+  iocp_.Kick();
+  iocp_worker_.WaitForShutdown();
+  iocp_.Shutdown();
+  GPR_ASSERT(WSACleanup() == 0);
+  timer_manager_.Shutdown();
+  executor_->Quiesce();
+}
+
+bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
+  grpc_core::MutexLock lock(&task_mu_);
+  if (!known_handles_.contains(handle)) return false;
+  GRPC_EVENT_ENGINE_TRACE(
+      "WindowsEventEngine::%p cancelling %s", this,
+      HandleToString<EventEngine::TaskHandle>(handle).c_str());
+  auto* cd = reinterpret_cast<TimerClosure*>(handle.keys[0]);
+  bool r = timer_manager_.TimerCancel(&cd->timer);
+  known_handles_.erase(handle);
+  if (r) delete cd;
+  return r;
+}
+
+EventEngine::TaskHandle WindowsEventEngine::RunAfter(
+    Duration when, absl::AnyInvocable<void()> closure) {
+  return RunAfterInternal(when, std::move(closure));
+}
+
+EventEngine::TaskHandle WindowsEventEngine::RunAfter(
+    Duration when, EventEngine::Closure* closure) {
+  return RunAfterInternal(when, [closure]() { closure->Run(); });
+}
+
+void WindowsEventEngine::Run(absl::AnyInvocable<void()> closure) {
+  executor_->Run(std::move(closure));
+}
+
+void WindowsEventEngine::Run(EventEngine::Closure* closure) {
+  executor_->Run(closure);
+}
+
+EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
+    Duration when, absl::AnyInvocable<void()> cb) {
+  auto when_ts = ToTimestamp(timer_manager_.Now(), when);
+  auto* cd = new TimerClosure;
+  cd->cb = std::move(cb);
+  cd->engine = this;
+  EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
+                                 aba_token_.fetch_add(1)};
+  grpc_core::MutexLock lock(&task_mu_);
+  known_handles_.insert(handle);
+  cd->handle = handle;
+  GRPC_EVENT_ENGINE_TRACE(
+      "WindowsEventEngine:%p scheduling callback:%s", this,
+      HandleToString<EventEngine::TaskHandle>(handle).c_str());
+  timer_manager_.TimerInit(&cd->timer, when_ts, cd);
+  return handle;
+}
+
+std::unique_ptr<EventEngine::DNSResolver> WindowsEventEngine::GetDNSResolver(
+    EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
+  grpc_core::Crash("unimplemented");
+}
+
+bool WindowsEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
+
+void WindowsEventEngine::OnConnectCompleted(
+    std::shared_ptr<ConnectionState> state) {
+  absl::StatusOr<std::unique_ptr<WindowsEndpoint>> endpoint;
+  {
+    // Connection attempt complete!
+    grpc_core::MutexLock lock(&state->mu);
+    state->on_connected = nullptr;
+    {
+      grpc_core::MutexLock handle_lock(&connection_mu_);
+      known_connection_handles_.erase(state->connection_handle);
+    }
+    const auto& overlapped_result = state->socket->write_info()->result();
+    // return early if we cannot cancel the connection timeout timer.
+    if (!Cancel(state->timer_handle)) return;
+    if (overlapped_result.wsa_error != 0) {
+      state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx failure");
+      endpoint = GRPC_WSA_ERROR(overlapped_result.wsa_error, "ConnectEx");
+    } else {
+      // This code should be running in an executor thread already, so the
+      // callback can be run directly.
+      ChannelArgsEndpointConfig cfg;
+      endpoint = std::make_unique<WindowsEndpoint>(
+          state->address, std::move(state->socket), std::move(state->allocator),
+          cfg, executor_.get());
+    }
+  }
+  state->on_connected_user_callback(std::move(endpoint));
+}
+
+EventEngine::ConnectionHandle WindowsEventEngine::Connect(
+    OnConnectCallback on_connect, const ResolvedAddress& addr,
+    const EndpointConfig& /* args */, MemoryAllocator memory_allocator,
+    Duration timeout) {
+  // TODO(hork): utilize the endpoint config
+  absl::Status status;
+  int istatus;
+  auto uri = ResolvedAddressToURI(addr);
+  if (!uri.ok()) {
+    Run([on_connect = std::move(on_connect), status = uri.status()]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  GRPC_EVENT_ENGINE_TRACE("EventEngine::%p connecting to %s", this,
+                          uri->c_str());
+  // Use dualstack sockets where available.
+  ResolvedAddress address = addr;
+  ResolvedAddress addr6_v4mapped;
+  if (ResolvedAddressToV4Mapped(addr, &addr6_v4mapped)) {
+    address = addr6_v4mapped;
+  }
+  SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, nullptr, 0,
+                          IOCP::GetDefaultSocketFlags());
+  if (sock == INVALID_SOCKET) {
+    Run([on_connect = std::move(on_connect),
+         status = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket")]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  status = PrepareSocket(sock);
+  if (!status.ok()) {
+    Run([on_connect = std::move(on_connect), status]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  // Grab the function pointer for ConnectEx for that specific socket It may
+  // change depending on the interface.
+  LPFN_CONNECTEX ConnectEx;
+  GUID guid = WSAID_CONNECTEX;
+  DWORD ioctl_num_bytes;
+  istatus = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid,
+                     sizeof(guid), &ConnectEx, sizeof(ConnectEx),
+                     &ioctl_num_bytes, nullptr, nullptr);
+  if (istatus != 0) {
+    Run([on_connect = std::move(on_connect),
+         status = GRPC_WSA_ERROR(
+             WSAGetLastError(),
+             "WSAIoctl(SIO_GET_EXTENSION_FUNCTION_POINTER)")]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  // bind the local address
+  auto local_address = ResolvedAddressMakeWild6(0);
+  istatus = bind(sock, local_address.address(), local_address.size());
+  if (istatus != 0) {
+    Run([on_connect = std::move(on_connect),
+         status = GRPC_WSA_ERROR(WSAGetLastError(), "bind")]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  // Connect
+  auto watched_socket = iocp_.Watch(sock);
+  auto* info = watched_socket->write_info();
+  bool success =
+      ConnectEx(watched_socket->raw_socket(), address.address(), address.size(),
+                nullptr, 0, nullptr, info->overlapped());
+  // It wouldn't be unusual to get a success immediately. But we'll still get an
+  // IOCP notification, so let's ignore it.
+  if (!success) {
+    int last_error = WSAGetLastError();
+    if (last_error != ERROR_IO_PENDING) {
+      Run([on_connect = std::move(on_connect),
+           status = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx")]() mutable {
+        on_connect(status);
+      });
+      watched_socket->Shutdown(DEBUG_LOCATION, "ConnectEx");
+      return EventEngine::kInvalidConnectionHandle;
+    }
+  }
+  GPR_ASSERT(watched_socket != nullptr);
+  auto connection_state = std::make_shared<ConnectionState>();
+  grpc_core::MutexLock lock(&connection_state->mu);
+  connection_state->address = address;
+  connection_state->socket = std::move(watched_socket);
+  connection_state->on_connected_user_callback = std::move(on_connect);
+  connection_state->allocator = std::move(memory_allocator);
+  connection_state->on_connected =
+      SelfDeletingClosure::Create([this, connection_state]() mutable {
+        OnConnectCompleted(std::move(connection_state));
+      });
+  {
+    grpc_core::MutexLock conn_lock(&connection_mu_);
+    connection_state->connection_handle =
+        ConnectionHandle{reinterpret_cast<intptr_t>(connection_state.get()),
+                         aba_token_.fetch_add(1)};
+    known_connection_handles_.insert(connection_state->connection_handle);
+  }
+  connection_state->timer_handle =
+      RunAfter(timeout, [this, connection_state]() {
+        grpc_core::MutexLock lock(&connection_state->mu);
+        if (CancelConnectFromDeadlineTimer(connection_state.get())) {
+          connection_state->on_connected_user_callback(
+              absl::DeadlineExceededError("Connection timed out"));
+        }
+        // else: The connection attempt could not be canceled. We can assume the
+        // connection callback will be called.
+      });
+  connection_state->socket->NotifyOnWrite(connection_state->on_connected);
+  return connection_state->connection_handle;
+}
+
+bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
+  if (TaskHandleComparator<ConnectionHandle>::Eq()(
+          handle, EventEngine::kInvalidConnectionHandle)) {
+    GRPC_EVENT_ENGINE_TRACE("%s",
+                            "Attempted to cancel an invalid connection handle");
+    return false;
+  }
+  // Erase the connection handle, which may be unknown
+  {
+    grpc_core::MutexLock lock(&connection_mu_);
+    if (!known_connection_handles_.contains(handle)) {
+      GRPC_EVENT_ENGINE_TRACE(
+          "Unknown connection handle: %s",
+          HandleToString<EventEngine::ConnectionHandle>(handle).c_str());
+      return false;
+    }
+    known_connection_handles_.erase(handle);
+  }
+  auto* connection_state = reinterpret_cast<ConnectionState*>(handle.keys[0]);
+  grpc_core::MutexLock state_lock(&connection_state->mu);
+  if (!Cancel(connection_state->timer_handle)) return false;
+  return CancelConnectInternalStateLocked(connection_state);
+}
+
+bool WindowsEventEngine::CancelConnectFromDeadlineTimer(
+    ConnectionState* connection_state) {
+  // Erase the connection handle, which is guaranteed to exist.
+  {
+    grpc_core::MutexLock lock(&connection_mu_);
+    GPR_ASSERT(known_connection_handles_.erase(
+                   connection_state->connection_handle) == 1);
+  }
+  return CancelConnectInternalStateLocked(connection_state);
+}
+
+bool WindowsEventEngine::CancelConnectInternalStateLocked(
+    ConnectionState* connection_state) {
+  connection_state->socket->Shutdown(DEBUG_LOCATION, "CancelConnect");
+  // Release the connection_state shared_ptr. connection_state is now invalid.
+  delete connection_state->on_connected;
+  GRPC_EVENT_ENGINE_TRACE("Successfully cancelled connection %s",
+                          HandleToString<EventEngine::ConnectionHandle>(
+                              connection_state->connection_handle)
+                              .c_str());
+  return true;
+}
+
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
+WindowsEventEngine::CreateListener(
+    Listener::AcceptCallback on_accept,
+    absl::AnyInvocable<void(absl::Status)> on_shutdown,
+    const EndpointConfig& config,
+    std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
+  grpc_core::Crash("unimplemented");
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_WINDOWS

data/src/core/lib/event_engine/windows/windows_engine.h

@@ -0,0 +1,163 @@
+// 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_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include <memory>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#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/handle_containers.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/event_engine/windows/iocp.h"
+#include "src/core/lib/event_engine/windows/windows_endpoint.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/surface/init_internally.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// TODO(ctiller): KeepsGrpcInitialized is an interim measure to ensure that
+// EventEngine is shut down before we shut down iomgr.
+class WindowsEventEngine : public EventEngine,
+                           public grpc_core::KeepsGrpcInitialized {
+ public:
+  class WindowsDNSResolver : public EventEngine::DNSResolver {
+   public:
+    ~WindowsDNSResolver() override;
+    LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
+                                    absl::string_view name,
+                                    absl::string_view default_port,
+                                    Duration timeout) override;
+    LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
+                               absl::string_view name,
+                               Duration timeout) override;
+    LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
+                               absl::string_view name,
+                               Duration timeout) override;
+    bool CancelLookup(LookupTaskHandle handle) override;
+  };
+
+  WindowsEventEngine();
+  ~WindowsEventEngine() override;
+
+  absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
+      Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+      override;
+
+  ConnectionHandle Connect(OnConnectCallback on_connect,
+                           const ResolvedAddress& addr,
+                           const EndpointConfig& args,
+                           MemoryAllocator memory_allocator,
+                           Duration timeout) override;
+
+  bool CancelConnect(ConnectionHandle handle) override;
+  bool IsWorkerThread() override;
+  std::unique_ptr<DNSResolver> GetDNSResolver(
+      const DNSResolver::ResolverOptions& options) override;
+  void Run(Closure* closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
+  TaskHandle RunAfter(Duration when, Closure* closure) override;
+  TaskHandle RunAfter(Duration when,
+                      absl::AnyInvocable<void()> closure) override;
+  bool Cancel(TaskHandle handle) override;
+
+  // Retrieve the base executor.
+  // This is public because most classes that know the concrete
+  // WindowsEventEngine type are effectively friends.
+  // Not intended for external use.
+  Executor* executor() { return executor_.get(); }
+
+ private:
+  // State of an active connection.
+  // Managed by a shared_ptr, owned exclusively by the timeout callback and the
+  // OnConnectCompleted callback herein.
+  struct ConnectionState {
+    // everything is guarded by mu;
+    grpc_core::Mutex mu
+        ABSL_ACQUIRED_BEFORE(WindowsEventEngine::connection_mu_);
+    EventEngine::ConnectionHandle connection_handle ABSL_GUARDED_BY(mu);
+    EventEngine::TaskHandle timer_handle ABSL_GUARDED_BY(mu);
+    EventEngine::OnConnectCallback on_connected_user_callback
+        ABSL_GUARDED_BY(mu);
+    EventEngine::Closure* on_connected ABSL_GUARDED_BY(mu);
+    std::unique_ptr<WinSocket> socket ABSL_GUARDED_BY(mu);
+    EventEngine::ResolvedAddress address ABSL_GUARDED_BY(mu);
+    MemoryAllocator allocator ABSL_GUARDED_BY(mu);
+  };
+
+  // A poll worker which schedules itself unless kicked
+  class IOCPWorkClosure : public EventEngine::Closure {
+   public:
+    explicit IOCPWorkClosure(Executor* executor, IOCP* iocp);
+    void Run() override;
+    void WaitForShutdown();
+
+   private:
+    std::atomic<int> workers_{1};
+    grpc_core::Notification done_signal_;
+    Executor* executor_;
+    IOCP* iocp_;
+  };
+
+  void OnConnectCompleted(std::shared_ptr<ConnectionState> state);
+
+  // CancelConnect called from within the deadline timer.
+  // In this case, the connection_state->mu is already locked, and timer
+  // cancellation is not possible.
+  bool CancelConnectFromDeadlineTimer(ConnectionState* connection_state)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state->mu);
+
+  // Completes the connection cancellation logic after checking handle validity
+  // and optionally cancelling deadline timers.
+  bool CancelConnectInternalStateLocked(ConnectionState* connection_state)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state->mu);
+
+  class TimerClosure;
+  EventEngine::TaskHandle RunAfterInternal(Duration when,
+                                           absl::AnyInvocable<void()> cb);
+  grpc_core::Mutex task_mu_;
+  TaskHandleSet known_handles_ ABSL_GUARDED_BY(task_mu_);
+  grpc_core::Mutex connection_mu_ ABSL_ACQUIRED_AFTER(ConnectionState::mu);
+  grpc_core::CondVar connection_cv_;
+  ConnectionHandleSet known_connection_handles_ ABSL_GUARDED_BY(connection_mu_);
+  std::atomic<intptr_t> aba_token_{0};
+
+  std::shared_ptr<ThreadPool> executor_;
+  IOCP iocp_;
+  TimerManager timer_manager_;
+  IOCPWorkClosure iocp_worker_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H