grpc 1.38.0 → 1.40.0

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

@@ -0,0 +1,24 @@
+// Copyright 2021 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_IOMGR_EVENT_ENGINE_IOMGR_H
+#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_IOMGR_H
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+// This can be called anywhere in the EE-based iomgr impl where we need to
+// access the global EE instance.
+grpc_event_engine::experimental::EventEngine* grpc_iomgr_event_engine();
+
+#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_IOMGR_H

data/src/core/lib/iomgr/event_engine/pollset.cc

@@ -0,0 +1,87 @@
+// Copyright 2021 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 GRPC_USE_EVENT_ENGINE
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/iomgr/event_engine/pollset.h"
+#include "src/core/lib/iomgr/iomgr_internal.h"
+#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+
+namespace {
+
+static gpr_mu g_mu;
+static gpr_cv g_cv;
+
+// --- pollset vtable API ---
+void pollset_global_init(void) {
+  gpr_mu_init(&g_mu);
+  gpr_cv_init(&g_cv);
+}
+void pollset_global_shutdown(void) {
+  gpr_cv_destroy(&g_cv);
+  gpr_mu_destroy(&g_mu);
+}
+void pollset_init(grpc_pollset* pollset, gpr_mu** mu) { *mu = &g_mu; }
+void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
+}
+void pollset_destroy(grpc_pollset* pollset) {}
+grpc_error* pollset_work(grpc_pollset* pollset, grpc_pollset_worker** worker,
+                         grpc_millis deadline) {
+  (void)worker;
+  gpr_cv_wait(&g_cv, &g_mu,
+              grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME));
+  return GRPC_ERROR_NONE;
+}
+grpc_error* pollset_kick(grpc_pollset* pollset,
+                         grpc_pollset_worker* specific_worker) {
+  (void)pollset;
+  (void)specific_worker;
+  return GRPC_ERROR_NONE;
+}
+size_t pollset_size(void) { return 1; }
+
+// --- pollset_set vtable API ---
+grpc_pollset_set* pollset_set_create(void) { return nullptr; }
+void pollset_set_destroy(grpc_pollset_set* pollset_set) {}
+void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
+                             grpc_pollset* pollset) {}
+
+void pollset_set_del_pollset(grpc_pollset_set* pollset_set,
+                             grpc_pollset* pollset) {}
+void pollset_set_add_pollset_set(grpc_pollset_set* bag,
+                                 grpc_pollset_set* item) {}
+void pollset_set_del_pollset_set(grpc_pollset_set* bag,
+                                 grpc_pollset_set* item) {}
+
+}  // namespace
+
+void grpc_pollset_ee_broadcast_event() { gpr_cv_signal(&g_cv); }
+
+// --- vtables ---
+grpc_pollset_vtable grpc_event_engine_pollset_vtable = {
+    pollset_global_init, pollset_global_shutdown,
+    pollset_init,        pollset_shutdown,
+    pollset_destroy,     pollset_work,
+    pollset_kick,        pollset_size};
+
+grpc_pollset_set_vtable grpc_event_engine_pollset_set_vtable = {
+    pollset_set_create,          pollset_set_destroy,
+    pollset_set_add_pollset,     pollset_set_del_pollset,
+    pollset_set_add_pollset_set, pollset_set_del_pollset_set};
+
+#endif  // GRPC_USE_EVENT_ENGINE

data/{include/grpc/event_engine/channel_args.h → src/core/lib/iomgr/event_engine/pollset.h}

@@ -11,18 +11,15 @@
 // 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_EVENT_ENGINE_CHANNEL_ARGS_H
-#define GRPC_EVENT_ENGINE_CHANNEL_ARGS_H
+#ifndef GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_POLLSET_H
+#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_POLLSET_H
 
 #include <grpc/support/port_platform.h>
 
