mirror of https://github.com/grpc/grpc.git
[EventEngine] WindowsEventEngine Listener v2 (#32488)
Continued from https://github.com/grpc/grpc/pull/32295 after landing the cleanup and logging pieces separately.pull/32493/head
AJ Heller
2 years ago
committed by
GitHub
parent
2ce147a131
commit
8f7cd1eeed
19 changed files with 590 additions and 11 deletions
@ -0,0 +1,365 @@ |
||||
// Copyright 2023 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 "absl/status/status.h" |
||||
#include "absl/strings/str_format.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/windows/iocp.h" |
||||
#include "src/core/lib/event_engine/windows/win_socket.h" |
||||
#include "src/core/lib/event_engine/windows/windows_endpoint.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/iomgr/error.h" |
||||
|
||||
namespace grpc_event_engine { |
||||
namespace experimental { |
||||
|
||||
// ---- SinglePortSocketListener::AsyncIOState ----
|
||||
|
||||
WindowsEventEngineListener::SinglePortSocketListener::AsyncIOState:: |
||||
AsyncIOState(SinglePortSocketListener* port_listener, |
||||
std::unique_ptr<WinSocket> listener_socket) |
||||
: port_listener(port_listener), |
||||
listener_socket(std::move(listener_socket)) {} |
||||
|
||||
WindowsEventEngineListener::SinglePortSocketListener::AsyncIOState:: |
||||
~AsyncIOState() { |
||||
closesocket(accept_socket); |
||||
} |
||||
|
||||
void WindowsEventEngineListener::SinglePortSocketListener:: |
||||
OnAcceptCallbackWrapper::Run() { |
||||
GPR_ASSERT(io_state_ != nullptr); |
||||
grpc_core::ReleasableMutexLock lock(&io_state_->mu); |
||||
if (io_state_->listener_socket->IsShutdown()) { |
||||
GRPC_EVENT_ENGINE_TRACE( |
||||
"SinglePortSocketListener::%p listener socket is shut down. Shutting " |
||||
"down listener.", |
||||
io_state_->port_listener); |
||||
lock.Release(); |
||||
io_state_.reset(); |
||||
return; |
||||
} |
||||
io_state_->port_listener->OnAcceptCallbackLocked(); |
||||
} |
||||
|
||||
void WindowsEventEngineListener::SinglePortSocketListener:: |
||||
OnAcceptCallbackWrapper::Prime(std::shared_ptr<AsyncIOState> io_state) { |
||||
io_state_ = std::move(io_state); |
||||
} |
||||
|
||||
// ---- SinglePortSocketListener ----
|
||||
|
||||
WindowsEventEngineListener::SinglePortSocketListener:: |
||||
~SinglePortSocketListener() { |
||||
io_state_->listener_socket->Shutdown(DEBUG_LOCATION, |
||||
"~SinglePortSocketListener"); |
||||
GRPC_EVENT_ENGINE_TRACE("~SinglePortSocketListener::%p", this); |
||||
} |
||||
|
||||
absl::StatusOr< |
||||
std::unique_ptr<WindowsEventEngineListener::SinglePortSocketListener>> |
||||
WindowsEventEngineListener::SinglePortSocketListener::Create( |
||||
WindowsEventEngineListener* listener, SOCKET sock, |
||||
EventEngine::ResolvedAddress addr) { |
||||
// We need to grab the AcceptEx pointer for that port, as it may be
|
||||
// interface-dependent. We'll cache it to avoid doing that again.
|
||||
GUID guid = WSAID_ACCEPTEX; |
||||
DWORD ioctl_num_bytes; |
||||
LPFN_ACCEPTEX AcceptEx; |
||||
int status = |
||||
WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid), |
||||
&AcceptEx, sizeof(AcceptEx), &ioctl_num_bytes, NULL, NULL); |
||||
if (status != 0) { |
||||
auto error = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket"); |
||||
closesocket(sock); |
||||
return error; |
||||
} |
||||
auto result = SinglePortSocketListener::PrepareListenerSocket(sock, addr); |
||||
GRPC_RETURN_IF_ERROR(result.status()); |
||||
GPR_ASSERT(result->port >= 0); |
||||
// Using `new` to access non-public constructor
|
||||
return absl::WrapUnique(new SinglePortSocketListener( |
||||
listener, AcceptEx, /*win_socket=*/listener->iocp_->Watch(sock), |
||||
result->port, result->hostbyname)); |
||||
} |
||||
|
||||
absl::Status WindowsEventEngineListener::SinglePortSocketListener::Start() { |
||||
grpc_core::MutexLock lock(&io_state_->mu); |
||||
return StartLocked(); |
||||
} |
||||
|
||||
absl::Status |
||||
WindowsEventEngineListener::SinglePortSocketListener::StartLocked() { |
||||
SOCKET accept_socket = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0, |
||||
IOCP::GetDefaultSocketFlags()); |
||||
if (accept_socket == INVALID_SOCKET) { |
||||
return GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket"); |
||||
} |
||||
auto fail = [&](absl::Status error) -> absl::Status { |
||||
if (accept_socket != INVALID_SOCKET) closesocket(accept_socket); |
||||
return error; |
||||
}; |
||||
auto error = PrepareSocket(accept_socket); |
||||
if (!error.ok()) return fail(error); |
||||
// Start the "accept" asynchronously.
|
||||
DWORD addrlen = sizeof(sockaddr_in6) + 16; |
||||
DWORD bytes_received = 0; |
||||
int success = |
||||
AcceptEx(io_state_->listener_socket->raw_socket(), accept_socket, |
||||
addresses_, 0, addrlen, addrlen, &bytes_received, |
||||
io_state_->listener_socket->read_info()->overlapped()); |
||||
// It is possible to get an accept immediately without delay. However, we
|
||||
// will still get an IOCP notification for it. So let's just ignore it.
|
||||
if (success != 0) { |
||||
int last_error = WSAGetLastError(); |
||||
if (last_error != ERROR_IO_PENDING) { |
||||
return fail(GRPC_WSA_ERROR(last_error, "AcceptEx")); |
||||
} |
||||
} |
||||
// We're ready to do the accept. Calling NotifyOnRead may immediately process
|
||||
// an accept that happened in the meantime.
|
||||
io_state_->accept_socket = accept_socket; |
||||
io_state_->listener_socket->NotifyOnRead(&io_state_->on_accept_cb); |
||||
GRPC_EVENT_ENGINE_TRACE( |
||||
"SinglePortSocketListener::%p listening. listener_socket::%p", this, |
||||
io_state_->listener_socket.get()); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
void WindowsEventEngineListener::SinglePortSocketListener:: |
||||
OnAcceptCallbackLocked() { |
||||
auto close_socket_and_restart = |
||||
[&](bool do_close_socket = true) |
||||
ABSL_EXCLUSIVE_LOCKS_REQUIRED(io_state_->mu) { |
||||
if (do_close_socket) closesocket(io_state_->accept_socket); |
||||
io_state_->accept_socket = INVALID_SOCKET; |
||||
GPR_ASSERT(GRPC_LOG_IF_ERROR("SinglePortSocketListener::Start", |
||||
StartLocked())); |
||||
}; |
||||
const auto& overlapped_result = |
||||
io_state_->listener_socket->read_info()->result(); |
||||
if (overlapped_result.wsa_error != 0) { |
||||
gpr_log(GPR_ERROR, "%s", |
||||
GRPC_WSA_ERROR(overlapped_result.wsa_error, |
||||
"Skipping on_accept due to error") |
||||
.ToString() |
||||
.c_str()); |
||||
return close_socket_and_restart(); |
||||
} |
||||
SOCKET tmp_listener_socket = io_state_->listener_socket->raw_socket(); |
||||
int err = |
||||
setsockopt(io_state_->accept_socket, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, |
||||
reinterpret_cast<char*>(&tmp_listener_socket), |
||||
sizeof(tmp_listener_socket)); |
||||
if (err != 0) { |
||||
gpr_log(GPR_ERROR, "%s", |
||||
GRPC_WSA_ERROR(WSAGetLastError(), "setsockopt").ToString().c_str()); |
||||
return close_socket_and_restart(); |
||||
} |
||||
EventEngine::ResolvedAddress peer_address; |
||||
int peer_name_len = EventEngine::ResolvedAddress::MAX_SIZE_BYTES; |
||||
err = getpeername(io_state_->accept_socket, |
||||
const_cast<sockaddr*>(peer_address.address()), |
||||
&peer_name_len); |
||||
if (err != 0) { |
||||
gpr_log( |
||||
GPR_ERROR, "%s", |
||||
GRPC_WSA_ERROR(WSAGetLastError(), "getpeername").ToString().c_str()); |
||||
return close_socket_and_restart(); |
||||
} |
||||
peer_address = |
||||
EventEngine::ResolvedAddress(peer_address.address(), peer_name_len); |
||||
auto addr_uri = ResolvedAddressToURI(peer_address); |
||||
std::string peer_name = "unknown"; |
||||
if (!addr_uri.ok()) { |
||||
// TODO(hork): test an early exit/restart here with end2end tests
|
||||
gpr_log(GPR_ERROR, "invalid peer name: %s", |
||||
addr_uri.status().ToString().c_str()); |
||||
} else { |
||||
peer_name = *addr_uri; |
||||
} |
||||
auto endpoint = std::make_unique<WindowsEndpoint>( |
||||
peer_address, listener_->iocp_->Watch(io_state_->accept_socket), |
||||
listener_->memory_allocator_factory_->CreateMemoryAllocator( |
||||
absl::StrFormat("listener endpoint %s", peer_name)), |
||||
listener_->config_, listener_->executor_); |
||||
listener_->accept_cb_( |
||||
std::move(endpoint), |
||||
listener_->memory_allocator_factory_->CreateMemoryAllocator( |
||||
absl::StrFormat("listener accept cb for %s", peer_name))); |
||||
close_socket_and_restart(/*do_close_socket=*/false); |
||||
} |
||||
|
||||
WindowsEventEngineListener::SinglePortSocketListener::SinglePortSocketListener( |
||||
WindowsEventEngineListener* listener, LPFN_ACCEPTEX AcceptEx, |
||||
std::unique_ptr<WinSocket> listener_socket, int port, |
||||
EventEngine::ResolvedAddress hostbyname) |
||||
: AcceptEx(AcceptEx), |
||||
listener_(listener), |
||||
io_state_( |
||||
std::make_shared<AsyncIOState>(this, std::move(listener_socket))), |
||||
port_(port), |
||||
listener_sockname_(hostbyname) { |
||||
io_state_->on_accept_cb.Prime(io_state_); |
||||
} |
||||
|
||||
absl::StatusOr<WindowsEventEngineListener::SinglePortSocketListener:: |
||||
PrepareListenerSocketResult> |
||||
WindowsEventEngineListener::SinglePortSocketListener::PrepareListenerSocket( |
||||
SOCKET sock, const EventEngine::ResolvedAddress& addr) { |
||||
auto fail = [&](absl::Status error) -> absl::Status { |
||||
GPR_ASSERT(!error.ok()); |
||||
auto addr_uri = ResolvedAddressToURI(addr); |
||||
error = grpc_error_set_int( |
||||
grpc_error_set_str( |
||||
GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket", |
||||
&error, 1), |
||||
grpc_core::StatusStrProperty::kTargetAddress, |
||||
addr_uri.ok() ? *addr_uri : addr_uri.status().ToString()), |
||||
grpc_core::StatusIntProperty::kFd, static_cast<intptr_t>(sock)); |
||||
if (sock != INVALID_SOCKET) closesocket(sock); |
||||
return error; |
||||
}; |
||||
auto error = PrepareSocket(sock); |
||||
if (!error.ok()) return fail(error); |
||||
if (bind(sock, addr.address(), addr.size()) == SOCKET_ERROR) { |
||||
return fail(GRPC_WSA_ERROR(WSAGetLastError(), "bind")); |
||||
} |
||||
if (listen(sock, SOMAXCONN) == SOCKET_ERROR) { |
||||
return fail(GRPC_WSA_ERROR(WSAGetLastError(), "listen")); |
||||
} |
||||
int sockname_temp_len = sizeof(struct sockaddr_storage); |
||||
EventEngine::ResolvedAddress sockname_temp; |
||||
if (getsockname(sock, const_cast<sockaddr*>(sockname_temp.address()), |
||||
&sockname_temp_len) == SOCKET_ERROR) { |
||||
return fail(GRPC_WSA_ERROR(WSAGetLastError(), "getsockname")); |
||||
} |
||||
sockname_temp = |
||||
EventEngine::ResolvedAddress(sockname_temp.address(), sockname_temp_len); |
||||
return PrepareListenerSocketResult{ResolvedAddressGetPort(sockname_temp), |
||||
sockname_temp}; |
||||
} |
||||
|
||||
// ---- WindowsEventEngineListener ----
|
||||
|
||||
WindowsEventEngineListener::WindowsEventEngineListener( |
||||
IOCP* iocp, AcceptCallback accept_cb, |
||||
absl::AnyInvocable<void(absl::Status)> on_shutdown, |
||||
std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory, |
||||
std::shared_ptr<EventEngine> engine, Executor* executor, |
||||
const EndpointConfig& config) |
||||
: iocp_(iocp), |
||||
config_(config), |
||||
engine_(std::move(engine)), |
||||
executor_(executor), |
||||
memory_allocator_factory_(std::move(memory_allocator_factory)), |
||||
accept_cb_(std::move(accept_cb)), |
||||
on_shutdown_(std::move(on_shutdown)) {} |
||||
|
||||
WindowsEventEngineListener::~WindowsEventEngineListener() { |
||||
GRPC_EVENT_ENGINE_TRACE( |
||||
"%s", |
||||
absl::StrFormat("WindowsEventEngineListener::%p shutting down", this) |
||||
.c_str()); |
||||
// Shut down each port listener before destroying this EventEngine::Listener
|
||||
for (auto& port_listener : port_listeners_) { |
||||
port_listener.reset(); |
||||
} |
||||
on_shutdown_(absl::OkStatus()); |
||||
} |
||||
|
||||
absl::StatusOr<int> WindowsEventEngineListener::Bind( |
||||
const EventEngine::ResolvedAddress& addr) { |
||||
if (started_.load()) { |
||||
return absl::FailedPreconditionError( |
||||
absl::StrFormat("WindowsEventEngineListener::%p is already started, " |
||||
"ports can no longer be bound", |
||||
this)); |
||||
} |
||||
int out_port = ResolvedAddressGetPort(addr); |
||||
EventEngine::ResolvedAddress out_addr(addr); |
||||
EventEngine::ResolvedAddress tmp_addr; |
||||
// Check if this is a wildcard port, and if so, try to keep the port the same
|
||||
// as some previously created listener.
|
||||
if (out_port == 0) { |
||||
grpc_core::MutexLock lock(&socket_listeners_mu_); |
||||
for (const auto& port_listener : port_listeners_) { |
||||
tmp_addr = port_listener->listener_sockname(); |
||||
out_port = ResolvedAddressGetPort(tmp_addr); |
||||
if (out_port > 0) { |
||||
ResolvedAddressSetPort(out_addr, out_port); |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
if (ResolvedAddressToV4Mapped(out_addr, &tmp_addr)) { |
||||
out_addr = tmp_addr; |
||||
} |
||||
// Treat :: or 0.0.0.0 as a family-agnostic wildcard.
|
||||
if (ResolvedAddressIsWildcard(out_addr)) { |
||||
out_addr = ResolvedAddressMakeWild6(out_port); |
||||
} |
||||
// open the socket
|
||||
SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, nullptr, 0, |
||||
IOCP::GetDefaultSocketFlags()); |
||||
if (sock == INVALID_SOCKET) { |
||||
auto error = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket"); |
||||
return GRPC_ERROR_CREATE_REFERENCING("Failed to add port to server", &error, |
||||
1); |
||||
} |
||||
auto port_listener = AddSinglePortSocketListener(sock, out_addr); |
||||
GRPC_RETURN_IF_ERROR(port_listener.status()); |
||||
return (*port_listener)->port(); |
||||
} |
||||
|
||||
absl::Status WindowsEventEngineListener::Start() { |
||||
GPR_ASSERT(!started_.exchange(true)); |
||||
grpc_core::MutexLock lock(&socket_listeners_mu_); |
||||
for (auto& port_listener : port_listeners_) { |
||||
GRPC_RETURN_IF_ERROR(port_listener->Start()); |
||||
} |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::StatusOr<WindowsEventEngineListener::SinglePortSocketListener*> |
||||
WindowsEventEngineListener::AddSinglePortSocketListener( |
||||
SOCKET sock, EventEngine::ResolvedAddress addr) { |
||||
auto single_port_listener = |
||||
SinglePortSocketListener::Create(this, sock, addr); |
||||
GRPC_RETURN_IF_ERROR(single_port_listener.status()); |
||||
auto* single_port_listener_ptr = single_port_listener->get(); |
||||
grpc_core::MutexLock lock(&socket_listeners_mu_); |
||||
port_listeners_.emplace_back(std::move(*single_port_listener)); |
||||
if (started_.load()) { |
||||
gpr_log(GPR_ERROR, |
||||
"WindowsEventEngineListener::%p Bind was called concurrently while " |
||||
"the Listener was starting. This is invalid usage, all ports must " |
||||
"be bound before the Listener is started.", |
||||
this); |
||||
single_port_listener_ptr->Start(); |
||||
} |
||||
return single_port_listener_ptr; |
||||
} |
||||
|
||||
} // namespace experimental
|
||||
} // namespace grpc_event_engine
|
||||
|
||||
#endif // GPR_WINDOWS
|
||||
@ -0,0 +1,151 @@ |
||||
// Copyright 2023 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_LISTENER_H |
||||
#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_LISTENER_H |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#ifdef GPR_WINDOWS |
||||
|
||||
#include <list> |
||||
|
||||
#include "absl/base/thread_annotations.h" |
||||
#include "absl/status/statusor.h" |
||||
|
||||
#include <grpc/event_engine/event_engine.h> |
||||
#include <grpc/event_engine/memory_allocator.h> |
||||
|
||||
#include "src/core/lib/event_engine/common_closures.h" |
||||
#include "src/core/lib/event_engine/windows/iocp.h" |
||||
#include "src/core/lib/gprpp/sync.h" |
||||
|
||||
namespace grpc_event_engine { |
||||
namespace experimental { |
||||
|
||||
class WindowsEventEngineListener : public EventEngine::Listener { |
||||
public: |
||||
WindowsEventEngineListener( |
||||
IOCP* iocp, AcceptCallback accept_cb, |
||||
absl::AnyInvocable<void(absl::Status)> on_shutdown, |
||||
std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory, |
||||
std::shared_ptr<EventEngine> engine, Executor* executor_, |
||||
const EndpointConfig& config); |
||||
~WindowsEventEngineListener() override; |
||||
absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr) override; |
||||
absl::Status Start() override; |
||||
|
||||
private: |
||||
/// Responsible for listening on a single port.
|
||||
class SinglePortSocketListener { |
||||
public: |
||||
~SinglePortSocketListener(); |
||||
// This factory will create a bound, listening WinSocket, registered with
|
||||
// the listener's IOCP poller.
|
||||
static absl::StatusOr<std::unique_ptr<SinglePortSocketListener>> Create( |
||||
WindowsEventEngineListener* listener, SOCKET sock, |
||||
EventEngine::ResolvedAddress addr); |
||||
|
||||
// Two-stage initialization, allows creation of all bound sockets before the
|
||||
// listener is started.
|
||||
absl::Status Start(); |
||||
absl::Status StartLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(io_state_->mu); |
||||
|
||||
// Accessor methods
|
||||
EventEngine::ResolvedAddress listener_sockname() { |
||||
return listener_sockname_; |
||||
}; |
||||
int port() { return port_; } |
||||
|
||||
private: |
||||
struct AsyncIOState; |
||||
|
||||
class OnAcceptCallbackWrapper : public EventEngine::Closure { |
||||
public: |
||||
void Run() override; |
||||
void Prime(std::shared_ptr<AsyncIOState> io_state); |
||||
|
||||
private: |
||||
std::shared_ptr<AsyncIOState> io_state_; |
||||
}; |
||||
|
||||
// A class to manage the data that must outlive the Endpoint.
|
||||
//
|
||||
// Once a listener is done and destroyed, there still may be overlapped
|
||||
// operations pending. To clean up safely, this data must outlive the
|
||||
// Listener, and be destroyed asynchronously when all pending overlapped
|
||||
// events are complete.
|
||||
struct AsyncIOState { |
||||
AsyncIOState(SinglePortSocketListener* port_listener, |
||||
std::unique_ptr<WinSocket> listener_socket); |
||||
~AsyncIOState(); |
||||
SinglePortSocketListener* const port_listener; |
||||
OnAcceptCallbackWrapper on_accept_cb; |
||||
// Synchronize accept handling on the same socket.
|
||||
grpc_core::Mutex mu; |
||||
// This will hold the socket for the next accept.
|
||||
SOCKET accept_socket ABSL_GUARDED_BY(mu) = INVALID_SOCKET; |
||||
// The listener winsocket.
|
||||
std::unique_ptr<WinSocket> listener_socket ABSL_GUARDED_BY(mu); |
||||
}; |
||||
|
||||
SinglePortSocketListener(WindowsEventEngineListener* listener, |
||||
LPFN_ACCEPTEX AcceptEx, |
||||
std::unique_ptr<WinSocket> listener_socket, |
||||
int port, EventEngine::ResolvedAddress hostbyname); |
||||
|
||||
// Bind a recently-created socket for listening
|
||||
struct PrepareListenerSocketResult { |
||||
int port; |
||||
EventEngine::ResolvedAddress hostbyname; |
||||
}; |
||||
static absl::StatusOr<PrepareListenerSocketResult> PrepareListenerSocket( |
||||
SOCKET sock, const EventEngine::ResolvedAddress& addr); |
||||
|
||||
void OnAcceptCallbackLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(io_state_->mu); |
||||
|
||||
// The cached AcceptEx for that port.
|
||||
LPFN_ACCEPTEX AcceptEx; |
||||
// This seemingly magic number comes from AcceptEx's documentation. each
|
||||
// address buffer needs to have at least 16 more bytes at their end.
|
||||
uint8_t addresses_[(sizeof(sockaddr_in6) + 16) * 2] = {}; |
||||
// The parent listener
|
||||
WindowsEventEngineListener* listener_; |
||||
// shared state for asynchronous cleanup of overlapped operations
|
||||
std::shared_ptr<AsyncIOState> io_state_; |
||||
// The actual TCP port number.
|
||||
int port_; |
||||
EventEngine::ResolvedAddress listener_sockname_; |
||||
}; |
||||
absl::StatusOr<SinglePortSocketListener*> AddSinglePortSocketListener( |
||||
SOCKET sock, EventEngine::ResolvedAddress addr); |
||||
|
||||
IOCP* const iocp_; |
||||
const EndpointConfig& config_; |
||||
std::shared_ptr<EventEngine> engine_; |
||||
Executor* executor_; |
||||
const std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory_; |
||||
AcceptCallback accept_cb_; |
||||
absl::AnyInvocable<void(absl::Status)> on_shutdown_; |
||||
std::atomic<bool> started_{false}; |
||||
grpc_core::Mutex socket_listeners_mu_; |
||||
std::list<std::unique_ptr<SinglePortSocketListener>> port_listeners_ |
||||
ABSL_GUARDED_BY(socket_listeners_mu_); |
||||
}; |
||||
|
||||
} // namespace experimental
|
||||
} // namespace grpc_event_engine
|
||||
|
||||
#endif |
||||
|
||||
#endif // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_LISTENER_H
|
||||
Loading…
Reference in new issue