grpc 1.46.3 → 1.47.0

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

@@ -1,172 +0,0 @@
-// 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 "absl/strings/string_view.h"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/slice.h>
-#include <grpc/slice_buffer.h>
-#include <grpc/support/time.h>
-
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/iomgr/endpoint.h"
-#include "src/core/lib/iomgr/error.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/pollset.h"
-#include "src/core/lib/iomgr/pollset.h"
-#include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/iomgr/resource_quota.h"
-#include "src/core/lib/transport/error_utils.h"
-
-extern grpc_core::TraceFlag grpc_tcp_trace;
-
-namespace {
-
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::ResolvedAddressToURI;
-using ::grpc_event_engine::experimental::SliceBuffer;
-
-void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                   grpc_closure* cb, bool /* urgent */) {
-  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
-  if (eeep->endpoint == nullptr) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, GRPC_ERROR_CANCELLED);
-    return;
-  }
-  SliceBuffer* read_buffer = new (&eeep->read_buffer) SliceBuffer(slices);
-  eeep->endpoint->Read(
-      [eeep, cb](absl::Status status) {
-        auto* read_buffer = reinterpret_cast<SliceBuffer*>(&eeep->read_buffer);
-        read_buffer->~SliceBuffer();
-        grpc_core::ExecCtx exec_ctx;
-        grpc_core::Closure::Run(DEBUG_LOCATION, cb,
-                                absl_status_to_grpc_error(status));
-        exec_ctx.Flush();
-        grpc_pollset_ee_broadcast_event();
-      },
-      read_buffer);
-}
-
-void endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                    grpc_closure* cb, void* arg) {
-  // TODO(hork): adapt arg to some metrics collection mechanism.
-  (void)arg;
-  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
-  if (eeep->endpoint == nullptr) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, GRPC_ERROR_CANCELLED);
-    return;
-  }
-  SliceBuffer* write_buffer = new (&eeep->write_buffer) SliceBuffer(slices);
-  eeep->endpoint->Write(
-      [eeep, cb](absl::Status status) {
-        auto* write_buffer =
-            reinterpret_cast<SliceBuffer*>(&eeep->write_buffer);
-        write_buffer->~SliceBuffer();
-        grpc_core::ExecCtx exec_ctx;
-        grpc_core::Closure::Run(DEBUG_LOCATION, cb,
-                                absl_status_to_grpc_error(status));
-        exec_ctx.Flush();
-        grpc_pollset_ee_broadcast_event();
-      },
-      write_buffer);
-}
-void endpoint_add_to_pollset(grpc_endpoint* /* ep */,
-                             grpc_pollset* /* pollset */) {}
-void endpoint_add_to_pollset_set(grpc_endpoint* /* ep */,
-                                 grpc_pollset_set* /* pollset */) {}
-void endpoint_delete_from_pollset_set(grpc_endpoint* /* ep */,
-                                      grpc_pollset_set* /* pollset */) {}
-/// After shutdown, all endpoint operations except destroy are no-op,
-/// and will return some kind of sane default (empty strings, nullptrs, etc). It
-/// is the caller's responsibility to ensure that calls to endpoint_shutdown are
-/// synchronized.
-void endpoint_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
-  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    std::string str = grpc_error_std_string(why);
-    gpr_log(GPR_INFO, "TCP Endpoint %p shutdown why=%s", eeep->endpoint.get(),
-            str.c_str());
-  }
-  eeep->endpoint.reset();
-}
-
-void endpoint_destroy(grpc_endpoint* ep) {
-  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
-  delete eeep;
-}
-
-absl::string_view endpoint_get_peer(grpc_endpoint* ep) {
-  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
-  if (eeep->endpoint == nullptr) {
-    return "";
-  }
-  if (eeep->peer_address.empty()) {
-    const EventEngine::ResolvedAddress& addr = eeep->endpoint->GetPeerAddress();
-    eeep->peer_address = ResolvedAddressToURI(addr);
-  }
-  return eeep->peer_address;
-}
-
-absl::string_view endpoint_get_local_address(grpc_endpoint* ep) {
-  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
-  if (eeep->endpoint == nullptr) {
-    return "";
-  }
-  if (eeep->local_address.empty()) {
-    const EventEngine::ResolvedAddress& addr =
-        eeep->endpoint->GetLocalAddress();
-    eeep->local_address = ResolvedAddressToURI(addr);
-  }
-  return eeep->local_address;
-}
-
-int endpoint_get_fd(grpc_endpoint* /* ep */) { return -1; }
-
-bool endpoint_can_track_err(grpc_endpoint* /* ep */) { return false; }
-
-grpc_endpoint_vtable grpc_event_engine_endpoint_vtable = {
-    endpoint_read,
-    endpoint_write,
-    endpoint_add_to_pollset,
-    endpoint_add_to_pollset_set,
-    endpoint_delete_from_pollset_set,
-    endpoint_shutdown,
-    endpoint_destroy,
-    endpoint_get_peer,
-    endpoint_get_local_address,
-    endpoint_get_fd,
-    endpoint_can_track_err};
-
-}  // namespace
-
-grpc_event_engine_endpoint* grpc_tcp_server_endpoint_create(
-    std::unique_ptr<EventEngine::Endpoint> ee_endpoint) {
-  auto endpoint = new grpc_event_engine_endpoint;
-  endpoint->base.vtable = &grpc_event_engine_endpoint_vtable;
-  endpoint->endpoint = std::move(ee_endpoint);
-  return endpoint;
-}
-
-grpc_endpoint* grpc_tcp_create(const grpc_channel_args* /* channel_args */,
-                               absl::string_view /* peer_address */) {
-  auto endpoint = new grpc_event_engine_endpoint;
-  endpoint->base.vtable = &grpc_event_engine_endpoint_vtable;
-  return &endpoint->base;
-}
-
-#endif  // GRPC_USE_EVENT_ENGINE

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