-namespace grpc_event_engine {
-namespace experimental {
+#ifdef GRPC_USE_EVENT_ENGINE
 
-// TODO(hork): define
-class ChannelArgs;
+/// Signals pollset_work that some work has been done.
+void grpc_pollset_ee_broadcast_event();
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
-
-#endif  // GRPC_EVENT_ENGINE_CHANNEL_ARGS_H
+#endif
+#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_POLLSET_H

data/src/core/lib/iomgr/event_engine/promise.h

@@ -0,0 +1,51 @@
+// Copyright 2021 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_IOMGR_EVENT_ENGINE_PROMISE_H
+#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_PROMISE_H
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// A minimal promise implementation.
+///
+/// This is light-duty, syntactical sugar around cv wait & signal, which is
+/// useful in some cases. A more robust implementation is being worked on
+/// separately.
+template <typename T>
+class Promise {
+ public:
+  T& Get() {
+    absl::MutexLock lock(&mu_);
+    cv_.Wait(&mu_);
+    return val_;
+  }
+  void Set(T&& val) {
+    absl::MutexLock lock(&mu_);
+    val_ = std::move(val);
+    cv_.Signal();
+  }
+
+ private:
+  absl::Mutex mu_;
+  absl::CondVar cv_;
+  T val_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_PROMISE_H

data/src/core/lib/iomgr/event_engine/resolved_address_internal.cc

@@ -0,0 +1,41 @@
+// Copyright 2021 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>
+
+#include "src/core/lib/iomgr/event_engine/resolved_address_internal.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+EventEngine::ResolvedAddress CreateResolvedAddress(
+    const grpc_resolved_address& addr) {
+  return EventEngine::ResolvedAddress(
+      reinterpret_cast<const sockaddr*>(addr.addr), addr.len);
+}
+
+grpc_resolved_address CreateGRPCResolvedAddress(
+    const EventEngine::ResolvedAddress& ra) {
+  grpc_resolved_address grpc_addr;
+  memcpy(grpc_addr.addr, ra.address(), ra.size());
+  grpc_addr.len = ra.size();
+  return grpc_addr;
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/iomgr/event_engine/resolved_address_internal.h

@@ -0,0 +1,35 @@
+// Copyright 2021 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_IOMGR_EVENT_ENGINE_RESOLVED_ADDRESS_INTERNAL_H
+#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVED_ADDRESS_INTERNAL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+EventEngine::ResolvedAddress CreateResolvedAddress(
+    const grpc_resolved_address& addr);
+
+grpc_resolved_address CreateGRPCResolvedAddress(
+    const EventEngine::ResolvedAddress& ra);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVED_ADDRESS_INTERNAL_H

data/src/core/lib/iomgr/event_engine/resolver.cc

@@ -0,0 +1,110 @@
+// Copyright 2021 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 GRPC_USE_EVENT_ENGINE
+#include <grpc/event_engine/event_engine.h>
+#include "absl/functional/bind_front.h"
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/event_engine/iomgr.h"
+#include "src/core/lib/iomgr/event_engine/promise.h"
+#include "src/core/lib/iomgr/event_engine/resolved_address_internal.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/surface/init.h"
+#include "src/core/lib/transport/error_utils.h"
+
+namespace {
+using ::grpc_event_engine::experimental::CreateGRPCResolvedAddress;
+using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::Promise;
+
+/// A fire-and-forget class representing an individual DNS request.
+///
+/// This provides a place to store the ownership of the DNSResolver object until
+/// the request is complete.
+class DnsRequest {
+ public:
+  DnsRequest(std::unique_ptr<EventEngine::DNSResolver> dns_resolver,
+             absl::string_view address, absl::string_view default_port,
+             grpc_closure* on_done, grpc_resolved_addresses** addresses)
+      : dns_resolver_(std::move(dns_resolver)),
+        cb_(on_done),
+        addresses_(addresses) {
+    dns_resolver_->LookupHostname(
+        absl::bind_front(&DnsRequest::OnLookupComplete, this), address,
+        default_port, absl::InfiniteFuture());
+  }
+
+ private:
+  void OnLookupComplete(
+      absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses) {
+    grpc_core::ExecCtx exec_ctx;
+    // Convert addresses to iomgr form.
+    *addresses_ = static_cast<grpc_resolved_addresses*>(
+        gpr_malloc(sizeof(grpc_resolved_addresses)));
+    (*addresses_)->naddrs = addresses->size();
+    (*addresses_)->addrs = static_cast<grpc_resolved_address*>(
+        gpr_malloc(sizeof(grpc_resolved_address) * addresses->size()));
+    for (size_t i = 0; i < addresses->size(); ++i) {
+      (*addresses_)->addrs[i] = CreateGRPCResolvedAddress((*addresses)[i]);
+    }
+    grpc_closure* cb = cb_;
+    delete this;
+    grpc_core::Closure::Run(DEBUG_LOCATION, cb,
+                            absl_status_to_grpc_error(addresses.status()));
+  }
+
+  std::unique_ptr<EventEngine::DNSResolver> dns_resolver_;
+  grpc_closure* cb_;
+  grpc_resolved_addresses** addresses_;
+};
+
+void resolve_address(const char* addr, const char* default_port,
+                     grpc_pollset_set* /* interested_parties */,
+                     grpc_closure* on_done,
+                     grpc_resolved_addresses** addresses) {
+  auto dns_resolver = grpc_iomgr_event_engine()->GetDNSResolver();
+  if (!dns_resolver.ok()) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done,
+                            absl_status_to_grpc_error(dns_resolver.status()));
+    return;
+  }
+  new DnsRequest(std::move(*dns_resolver), addr, default_port, on_done,
+                 addresses);
+}
+
+void blocking_handle_async_resolve_done(void* arg, grpc_error_handle error) {
+  static_cast<Promise<grpc_error_handle>*>(arg)->Set(std::move(error));
+}
+
+grpc_error* blocking_resolve_address(const char* name, const char* default_port,
+                                     grpc_resolved_addresses** addresses) {
+  grpc_closure on_done;
+  Promise<grpc_error_handle> evt;
+  GRPC_CLOSURE_INIT(&on_done, blocking_handle_async_resolve_done, &evt,
+                    grpc_schedule_on_exec_ctx);
+  resolve_address(name, default_port, nullptr, &on_done, addresses);
+  return evt.Get();
+}
+
+}  // namespace
+
+grpc_address_resolver_vtable grpc_event_engine_resolver_vtable{
+    resolve_address, blocking_resolve_address};
+
+#endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/event_engine/tcp.cc

