grpc 1.53.2 → 1.54.0

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

@@ -34,19 +34,29 @@ namespace grpc_event_engine {
 namespace experimental {
 
 namespace {
-constexpr int64_t kDefaultTargetReadSize = 8192;
+constexpr size_t kDefaultTargetReadSize = 8192;
 constexpr int kMaxWSABUFCount = 16;
 
+void DumpSliceBuffer(SliceBuffer* buffer, absl::string_view context_string) {
+  for (size_t i = 0; i < buffer->Count(); i++) {
+    auto str = buffer->MutableSliceAt(i).as_string_view();
+    gpr_log(GPR_INFO, "%s: %.*s", context_string.data(), str.length(),
+            str.data());
+  }
+}
+
 }  // namespace
 
 WindowsEndpoint::WindowsEndpoint(
     const EventEngine::ResolvedAddress& peer_address,
     std::unique_ptr<WinSocket> socket, MemoryAllocator&& allocator,
-    const EndpointConfig& /* config */, Executor* executor)
+    const EndpointConfig& /* config */, Executor* executor,
+    std::shared_ptr<EventEngine> engine)
     : peer_address_(peer_address),
       allocator_(std::move(allocator)),
       executor_(executor),
-      io_state_(std::make_shared<AsyncIOState>(this, std::move(socket))) {
+      io_state_(std::make_shared<AsyncIOState>(this, std::move(socket),
+                                               std::move(engine))) {
   char addr[EventEngine::ResolvedAddress::MAX_SIZE_BYTES];
   int addr_len = sizeof(addr);
   if (getsockname(io_state_->socket->raw_socket(),
@@ -62,92 +72,95 @@ WindowsEndpoint::WindowsEndpoint(
 }
 
 WindowsEndpoint::~WindowsEndpoint() {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p destoyed", this);
+  io_state_->socket->Shutdown(DEBUG_LOCATION, "~WindowsEndpoint");
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("~WindowsEndpoint::%p", this);
 }
 
-void WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
-                           SliceBuffer* buffer, const ReadArgs* args) {
+absl::Status WindowsEndpoint::DoTcpRead(SliceBuffer* buffer) {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p reading", this);
   if (io_state_->socket->IsShutdown()) {
-    executor_->Run([on_read = std::move(on_read)]() mutable {
-      on_read(absl::UnavailableError("Socket is shutting down."));
-    });
-    return;
+    return absl::UnavailableError("Socket is shutting down.");
   }
   // Prepare the WSABUF struct
-  WSABUF wsa_buffers[kMaxWSABUFCount];
-  // TODO(hork): introduce a last_read_buffer to save unused sliced.
-  buffer->Clear();
-  // TODO(hork): sometimes args->read_hint_bytes is 1, which is not useful.
-  // Choose an appropriate size.
-  int min_read_size = kDefaultTargetReadSize;
-  if (buffer->Length() < min_read_size && buffer->Count() < kMaxWSABUFCount) {
-    buffer->AppendIndexed(Slice(allocator_.MakeSlice(min_read_size)));
-  }
   GPR_ASSERT(buffer->Count() <= kMaxWSABUFCount);
-  for (int i = 0; i < buffer->Count(); i++) {
+  WSABUF wsa_buffers[kMaxWSABUFCount];
+  for (size_t i = 0; i < buffer->Count(); i++) {
     auto& slice = buffer->MutableSliceAt(i);
     wsa_buffers[i].buf = (char*)slice.begin();
     wsa_buffers[i].len = slice.size();
   }
   DWORD bytes_read = 0;
   DWORD flags = 0;
-  // First let's try a synchronous, non-blocking read.
+  // First try a synchronous, non-blocking read.
   int status =
       WSARecv(io_state_->socket->raw_socket(), wsa_buffers,
               (DWORD)buffer->Count(), &bytes_read, &flags, nullptr, nullptr);
   int wsa_error = status == 0 ? 0 : WSAGetLastError();
-  // Did we get data immediately ? Yay.
   if (wsa_error != WSAEWOULDBLOCK) {
+    // Data or some error was returned immediately.
     io_state_->socket->read_info()->SetResult(
         {/*wsa_error=*/wsa_error, /*bytes_read=*/bytes_read});
-    absl::Status result;
-    if (bytes_read == 0) {
-      result = absl::UnavailableError("End of TCP stream");
-      grpc_core::StatusSetInt(&result, grpc_core::StatusIntProperty::kRpcStatus,
-                              GRPC_STATUS_UNAVAILABLE);
-      buffer->Clear();
-    } else {
-      result = absl::OkStatus();
-      // prune slicebuffer
-      if (bytes_read != buffer->Length()) {
-        buffer->RemoveLastNBytes(buffer->Length() - bytes_read);
-      }
-    }
-    executor_->Run(
-        [result, on_read = std::move(on_read)]() mutable { on_read(result); });
-    return;
+    executor_->Run(&io_state_->handle_read_event);
+    return absl::OkStatus();
+  }
+  // If the endpoint has already received some data, and the next call would
+  // block, return the data in case that is all the data the reader expects.
+  if (io_state_->handle_read_event.MaybeFinishIfDataHasAlreadyBeenRead()) {
+    return absl::OkStatus();
   }
   // Otherwise, let's retry, by queuing a read.
-  memset(io_state_->socket->read_info()->overlapped(), 0, sizeof(OVERLAPPED));
   status = WSARecv(io_state_->socket->raw_socket(), wsa_buffers,
                    (DWORD)buffer->Count(), &bytes_read, &flags,
                    io_state_->socket->read_info()->overlapped(), nullptr);
   wsa_error = status == 0 ? 0 : WSAGetLastError();
   if (wsa_error != 0 && wsa_error != WSA_IO_PENDING) {
     // Async read returned immediately with an error
-    executor_->Run([this, on_read = std::move(on_read), wsa_error]() mutable {
-      on_read(GRPC_WSA_ERROR(
-          wsa_error,
-          absl::StrFormat("WindowsEndpont::%p Read failed", this).c_str()));
+    return GRPC_WSA_ERROR(
+        wsa_error,
+        absl::StrFormat("WindowsEndpont::%p Read failed", this).c_str());
+  }
+  io_state_->socket->NotifyOnRead(&io_state_->handle_read_event);
+  return absl::OkStatus();
+}
+
+bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
+                           SliceBuffer* buffer, const ReadArgs* /* args */) {
+  if (io_state_->socket->IsShutdown()) {
+    executor_->Run([on_read = std::move(on_read)]() mutable {
+      on_read(absl::UnavailableError("Socket is shutting down."));
     });
-    return;
+    return false;
+  }
+  buffer->Clear();
+  io_state_->handle_read_event.DonateSpareSlices(buffer);
+  // TODO(hork): sometimes args->read_hint_bytes is 1, which is not useful.
+  // Choose an appropriate size.
+  size_t min_read_size = kDefaultTargetReadSize;
+  if (buffer->Length() < min_read_size && buffer->Count() < kMaxWSABUFCount) {
+    buffer->AppendIndexed(Slice(allocator_.MakeSlice(min_read_size)));
   }
   io_state_->handle_read_event.Prime(io_state_, buffer, std::move(on_read));
-  io_state_->socket->NotifyOnRead(&io_state_->handle_read_event);
+  auto status = DoTcpRead(buffer);
+  if (!status.ok()) {
+    // The read could not be completed.
+    io_state_->endpoint->executor_->Run([this, status]() {
+      io_state_->handle_read_event.ExecuteCallbackAndReset(status);
+    });
+  }
+  return false;
 }
 
-void WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
                             SliceBuffer* data, const WriteArgs* /* args */) {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p writing", this);
   if (io_state_->socket->IsShutdown()) {
     executor_->Run([on_writable = std::move(on_writable)]() mutable {
       on_writable(absl::UnavailableError("Socket is shutting down."));
     });
-    return;
+    return false;
   }
   if (grpc_event_engine_endpoint_data_trace.enabled()) {
-    for (int i = 0; i < data->Count(); i++) {
+    for (size_t i = 0; i < data->Count(); i++) {
       auto str = data->RefSlice(i).as_string_view();
       gpr_log(GPR_INFO, "WindowsEndpoint::%p WRITE (peer=%s): %.*s", this,
               peer_address_string_.c_str(), str.length(), str.data());
@@ -155,7 +168,7 @@ void WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
   }
   GPR_ASSERT(data->Count() <= UINT_MAX);
   absl::InlinedVector<WSABUF, kMaxWSABUFCount> buffers(data->Count());
-  for (int i = 0; i < data->Count(); i++) {
+  for (size_t i = 0; i < data->Count(); i++) {
     auto& slice = data->MutableSliceAt(i);
     GPR_ASSERT(slice.size() <= ULONG_MAX);
     buffers[i].len = slice.size();
@@ -171,11 +184,11 @@ void WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
       // Write completed, exiting early
       executor_->Run(
           [cb = std::move(on_writable)]() mutable { cb(absl::OkStatus()); });
-      return;
+      return false;
     }
     // The data was not completely delivered, we should send the rest of it by
     // doing an async write operation.
-    for (int i = 0; i < data->Count(); i++) {
+    for (size_t i = 0; i < data->Count(); i++) {
       if (buffers[i].len > bytes_sent) {
         buffers[i].buf += bytes_sent;
         buffers[i].len -= bytes_sent;
@@ -193,29 +206,28 @@ void WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
       executor_->Run([cb = std::move(on_writable), wsa_error]() mutable {
         cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
       });
-      return;
+      return false;
     }
   }
   auto write_info = io_state_->socket->write_info();
-  memset(write_info->overlapped(), 0, sizeof(OVERLAPPED));
   status =
       WSASend(io_state_->socket->raw_socket(), &buffers[async_buffers_offset],
               (DWORD)(data->Count() - async_buffers_offset), nullptr, 0,
               write_info->overlapped(), nullptr);
-
   if (status != 0) {
     int wsa_error = WSAGetLastError();
     if (wsa_error != WSA_IO_PENDING) {
       executor_->Run([cb = std::move(on_writable), wsa_error]() mutable {
         cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
       });
-      return;
+      return false;
     }
   }
   // As all is now setup, we can now ask for the IOCP notification. It may
   // trigger the callback immediately however, but no matter.
   io_state_->handle_write_event.Prime(io_state_, data, std::move(on_writable));
   io_state_->socket->NotifyOnWrite(&io_state_->handle_write_event);
+  return false;
 }
 const EventEngine::ResolvedAddress& WindowsEndpoint::GetPeerAddress() const {
   return peer_address_;
@@ -234,11 +246,13 @@ void AbortOnEvent(absl::Status) {
 }  // namespace
 
 void WindowsEndpoint::HandleReadClosure::Reset() {
+  io_state_.reset();
   cb_ = &AbortOnEvent;
   buffer_ = nullptr;
 }
 
 void WindowsEndpoint::HandleWriteClosure::Reset() {
+  io_state_.reset();
   cb_ = &AbortOnEvent;
   buffer_ = nullptr;
 }
@@ -265,61 +279,94 @@ void WindowsEndpoint::HandleReadClosure::Run() {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Read Event",
                                    io_state->endpoint);
   absl::Status status;
-  auto cb_cleanup = absl::MakeCleanup([this, &status]() {
-    auto cb = std::move(cb_);
-    Reset();
-    cb(status);
-  });
   const auto result = io_state->socket->read_info()->result();
   if (result.wsa_error != 0) {
     status = GRPC_WSA_ERROR(result.wsa_error, "Async Read Error");
     buffer_->Clear();
-    return;
+    return ExecuteCallbackAndReset(status);
   }
-  if (result.bytes_transferred > 0) {
-    GPR_ASSERT(result.bytes_transferred <= buffer_->Length());
-    if (result.bytes_transferred != buffer_->Length()) {
-      buffer_->RemoveLastNBytes(buffer_->Length() - result.bytes_transferred);
-    }
-    GPR_ASSERT(result.bytes_transferred == buffer_->Length());
+  if (result.bytes_transferred == 0) {
+    // Either the endpoint is shut down or we've seen the end of the stream
     if (grpc_event_engine_endpoint_data_trace.enabled()) {
-      for (int i = 0; i < buffer_->Count(); i++) {
-        auto str = buffer_->RefSlice(i).as_string_view();
-        gpr_log(GPR_INFO, "WindowsEndpoint::%p READ (peer=%s): %.*s",
-                io_state->endpoint,
-                io_state->endpoint->peer_address_string_.c_str(), str.length(),
-                str.data());
-      }
+      DumpSliceBuffer(
+          buffer_, absl::StrFormat("WindowsEndpoint::%p READ (peer=%s)",
+                                   io_state->endpoint,
+                                   io_state->endpoint->peer_address_string_));
     }
-    return;
+    status = absl::UnavailableError("End of TCP stream");
+    grpc_core::StatusSetInt(&status, grpc_core::StatusIntProperty::kRpcStatus,
+                            GRPC_STATUS_UNAVAILABLE);
+    buffer_->Swap(last_read_buffer_);
+    return ExecuteCallbackAndReset(status);
+  }
+  GPR_DEBUG_ASSERT(result.bytes_transferred > 0);
+  GPR_DEBUG_ASSERT(result.bytes_transferred <= buffer_->Length());
+  buffer_->MoveFirstNBytesIntoSliceBuffer(result.bytes_transferred,
+                                          last_read_buffer_);
+  if (buffer_->Length() == 0) {
+    buffer_->Swap(last_read_buffer_);
+    return ExecuteCallbackAndReset(status);
+  }
+  // Doing another read. Let's keep the AsyncIOState alive a bit longer.
+  io_state_ = std::move(io_state);
+  status = io_state_->endpoint->DoTcpRead(buffer_);
+  if (!status.ok()) {
+    io_state_.reset();
+    ExecuteCallbackAndReset(status);
   }
-  // Either the endpoint is shut down or we've seen the end of the stream
-  buffer_->Clear();
-  status = absl::UnavailableError("End of TCP stream");
+}
+
+bool WindowsEndpoint::HandleReadClosure::MaybeFinishIfDataHasAlreadyBeenRead() {
+  if (last_read_buffer_.Length() > 0) {
+    buffer_->Swap(last_read_buffer_);
+    io_state_->endpoint->executor_->Run(
+        [this]() { ExecuteCallbackAndReset(absl::OkStatus()); });
+    return true;
+  }
+  return false;
+}
+
+void WindowsEndpoint::HandleReadClosure::ExecuteCallbackAndReset(
+    absl::Status status) {
+  auto cb = std::move(cb_);
+  Reset();
+  cb(status);
+}
+
+void WindowsEndpoint::HandleReadClosure::DonateSpareSlices(
+    SliceBuffer* buffer) {
+  // Donee buffer must be empty.
+  GPR_ASSERT(buffer->Length() == 0);
+  // HandleReadClosure must be in the reset state.
+  GPR_ASSERT(buffer_ == nullptr);
+  buffer->Swap(last_read_buffer_);
 }
 
 void WindowsEndpoint::HandleWriteClosure::Run() {
   // Deletes the shared_ptr when this closure returns
   auto io_state = std::move(io_state_);
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Write Event",
-                                   io_state_->endpoint);
+                                   io_state->endpoint);
   auto cb = std::move(cb_);
   const auto result = io_state->socket->write_info()->result();
-  Reset();
   absl::Status status;
   if (result.wsa_error != 0) {
     status = GRPC_WSA_ERROR(result.wsa_error, "WSASend");
   } else {
     GPR_ASSERT(result.bytes_transferred == buffer_->Length());
   }
+  Reset();
   cb(status);
 }
 
 // ---- AsyncIOState ----
 
 WindowsEndpoint::AsyncIOState::AsyncIOState(WindowsEndpoint* endpoint,
-                                            std::unique_ptr<WinSocket> socket)
-    : endpoint(endpoint), socket(std::move(socket)) {}
+                                            std::unique_ptr<WinSocket> socket,
+                                            std::shared_ptr<EventEngine> engine)
+    : endpoint(endpoint),
+      socket(std::move(socket)),
+      engine(std::move(engine)) {}
 
 WindowsEndpoint::AsyncIOState::~AsyncIOState() {
   socket->Shutdown(DEBUG_LOCATION, "~AsyncIOState");

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

@@ -29,17 +29,17 @@ class WindowsEndpoint : public EventEngine::Endpoint {
   WindowsEndpoint(const EventEngine::ResolvedAddress& peer_address,
                   std::unique_ptr<WinSocket> socket,
                   MemoryAllocator&& allocator, const EndpointConfig& config,
-                  Executor* Executor);
+                  Executor* Executor, std::shared_ptr<EventEngine> engine);
   ~WindowsEndpoint() override;
-  void Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
+  bool Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
             const ReadArgs* args) override;
-  void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+  bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,
              SliceBuffer* data, const WriteArgs* args) override;
   const EventEngine::ResolvedAddress& GetPeerAddress() const override;
   const EventEngine::ResolvedAddress& GetLocalAddress() const override;
 
  private:
-  class AsyncIOState;
+  struct AsyncIOState;
 
   // Permanent closure type for Read callbacks
   class HandleReadClosure : public EventEngine::Closure {
@@ -49,11 +49,21 @@ class WindowsEndpoint : public EventEngine::Endpoint {
                absl::AnyInvocable<void(absl::Status)> cb);
     // Resets the per-request data
     void Reset();
+    // Run the callback with whatever data is available, and reset state.
+    //
+    // Returns true if the callback has been called with some data. Returns
+    // false if no data has been read.
+    bool MaybeFinishIfDataHasAlreadyBeenRead();
+    // Execute the callback and reset.
+    void ExecuteCallbackAndReset(absl::Status status);
+    // Swap any leftover slices into the provided buffer
+    void DonateSpareSlices(SliceBuffer* buffer);
 
    private:
     std::shared_ptr<AsyncIOState> io_state_;
     absl::AnyInvocable<void(absl::Status)> cb_;
     SliceBuffer* buffer_ = nullptr;
+    SliceBuffer last_read_buffer_;
   };
 
   // Permanent closure type for Write callbacks
@@ -78,14 +88,20 @@ class WindowsEndpoint : public EventEngine::Endpoint {
   // Endpoint, and be destroyed asynchronously when all pending overlapped
   // events are complete.
   struct AsyncIOState {
-    AsyncIOState(WindowsEndpoint* endpoint, std::unique_ptr<WinSocket> socket);
+    AsyncIOState(WindowsEndpoint* endpoint, std::unique_ptr<WinSocket> socket,
+                 std::shared_ptr<EventEngine> engine);
     ~AsyncIOState();
     WindowsEndpoint* const endpoint;
     std::unique_ptr<WinSocket> socket;
     HandleReadClosure handle_read_event;
     HandleWriteClosure handle_write_event;
+    std::shared_ptr<EventEngine> engine;
   };
 
+  // Perform the low-level calls and execute the HandleReadClosure
+  // asynchronously.
+  absl::Status DoTcpRead(SliceBuffer* buffer);
+
   EventEngine::ResolvedAddress peer_address_;
   std::string peer_address_string_;
   EventEngine::ResolvedAddress local_address_;

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

@@ -37,6 +37,7 @@
 #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/event_engine/windows/windows_listener.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
@@ -106,16 +107,33 @@ WindowsEventEngine::WindowsEventEngine()
 }
 
 WindowsEventEngine::~WindowsEventEngine() {
+  GRPC_EVENT_ENGINE_TRACE("~WindowsEventEngine::%p", this);
   {
-    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());
+    task_mu_.Lock();
+    if (!known_handles_.empty()) {
+      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());
+        }
+      }
+      // Allow a small grace period for timers to be run before shutting down.
+      auto deadline =
+          timer_manager_.Now() + grpc_core::Duration::FromSecondsAsDouble(10);
+      while (!known_handles_.empty() && timer_manager_.Now() < deadline) {
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+          GRPC_LOG_EVERY_N_SEC(1, GPR_DEBUG, "Waiting for timers. %d remaining",
+                               known_handles_.size());
+        }
+        task_mu_.Unlock();
+        absl::SleepFor(absl::Milliseconds(200));
+        task_mu_.Lock();
       }
     }
     GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+    task_mu_.Unlock();
   }
   iocp_.Kick();
   iocp_worker_.WaitForShutdown();
@@ -184,9 +202,11 @@ bool WindowsEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
 void WindowsEventEngine::OnConnectCompleted(
     std::shared_ptr<ConnectionState> state) {
   absl::StatusOr<std::unique_ptr<WindowsEndpoint>> endpoint;
+  EventEngine::OnConnectCallback cb;
   {
     // Connection attempt complete!
     grpc_core::MutexLock lock(&state->mu);
+    cb = std::move(state->on_connected_user_callback);
     state->on_connected = nullptr;
     {
       grpc_core::MutexLock handle_lock(&connection_mu_);
@@ -204,10 +224,10 @@ void WindowsEventEngine::OnConnectCompleted(
       ChannelArgsEndpointConfig cfg;
       endpoint = std::make_unique<WindowsEndpoint>(
           state->address, std::move(state->socket), std::move(state->allocator),
-          cfg, executor_.get());
+          cfg, executor_.get(), shared_from_this());
     }
   }
-  state->on_connected_user_callback(std::move(endpoint));
+  cb(std::move(endpoint));
 }
 
 EventEngine::ConnectionHandle WindowsEventEngine::Connect(
@@ -222,7 +242,7 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     Run([on_connect = std::move(on_connect), status = uri.status()]() mutable {
       on_connect(status);
     });
-    return EventEngine::kInvalidConnectionHandle;
+    return EventEngine::ConnectionHandle::kInvalid;
   }
   GRPC_EVENT_ENGINE_TRACE("EventEngine::%p connecting to %s", this,
                           uri->c_str());
@@ -239,14 +259,14 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
          status = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket")]() mutable {
       on_connect(status);
     });
-    return EventEngine::kInvalidConnectionHandle;
+    return EventEngine::ConnectionHandle::kInvalid;
   }
   status = PrepareSocket(sock);
   if (!status.ok()) {
     Run([on_connect = std::move(on_connect), status]() mutable {
       on_connect(status);
     });
-    return EventEngine::kInvalidConnectionHandle;
+    return EventEngine::ConnectionHandle::kInvalid;
   }
   // Grab the function pointer for ConnectEx for that specific socket It may
   // change depending on the interface.