@@ -1,52 +0,0 @@
-// 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_ENDPOINT_H
-#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_ENDPOINT_H
-
-#include <grpc/support/port_platform.h>
-
-#ifdef GRPC_USE_EVENT_ENGINE
-#include <grpc/event_engine/event_engine.h>
-
-#include "src/core/lib/iomgr/endpoint.h"
-#include "src/core/lib/iomgr/resource_quota.h"
-
-struct grpc_event_engine_endpoint {
-  grpc_endpoint base;
-  std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
-      endpoint;
-  std::string peer_address;
-  std::string local_address;
-  std::aligned_storage<
-      sizeof(grpc_event_engine::experimental::SliceBuffer),
-      alignof(grpc_event_engine::experimental::SliceBuffer)>::type read_buffer;
-  std::aligned_storage<
-      sizeof(grpc_event_engine::experimental::SliceBuffer),
-      alignof(grpc_event_engine::experimental::SliceBuffer)>::type write_buffer;
-};
-
-/// Creates an internal grpc_endpoint struct from an EventEngine Endpoint.
-/// Server code needs to create grpc_endpoints after the EventEngine has made
-/// connections.
-grpc_event_engine_endpoint* grpc_tcp_server_endpoint_create(
-    std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint> ee);
-
-/// Creates a new internal grpc_endpoint struct, when no EventEngine Endpoint
-/// has yet been created. This is used in client code before connections are
-/// established. Takes ownership of the slice_allocator.
-grpc_endpoint* grpc_tcp_create(const grpc_channel_args* channel_args,
-                               absl::string_view peer_address);
-
-#endif
-#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_ENDPOINT_H

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

@@ -1,85 +0,0 @@
-// 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/debug/trace.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/event_engine/resolver.h"
-#include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/tcp_client.h"
-#include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/surface/init.h"
-
-extern grpc_tcp_client_vtable grpc_event_engine_tcp_client_vtable;
-extern grpc_tcp_server_vtable grpc_event_engine_tcp_server_vtable;
-extern grpc_timer_vtable grpc_event_engine_timer_vtable;
-extern grpc_pollset_vtable grpc_event_engine_pollset_vtable;
-extern grpc_pollset_set_vtable grpc_event_engine_pollset_set_vtable;
-
-// Disabled by default. grpc_polling_trace must be defined in all iomgr
-// implementations due to its usage in lockfree_event.
-grpc_core::DebugOnlyTraceFlag grpc_polling_trace(false, "polling");
-
-namespace {
-
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::GetDefaultEventEngine;
-
-// TODO(nnoble): Instantiate the default EventEngine if none have been provided.
-void iomgr_platform_init(void) {}
-
-void iomgr_platform_flush(void) {}
-
-void iomgr_platform_shutdown(void) {}
-
-void iomgr_platform_shutdown_background_closure(void) {}
-
-bool iomgr_platform_is_any_background_poller_thread(void) {
-  return grpc_event_engine::experimental::GetDefaultEventEngine()
-      ->IsWorkerThread();
-}
-
-bool iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* /* closure */, grpc_error_handle /* error */) {
-  return false;
-}
-
-grpc_iomgr_platform_vtable vtable = {
-    iomgr_platform_init,
-    iomgr_platform_flush,
-    iomgr_platform_shutdown,
-    iomgr_platform_shutdown_background_closure,
-    iomgr_platform_is_any_background_poller_thread,
-    iomgr_platform_add_closure_to_background_poller};
-
-}  // namespace
-
-void grpc_set_default_iomgr_platform() {
-  grpc_set_tcp_client_impl(&grpc_event_engine_tcp_client_vtable);
-  grpc_set_tcp_server_impl(&grpc_event_engine_tcp_server_vtable);
-  grpc_set_timer_impl(&grpc_event_engine_timer_vtable);
-  grpc_set_pollset_vtable(&grpc_event_engine_pollset_vtable);
-  grpc_set_pollset_set_vtable(&grpc_event_engine_pollset_set_vtable);
-  grpc_core::SetDNSResolver(
-      grpc_core::experimental::EventEngineDNSResolver::GetOrCreate());
-  grpc_set_iomgr_platform_vtable(&vtable);
-}
-
-bool grpc_iomgr_run_in_background() { return false; }
-
-#endif  // GRPC_USE_EVENT_ENGINE

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