@@ -0,0 +1,263 @@
+// Copyright 2021 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 GRPC_USE_EVENT_ENGINE
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/event_engine/endpoint_config_internal.h"
+#include "src/core/lib/event_engine/sockaddr.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/iomgr/event_engine/closure.h"
+#include "src/core/lib/iomgr/event_engine/endpoint.h"
+#include "src/core/lib/iomgr/event_engine/iomgr.h"
+#include "src/core/lib/iomgr/event_engine/pollset.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/tcp_client.h"
+#include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/surface/init.h"
+#include "src/core/lib/transport/error_utils.h"
+
+extern grpc_core::TraceFlag grpc_tcp_trace;
+
+namespace {
+using ::grpc_event_engine::experimental::ChannelArgsEndpointConfig;
+using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::GrpcClosureToCallback;
+using ::grpc_event_engine::experimental::SliceAllocator;
+using ::grpc_event_engine::experimental::SliceAllocatorFactory;
+using ::grpc_event_engine::experimental::SliceBuffer;
+}  // namespace
+
+// TODO(hork): remove these classes in PR #26643, when the iomgr APIs change to
+// accept SliceAllocators and SliceAllocatorFactory(ie)s. In the meantime, the
+// libuv work has temporary implementations as well.
+class NoopSliceAllocator : public SliceAllocator {
+ public:
+  absl::Status Allocate(size_t size, SliceBuffer* dest,
+                        SliceAllocator::AllocateCallback cb) {
+    return absl::OkStatus();
+  }
+};
+
+class NoopSliceAllocatorFactory : public SliceAllocatorFactory {
+ public:
+  std::unique_ptr<SliceAllocator> CreateSliceAllocator(
+      absl::string_view peer_name) {
+    return absl::make_unique<NoopSliceAllocator>();
+  };
+};
+
+struct grpc_tcp_server {
+  explicit grpc_tcp_server(std::unique_ptr<EventEngine::Listener> listener)
+      : refcount(1, GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) ? "tcp" : nullptr),
+        listener(std::move(listener)) {
+    shutdown_starting.head = nullptr;
+    shutdown_starting.tail = nullptr;
+  };
+  ~grpc_tcp_server() {
+    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &shutdown_starting);
+    grpc_core::ExecCtx::Get()->Flush();
+  }
+  grpc_core::RefCount refcount;
+  grpc_core::Mutex mu;
+  std::unique_ptr<EventEngine::Listener> listener;
+  grpc_closure_list shutdown_starting ABSL_GUARDED_BY(mu);
+  grpc_tcp_server_cb on_accept_internal;
+  void* on_accept_internal_arg;
+};
+
+namespace {
+
+/// Converts a grpc_closure to an EventEngine Callback. The closure is expected
+/// to already be initialized.
+EventEngine::OnConnectCallback GrpcClosureToOnConnectCallback(
+    grpc_closure* closure, grpc_endpoint** endpoint_ptr) {
+  return [closure, endpoint_ptr](
+             absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> endpoint) {
+    grpc_core::ExecCtx exec_ctx;
+    if (endpoint.ok()) {
+      auto* grpc_endpoint_out =
+          reinterpret_cast<grpc_event_engine_endpoint*>(*endpoint_ptr);
+      grpc_endpoint_out->endpoint = std::move(*endpoint);
+    } else {
+      grpc_endpoint_destroy(*endpoint_ptr);
+      *endpoint_ptr = nullptr;
+    }
+    grpc_core::Closure::Run(DEBUG_LOCATION, closure,
+                            absl_status_to_grpc_error(endpoint.status()));
+    exec_ctx.Flush();
+    grpc_pollset_ee_broadcast_event();
+  };
+}
+
+/// Usage note: this method does not take ownership of any pointer arguments.
+void tcp_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
+                 grpc_pollset_set* /* interested_parties */,
+                 const grpc_channel_args* channel_args,
+                 const grpc_resolved_address* addr, grpc_millis deadline) {
+  grpc_event_engine_endpoint* ee_endpoint =
+      reinterpret_cast<grpc_event_engine_endpoint*>(
+          grpc_tcp_create(channel_args, grpc_sockaddr_to_uri(addr)));
+  *endpoint = &ee_endpoint->base;
+  EventEngine::OnConnectCallback ee_on_connect =
+      GrpcClosureToOnConnectCallback(on_connect, endpoint);
+  // TODO(hork): tcp_connect will change to accept a SliceAllocator. This is
+  // temporary.
+  auto sa = absl::make_unique<NoopSliceAllocator>();
+  EventEngine::ResolvedAddress ra(reinterpret_cast<const sockaddr*>(addr->addr),
+                                  addr->len);
+  absl::Time ee_deadline = grpc_core::ToAbslTime(
+      grpc_millis_to_timespec(deadline, GPR_CLOCK_MONOTONIC));
+  ChannelArgsEndpointConfig endpoint_config(channel_args);
+  absl::Status connected = grpc_iomgr_event_engine()->Connect(
+      ee_on_connect, ra, endpoint_config, std::move(sa), ee_deadline);
+  if (!connected.ok()) {
+    // EventEngine failed to start an asynchronous connect.
+    grpc_endpoint_destroy(*endpoint);
+    *endpoint = nullptr;
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_connect,
+                            absl_status_to_grpc_error(connected));
+  }
+}
+
+grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
+                              const grpc_channel_args* args,
+                              grpc_tcp_server** server) {
+  ChannelArgsEndpointConfig endpoint_config(args);
+  grpc_resource_quota* rq = grpc_resource_quota_from_channel_args(args);
+  if (rq == nullptr) {
+    rq = grpc_resource_quota_create(nullptr);
+  }
+  // TODO(hork): tcp_server_create will change to accept a
+  // SliceAllocatorFactory. This is temporary.
+  auto saf = absl::make_unique<NoopSliceAllocatorFactory>();
+  EventEngine* event_engine = grpc_iomgr_event_engine();
+  absl::StatusOr<std::unique_ptr<EventEngine::Listener>> listener =
+      event_engine->CreateListener(
+          [server](std::unique_ptr<EventEngine::Endpoint> ee_endpoint) {
+            grpc_core::ExecCtx exec_ctx;
+            GPR_ASSERT((*server)->on_accept_internal != nullptr);
+            grpc_event_engine_endpoint* iomgr_endpoint =
+                grpc_tcp_server_endpoint_create(std::move(ee_endpoint));
+            grpc_tcp_server_acceptor* acceptor =
+                static_cast<grpc_tcp_server_acceptor*>(
+                    gpr_zalloc(sizeof(*acceptor)));
+            acceptor->from_server = *server;
+            acceptor->external_connection = false;
+            (*server)->on_accept_internal((*server)->on_accept_internal_arg,
+                                          &iomgr_endpoint->base, nullptr,
+                                          acceptor);
+            exec_ctx.Flush();
+            grpc_pollset_ee_broadcast_event();
+          },
+          GrpcClosureToCallback(shutdown_complete, GRPC_ERROR_NONE),
+          endpoint_config, std::move(saf));
+  if (!listener.ok()) {
+    return absl_status_to_grpc_error(listener.status());
+  }
+  *server = new grpc_tcp_server(std::move(*listener));
+  return GRPC_ERROR_NONE;
+}
+
+void tcp_server_start(grpc_tcp_server* server,
+                      const std::vector<grpc_pollset*>* /* pollsets */,
+                      grpc_tcp_server_cb on_accept_cb, void* cb_arg) {
+  server->on_accept_internal = on_accept_cb;
+  server->on_accept_internal_arg = cb_arg;
+  // The iomgr API does not handle situations where the server cannot start, so
+  // a crash may be preferable for now.
+  GPR_ASSERT(server->listener->Start().ok());
+}
+
+grpc_error* tcp_server_add_port(grpc_tcp_server* s,
+                                const grpc_resolved_address* addr,
+                                int* out_port) {
+  EventEngine::ResolvedAddress ra(reinterpret_cast<const sockaddr*>(addr->addr),
+                                  addr->len);
+  auto port = s->listener->Bind(ra);
+  if (!port.ok()) {
+    return absl_status_to_grpc_error(port.status());
+  }
+  *out_port = *port;
+  return GRPC_ERROR_NONE;
+}
+
+grpc_core::TcpServerFdHandler* tcp_server_create_fd_handler(
+    grpc_tcp_server* /* s */) {
+  // EventEngine-iomgr does not support fds.
+  return nullptr;
+}
+
+unsigned tcp_server_port_fd_count(grpc_tcp_server* /* s */,
+                                  unsigned /* port_index */) {
+  return 0;
+}
+
+int tcp_server_port_fd(grpc_tcp_server* /* s */, unsigned /* port_index */,
+                       unsigned /* fd_index */) {
+  // Note: only used internally
+  return -1;
+}
+
+grpc_tcp_server* tcp_server_ref(grpc_tcp_server* s) {
+  s->refcount.Ref(DEBUG_LOCATION, "server ref");
+  return s;
+}
+
+void tcp_server_shutdown_starting_add(grpc_tcp_server* s,
+                                      grpc_closure* shutdown_starting) {
+  grpc_core::MutexLock lock(&s->mu);
+  grpc_closure_list_append(&s->shutdown_starting, shutdown_starting,
+                           GRPC_ERROR_NONE);
+}
+
+void tcp_server_unref(grpc_tcp_server* s) {
+  if (GPR_UNLIKELY(s->refcount.Unref(DEBUG_LOCATION, "server unref"))) {
+    delete s;
+  }
+}
+
+// No-op, all are handled on listener unref
+void tcp_server_shutdown_listeners(grpc_tcp_server* /* s */) {}
+
+}  // namespace
+
+grpc_tcp_client_vtable grpc_event_engine_tcp_client_vtable = {tcp_connect};
+grpc_tcp_server_vtable grpc_event_engine_tcp_server_vtable = {
+    tcp_server_create,        tcp_server_start,
+    tcp_server_add_port,      tcp_server_create_fd_handler,
+    tcp_server_port_fd_count, tcp_server_port_fd,
+    tcp_server_ref,           tcp_server_shutdown_starting_add,
+    tcp_server_unref,         tcp_server_shutdown_listeners};
+
+// Methods that are expected to exist elsewhere in the codebase.
+
+struct grpc_fd {
+  int fd;
+};
+
+grpc_fd* grpc_fd_create(int /* fd */, const char* /* name */,
+                        bool /* track_err */) {
+  return nullptr;
+}
+
+grpc_endpoint* grpc_tcp_client_create_from_fd(
+    grpc_fd* /* fd */, const grpc_channel_args* /* channel_args */,
+    const char* /* addr_str */) {
+  return nullptr;
+}
+
+#endif  // GRPC_USE_EVENT_ENGINE