grpc 1.51.0 → 1.52.0.pre2

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

@@ -21,6 +21,7 @@
 #include <cstring>
 #include <memory>
 #include <string>
+#include <type_traits>
 #include <utility>
 
 #include "absl/cleanup/cleanup.h"
@@ -37,9 +38,10 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/timer.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/experiments/experiments.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -50,6 +52,7 @@
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller_posix_default.h"
 #include "src/core/lib/event_engine/posix_engine/posix_endpoint.h"
+#include "src/core/lib/event_engine/posix_engine/posix_engine_listener.h"
 #endif  // GRPC_POSIX_SOCKET_TCP
 
 // IWYU pragma: no_include <ratio>
@@ -60,13 +63,6 @@ namespace grpc_event_engine {
 namespace experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
-using ::grpc_event_engine::posix_engine::EventHandle;
-using ::grpc_event_engine::posix_engine::PosixEngineClosure;
-using ::grpc_event_engine::posix_engine::PosixEventPoller;
-using ::grpc_event_engine::posix_engine::PosixSocketWrapper;
-using ::grpc_event_engine::posix_engine::PosixTcpOptions;
-using ::grpc_event_engine::posix_engine::SockaddrToString;
-using ::grpc_event_engine::posix_engine::TcpOptionsFromEndpointConfig;
 
 void AsyncConnect::Start(EventEngine::Duration timeout) {
   on_writable_ = PosixEngineClosure::ToPermanentClosure(
@@ -136,9 +132,8 @@ void AsyncConnect::OnWritable(absl::Status status)
       fd = nullptr;
     }
     if (!status.ok()) {
-      ep = absl::CancelledError(
-          absl::StrCat("Failed to connect to remote host: ", resolved_addr_str_,
-                       " with error: ", status.ToString()));
+      ep = absl::UnknownError(
+          absl::StrCat("Failed to connect to remote host: ", status.message()));
     }
     // Run the OnConnect callback asynchronously.
     if (!connect_cancelled) {
@@ -201,8 +196,7 @@ void AsyncConnect::OnWritable(absl::Status status)
       return;
     case ECONNREFUSED:
       // This error shouldn't happen for anything other than connect().
-      status = absl::FailedPreconditionError(
-          absl::StrCat("connect: ", std::strerror(so_error)));
+      status = absl::FailedPreconditionError(std::strerror(so_error));
       break;
     default:
       // We don't really know which syscall triggered the problem here, so
@@ -224,7 +218,7 @@ EventEngine::ConnectionHandle PosixEventEngine::ConnectInternal(
   } while (err < 0 && errno == EINTR);
   saved_errno = errno;
 
-  auto addr_uri = SockaddrToString(&addr, true);
+  auto addr_uri = ResolvedAddressToURI(addr);
   if (!addr_uri.ok()) {
     Run([on_connect = std::move(on_connect),
          ep = absl::FailedPreconditionError(absl::StrCat(
@@ -290,7 +284,7 @@ void PosixEventEngine::OnConnectFinishInternal(int connection_handle) {
 
 PosixEnginePollerManager::PosixEnginePollerManager(
     std::shared_ptr<ThreadPool> executor)
-    : poller_(grpc_event_engine::posix_engine::MakeDefaultPoller(this)),
+    : poller_(grpc_event_engine::experimental::MakeDefaultPoller(this)),
       executor_(std::move(executor)) {}
 
 PosixEnginePollerManager::PosixEnginePollerManager(PosixEventPoller* poller)
@@ -341,13 +335,11 @@ PosixEventEngine::PosixEventEngine()
     : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
       executor_(std::make_shared<ThreadPool>()),
       timer_manager_(executor_) {
-  if (grpc_core::IsPosixEventEngineEnablePollingEnabled()) {
-    poller_manager_ = std::make_shared<PosixEnginePollerManager>(executor_);
-    if (poller_manager_->Poller() != nullptr) {
-      executor_->Run([poller_manager = poller_manager_]() {
-        PollerWorkInternal(poller_manager);
-      });
-    }
+  poller_manager_ = std::make_shared<PosixEnginePollerManager>(executor_);
+  if (poller_manager_->Poller() != nullptr) {
+    executor_->Run([poller_manager = poller_manager_]() {
+      PollerWorkInternal(poller_manager);
+    });
   }
 }
 
@@ -388,7 +380,7 @@ void PosixEventEngine::PollerWorkInternal(
 
 struct PosixEventEngine::ClosureData final : public EventEngine::Closure {
   absl::AnyInvocable<void()> cb;
-  posix_engine::Timer timer;
+  Timer timer;
   PosixEventEngine* engine;
   EventEngine::TaskHandle handle;
 
@@ -474,12 +466,10 @@ EventEngine::TaskHandle PosixEventEngine::RunAfterInternal(
 
 std::unique_ptr<EventEngine::DNSResolver> PosixEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
-bool PosixEventEngine::IsWorkerThread() {
-  GPR_ASSERT(false && "unimplemented");
-}
+bool PosixEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
 
 bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -532,8 +522,8 @@ bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
   }
   return connection_cancel_success;
 #else   // GRPC_POSIX_SOCKET_TCP
-  GPR_ASSERT(false &&
-             "EventEngine::CancelConnect is not supported on this platform");
+  grpc_core::Crash(
+      "EventEngine::CancelConnect is not supported on this platform");
 #endif  // GRPC_POSIX_SOCKET_TCP
 }
 
@@ -542,11 +532,6 @@ EventEngine::ConnectionHandle PosixEventEngine::Connect(
     const EndpointConfig& args, MemoryAllocator memory_allocator,
     Duration timeout) {
 #ifdef GRPC_POSIX_SOCKET_TCP
-  if (!grpc_core::IsPosixEventEngineEnablePollingEnabled()) {
-    GPR_ASSERT(
-        false &&
-        "EventEngine::Connect is not supported because polling is not enabled");
-  }
   GPR_ASSERT(poller_manager_ != nullptr);
   PosixTcpOptions options = TcpOptionsFromEndpointConfig(args);
   absl::StatusOr<PosixSocketWrapper::PosixSocketCreateResult> socket =
@@ -560,17 +545,25 @@ EventEngine::ConnectionHandle PosixEventEngine::Connect(
                          (*socket).mapped_target_addr,
                          std::move(memory_allocator), options, timeout);
 #else   // GRPC_POSIX_SOCKET_TCP
-  GPR_ASSERT(false && "EventEngine::Connect is not supported on this platform");
+  grpc_core::Crash("EventEngine::Connect is not supported on this platform");
 #endif  // GRPC_POSIX_SOCKET_TCP
 }
 
 absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
 PosixEventEngine::CreateListener(
-    Listener::AcceptCallback /*on_accept*/,
-    absl::AnyInvocable<void(absl::Status)> /*on_shutdown*/,
-    const EndpointConfig& /*config*/,
-    std::unique_ptr<MemoryAllocatorFactory> /*memory_allocator_factory*/) {
-  GPR_ASSERT(false && "unimplemented");
+    Listener::AcceptCallback on_accept,
+    absl::AnyInvocable<void(absl::Status)> on_shutdown,
+    const EndpointConfig& config,
+    std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
+#ifdef GRPC_POSIX_SOCKET_TCP
+  return std::make_unique<PosixEngineListener>(
+      std::move(on_accept), std::move(on_shutdown), config,
+      std::move(memory_allocator_factory), poller_manager_->Poller(),
+      shared_from_this());
+#else   // GRPC_POSIX_SOCKET_TCP
+  grpc_core::Crash(
+      "EventEngine::CreateListener is not supported on this platform");
+#endif  // GRPC_POSIX_SOCKET_TCP
 }
 
 }  // namespace experimental

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

@@ -56,9 +56,9 @@ class AsyncConnect {
  public:
   AsyncConnect(EventEngine::OnConnectCallback on_connect,
                std::shared_ptr<EventEngine> engine, ThreadPool* executor,
-               grpc_event_engine::posix_engine::EventHandle* fd,
+               grpc_event_engine::experimental::EventHandle* fd,
                MemoryAllocator&& allocator,
-               const grpc_event_engine::posix_engine::PosixTcpOptions& options,
+               const grpc_event_engine::experimental::PosixTcpOptions& options,
                std::string resolved_addr_str, int64_t connection_handle)
       : on_connect_(std::move(on_connect)),
         engine_(engine),
@@ -80,15 +80,15 @@ class AsyncConnect {
   void OnWritable(absl::Status status) ABSL_NO_THREAD_SAFETY_ANALYSIS;
 
   grpc_core::Mutex mu_;
-  grpc_event_engine::posix_engine::PosixEngineClosure* on_writable_ = nullptr;
+  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::posix_engine::EventHandle* fd_;
+  grpc_event_engine::experimental::EventHandle* fd_;
   MemoryAllocator allocator_;
-  grpc_event_engine::posix_engine::PosixTcpOptions options_;
+  grpc_event_engine::experimental::PosixTcpOptions options_;
   std::string resolved_addr_str_;
   int64_t connection_handle_;
   bool connect_cancelled_;
@@ -97,12 +97,12 @@ class AsyncConnect {
 // 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 grpc_event_engine::experimental::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() {
+      grpc_event_engine::experimental::PosixEventPoller* poller);
+  grpc_event_engine::experimental::PosixEventPoller* Poller() {
     return poller_;
   }
 
@@ -121,7 +121,7 @@ class PosixEnginePollerManager
 
  private:
   enum class PollerState { kExternal, kOk, kShuttingDown };
-  grpc_event_engine::posix_engine::PosixEventPoller* poller_ = nullptr;
+  grpc_event_engine::experimental::PosixEventPoller* poller_ = nullptr;
   std::atomic<PollerState> poller_state_{PollerState::kOk};
   std::shared_ptr<ThreadPool> executor_;
 };
@@ -155,7 +155,7 @@ class PosixEventEngine final : public EventEngine,
   // 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);
+      grpc_event_engine::experimental::PosixEventPoller* poller);
   PosixEventEngine();
 #else   // GRPC_POSIX_SOCKET_TCP
   PosixEventEngine();
@@ -194,7 +194,7 @@ class PosixEventEngine final : public EventEngine,
   // 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) {
+      grpc_event_engine::experimental::PosixEventPoller* test_only_poller) {
     return std::make_shared<PosixEventEngine>(test_only_poller);
   }
 #endif  // GRPC_POSIX_SOCKET_TCP
@@ -216,10 +216,10 @@ class PosixEventEngine final : public EventEngine,
       std::shared_ptr<PosixEnginePollerManager> poller_manager);
 
   ConnectionHandle ConnectInternal(
-      grpc_event_engine::posix_engine::PosixSocketWrapper sock,
+      grpc_event_engine::experimental::PosixSocketWrapper sock,
       OnConnectCallback on_connect, ResolvedAddress addr,
       MemoryAllocator&& allocator,
-      const grpc_event_engine::posix_engine::PosixTcpOptions& options,
+      const grpc_event_engine::experimental::PosixTcpOptions& options,
       Duration timeout);
 
   void OnConnectFinishInternal(int connection_handle);
@@ -233,7 +233,7 @@ class PosixEventEngine final : public EventEngine,
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
   std::atomic<intptr_t> aba_token_{0};
   std::shared_ptr<ThreadPool> executor_;
-  posix_engine::TimerManager timer_manager_;
+  TimerManager timer_manager_;
 #ifdef GRPC_POSIX_SOCKET_TCP
   std::shared_ptr<PosixEnginePollerManager> poller_manager_;
 #endif  // GRPC_POSIX_SOCKET_TCP

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

@@ -24,7 +24,7 @@
 #include <grpc/event_engine/event_engine.h>
 
 namespace grpc_event_engine {
-namespace posix_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
@@ -74,7 +74,7 @@ class PosixEngineClosure final
   absl::Status status_;
 };
 
-}  // namespace posix_engine
+}  // 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