@@ -1,87 +0,0 @@
-// 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_handle pollset_work(grpc_pollset* pollset,
-                               grpc_pollset_worker** worker,
-                               grpc_core::Timestamp deadline) {
-  (void)worker;
-  gpr_cv_wait(&g_cv, &g_mu, deadline.as_timespec(GPR_CLOCK_REALTIME));
-  return GRPC_ERROR_NONE;
-}
-grpc_error_handle 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/src/core/lib/iomgr/event_engine/promise.h

@@ -1,51 +0,0 @@
-// 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

@@ -1,47 +0,0 @@
-// 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;
-}
-
-// TODO(ctiller): Move this to somewhere more permanent as we're deleting iomgr.
-std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr) {
-  auto gra = CreateGRPCResolvedAddress(addr);
-  return grpc_sockaddr_to_uri(&gra);
-}
-
-}  // namespace experimental
-}  // namespace grpc_event_engine

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

@@ -1,37 +0,0 @@
-// 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);
-
-std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr);
-
-}  // 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

@@ -1,133 +0,0 @@
-// 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 "absl/functional/bind_front.h"
-
-#include <grpc/event_engine/event_engine.h>
-
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/event_engine/event_engine_factory.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/error.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/event_engine/resolver.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resolve_address_impl.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 grpc_core {
-namespace experimental {
-namespace {
-using ::grpc_event_engine::experimental::CreateGRPCResolvedAddress;
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::GetDefaultEventEngine;
-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 EventEngineDNSRequest : DNSRequest {
- public:
-  EventEngineDNSRequest(std::unique_ptr<EventEngine::DNSResolver> dns_resolver,
-                        absl::string_view name, absl::string_view default_port,
-                        grpc_closure* on_done,
-                        std::vector<grpc_resolved_address>* addresses)
-      : dns_resolver_(std::move(dns_resolver)),
-        name_(std::string(name)),
-        default_port_(std::string(default_port)),
-        on_done_(std::move(on_done)) {}
-
-  void Start() override {
-    if (dns_resolver_ == nullptr) {
-      new DNSCallbackExecCtxScheduler(
-          std::move(on_done_),
-          absl::UnknownError("Failed to get DNS Resolver."));
-      return;
-    }
-    Ref().release();  // ref held by pending resolution
-    dns_resolver_->LookupHostname(
-        absl::bind_front(&EventEngineDNSRequest::OnLookupComplete, this), name_,
-        default_port_, absl::InfiniteFuture());
-  }
-
-  // TODO(hork): implement cancellation; currently it's a no-op
-  void Orphan() override { Unref(); }
-
- private:
-  void OnLookupComplete(
-      absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses) {
-    ExecCtx exec_ctx;
-    // Convert addresses to iomgr form.
-    std::vector<grpc_resolved_address> result;
-    results.reserve(addresses->size());
-    for (size_t i = 0; i < addresses->size(); ++i) {
-      results.push_back(CreateGRPCResolvedAddress(addresses[i]));
-    }
-    if (addresses.ok()) {
-      on_done_(std::move(result));
-    } else {
-      on_done_(addresses.status());
-    }
-    Unref();
-  }
-
-  std::unique_ptr<EventEngine::DNSResolver> dns_resolver_;
-  const std::string name_;
-  const std::string default_port_;
-  std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-      on_done_;
-};
-
-}  // namespace
-
-DNSResolver* EventEngineDNSResolver::GetOrCreate() {
-  static EventEngineDNSResolver* instance = new EventEngineDNSResolver();
-  return instance;
-}
-
-OrphanablePtr<DNSResolver::Request> EventEngineDNSResolver::ResolveName(
-    absl::string_view name, absl::string_view default_port,
-    grpc_pollset_set* /* interested_parties */,
-    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-        on_done) {
-  std::unique_ptr<EventEngine::DNSResolver> dns_resolver =
-      GetDefaultEventEngine()->GetDNSResolver();
-  return MakeOrphanable<EventEngineDNSRequest>(
-      std::move(dns_resolver), name, default_port, std::move(on_done));
-}
-
-absl::StatusOr<std::vector<grpc_resolved_address>>
-EventEngineDNSResolver::ResolveNameBlocking(absl::string_view name,
-                                            absl::string_view default_port) {
-  grpc_closure on_done;
-  Promise<absl::StatusOr<std::vector<grpc_resolved_address>>> evt;
-  auto r = ResolveName(
-      name, default_port,
-      [&evt](void(absl::StatusOr<std::vector<grpc_resolved_address>> result) {
-        evt.Set(std::move(result));
-      }));
-  r->Start();
-  return evt.Get();
-}
-
-}  // namespace experimental
-}  // namespace grpc_core
-
-#endif  // GRPC_USE_EVENT_ENGINE