@@ -263,7 +283,7 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
              "WSAIoctl(SIO_GET_EXTENSION_FUNCTION_POINTER)")]() mutable {
       on_connect(status);
     });
-    return EventEngine::kInvalidConnectionHandle;
+    return EventEngine::ConnectionHandle::kInvalid;
   }
   // bind the local address
   auto local_address = ResolvedAddressMakeWild6(0);
@@ -273,7 +293,7 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
          status = GRPC_WSA_ERROR(WSAGetLastError(), "bind")]() mutable {
       on_connect(status);
     });
-    return EventEngine::kInvalidConnectionHandle;
+    return EventEngine::ConnectionHandle::kInvalid;
   }
   // Connect
   auto watched_socket = iocp_.Watch(sock);
@@ -291,7 +311,7 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
         on_connect(status);
       });
       watched_socket->Shutdown(DEBUG_LOCATION, "ConnectEx");
-      return EventEngine::kInvalidConnectionHandle;
+      return EventEngine::ConnectionHandle::kInvalid;
     }
   }
   GPR_ASSERT(watched_socket != nullptr);
@@ -327,8 +347,7 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
 }
 
 bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
-  if (TaskHandleComparator<ConnectionHandle>::Eq()(
-          handle, EventEngine::kInvalidConnectionHandle)) {
+  if (handle == EventEngine::ConnectionHandle::kInvalid) {
     GRPC_EVENT_ENGINE_TRACE("%s",
                             "Attempted to cancel an invalid connection handle");
     return false;
@@ -379,9 +398,11 @@ WindowsEventEngine::CreateListener(
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     const EndpointConfig& config,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
-  grpc_core::Crash("unimplemented");
+  return std::make_unique<WindowsEventEngineListener>(
+      &iocp_, std::move(on_accept), std::move(on_shutdown),
+      std::move(memory_allocator_factory), shared_from_this(), executor_.get(),
+      config);
 }
-
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

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

@@ -93,6 +93,7 @@ class WindowsEventEngine : public EventEngine,
   // WindowsEventEngine type are effectively friends.
   // Not intended for external use.
   Executor* executor() { return executor_.get(); }
+  IOCP* poller() { return &iocp_; }
 
  private:
   // State of an active connection.
@@ -139,7 +140,7 @@ class WindowsEventEngine : public EventEngine,
   bool CancelConnectInternalStateLocked(ConnectionState* connection_state)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state->mu);
 
-  class TimerClosure;
+  struct TimerClosure;
   EventEngine::TaskHandle RunAfterInternal(Duration when,
                                            absl::AnyInvocable<void()> cb);
   grpc_core::Mutex task_mu_;