grpc 1.42.0 → 1.46.3

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

@@ -71,24 +71,15 @@ static void create_sockets(SOCKET sv[2]) {
 }
 
 grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
-    const char* name, grpc_channel_args* channel_args) {
+    const char*, grpc_channel_args* channel_args) {
   SOCKET sv[2];
   grpc_endpoint_pair p;
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
-  grpc_resource_quota* resource_quota =
-      grpc_resource_quota_from_channel_args(channel_args, true);
-  p.client =
-      grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
-                      channel_args, "endpoint:server",
-                      grpc_slice_allocator_create(
-                          resource_quota, "endpoint:server", channel_args));
-  p.server =
-      grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
-                      channel_args, "endpoint:client",
-                      grpc_slice_allocator_create(
-                          resource_quota, "endpoint:client", channel_args));
-  grpc_resource_quota_unref_internal(resource_quota);
+  p.client = grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
+                             channel_args, "endpoint:server");
+  p.server = grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
+                             channel_args, "endpoint:client");
   return p;
 }
 

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

@@ -35,7 +35,6 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/error_internal.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_utils.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_error_refcount(false,
                                                         "error_refcount");
@@ -86,7 +85,7 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
                             const char* call_name) {
   char* utf8_message = gpr_format_message(err);
   absl::Status s =
-      StatusCreate(absl::StatusCode::kUnknown, "WSA Error", location, {});
+      StatusCreate(absl::StatusCode::kUnavailable, "WSA Error", location, {});
   StatusSetInt(&s, grpc_core::StatusIntProperty::kWsaError, err);
   StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError, utf8_message);
   StatusSetStr(&s, grpc_core::StatusStrProperty::kSyscall, call_name);
@@ -446,6 +445,8 @@ static void internal_set_time(grpc_error_handle* err, grpc_error_times which,
   memcpy((*err)->arena + slot, &value, sizeof(value));
 }
 
+const char* grpc_error_string(grpc_error_handle err);
+
 static void internal_add_error(grpc_error_handle* err,
                                grpc_error_handle new_err) {
   grpc_linked_error new_last = {new_err, UINT8_MAX};
@@ -959,15 +960,17 @@ grpc_error_handle grpc_os_error(const char* file, int line, int err,
 grpc_error_handle grpc_wsa_error(const char* file, int line, int err,
                                  const char* call_name) {
   char* utf8_message = gpr_format_message(err);
-  grpc_error_handle error = grpc_error_set_str(
+  grpc_error_handle error = grpc_error_set_int(
       grpc_error_set_str(
-          grpc_error_set_int(
-              grpc_error_create(file, line,
-                                grpc_slice_from_static_string("OS Error"), NULL,
-                                0),
-              GRPC_ERROR_INT_WSA_ERROR, err),
-          GRPC_ERROR_STR_OS_ERROR, utf8_message),
-      GRPC_ERROR_STR_SYSCALL, call_name);
+          grpc_error_set_str(
+              grpc_error_set_int(
+                  grpc_error_create(file, line,
+                                    grpc_slice_from_static_string("OS Error"),
+                                    NULL, 0),
+                  GRPC_ERROR_INT_WSA_ERROR, err),
+              GRPC_ERROR_STR_OS_ERROR, utf8_message),
+          GRPC_ERROR_STR_SYSCALL, call_name),
+      GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
   gpr_free(utf8_message);
   return error;
 }

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

@@ -145,8 +145,6 @@ typedef enum {
   GRPC_ERROR_TIME_MAX,
 } grpc_error_times;
 
-// DEPRECATED: Use grpc_error_std_string instead
-const char* grpc_error_string(grpc_error_handle error);
 std::string grpc_error_std_string(grpc_error_handle error);
 
 // debug only toggles that allow for a sanity to check that ensures we will

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

@@ -221,9 +221,10 @@ static void pollset_global_shutdown(void) {
 /// these events will eventually trigger the kick.
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker,
-                                      grpc_millis deadline) {
+                                      grpc_core::Timestamp deadline) {
   GRPC_POLLING_TRACE("pollset work: %p, worker: %p, deadline: %" PRIu64,
-                     pollset, worker, deadline);
+                     pollset, worker,
+                     deadline.milliseconds_after_process_epoch());
   GrpcApplePollset* apple_pollset =
       reinterpret_cast<GrpcApplePollset*>(pollset);
   GrpcAppleWorker actual_worker;
@@ -241,8 +242,8 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
 
     while (!actual_worker.kicked && !apple_pollset->is_shutdown) {
       if (actual_worker.cv.WaitWithDeadline(
-              &apple_pollset->mu, grpc_core::ToAbslTime(grpc_millis_to_timespec(
-                                      deadline, GPR_CLOCK_REALTIME)))) {
+              &apple_pollset->mu, grpc_core::ToAbslTime(deadline.as_timespec(
+                                      GPR_CLOCK_REALTIME)))) {
         // timed out
         break;
       }
@@ -313,7 +314,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   GrpcApplePollset* apple_pollset =
       reinterpret_cast<GrpcApplePollset*>(pollset);
   apple_pollset->is_shutdown = true;
-  pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
+  (void)pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
 
   // If there is any worker blocked, shutdown will be done asynchronously.
   if (apple_pollset->workers.empty()) {

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

@@ -639,9 +639,9 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   pollset_maybe_finish_shutdown(pollset);
 }
 
-static int poll_deadline_to_millis_timeout(grpc_millis millis) {
-  if (millis == GRPC_MILLIS_INF_FUTURE) return -1;
-  grpc_millis delta = millis - grpc_core::ExecCtx::Get()->Now();
+static int poll_deadline_to_millis_timeout(grpc_core::Timestamp millis) {
+  if (millis == grpc_core::Timestamp::InfFuture()) return -1;
+  int64_t delta = (millis - grpc_core::ExecCtx::Get()->Now()).millis();
   if (delta > INT_MAX) {
     return INT_MAX;
   } else if (delta < 0) {
@@ -711,7 +711,8 @@ static grpc_error_handle process_epoll_events(grpc_pollset* /*pollset*/) {
    NOTE ON SYNCHRONIZATION: At any point of time, only the g_active_poller
    (i.e the designated poller thread) will be calling this function. So there is
    no need for any synchronization when accesing fields in g_epoll_set */
-static grpc_error_handle do_epoll_wait(grpc_pollset* ps, grpc_millis deadline) {
+static grpc_error_handle do_epoll_wait(grpc_pollset* ps,
+                                       grpc_core::Timestamp deadline) {
   GPR_TIMER_SCOPE("do_epoll_wait", 0);
 
   int r;
@@ -744,7 +745,7 @@ static grpc_error_handle do_epoll_wait(grpc_pollset* ps, grpc_millis deadline) {
 
 static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
                          grpc_pollset_worker** worker_hdl,
-                         grpc_millis deadline) {
+                         grpc_core::Timestamp deadline) {
   GPR_TIMER_SCOPE("begin_worker", 0);
   if (worker_hdl != nullptr) *worker_hdl = worker;
   worker->initialized_cv = false;
@@ -831,7 +832,7 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
       }
 
       if (gpr_cv_wait(&worker->cv, &pollset->mu,
-                      grpc_millis_to_timespec(deadline, GPR_CLOCK_MONOTONIC)) &&
+                      deadline.as_timespec(GPR_CLOCK_MONOTONIC)) &&
           worker->state == UNKICKED) {
         /* If gpr_cv_wait returns true (i.e a timeout), pretend that the worker
            received a kick */
@@ -1012,7 +1013,7 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
    ensure that it is held by the time the function returns */
 static grpc_error_handle pollset_work(grpc_pollset* ps,
                                       grpc_pollset_worker** worker_hdl,
-                                      grpc_millis deadline) {
+                                      grpc_core::Timestamp deadline) {
   GPR_TIMER_SCOPE("pollset_work", 0);
   grpc_pollset_worker worker;
   grpc_error_handle error = GRPC_ERROR_NONE;

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

@@ -221,7 +221,7 @@ static void pollset_set_add_fd(grpc_pollset_set* pollset_set, grpc_fd* fd);
    - longer than a millisecond polls are rounded up to the next nearest
      millisecond to avoid spinning
    - infinite timeouts are converted to -1 */
-static int poll_deadline_to_millis_timeout(grpc_millis deadline);
+static int poll_deadline_to_millis_timeout(grpc_core::Timestamp deadline);
 
 /* Allow kick to wakeup the currently polling worker */
 #define GRPC_POLLSET_CAN_KICK_SELF 1
@@ -913,7 +913,7 @@ static void work_combine_error(grpc_error_handle* composite,
 
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker_hdl,
-                                      grpc_millis deadline) {
+                                      grpc_core::Timestamp deadline) {
   GPR_TIMER_SCOPE("pollset_work", 0);
   grpc_pollset_worker worker;
   if (worker_hdl) *worker_hdl = &worker;
@@ -1106,7 +1106,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
       if (queued_work || worker.kicked_specifically) {
         /* If there's queued work on the list, then set the deadline to be
            immediate so we get back out of the polling loop quickly */
-        deadline = 0;
+        deadline = grpc_core::Timestamp();
       }
       keep_polling = 1;
     }
@@ -1151,10 +1151,10 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   }
 }
 
-static int poll_deadline_to_millis_timeout(grpc_millis deadline) {
-  if (deadline == GRPC_MILLIS_INF_FUTURE) return -1;
-  if (deadline == 0) return 0;
-  grpc_millis n = deadline - grpc_core::ExecCtx::Get()->Now();
+static int poll_deadline_to_millis_timeout(grpc_core::Timestamp deadline) {
+  if (deadline == grpc_core::Timestamp::InfFuture()) return -1;
+  if (deadline.is_process_epoch()) return 0;
+  int64_t n = (deadline - grpc_core::ExecCtx::Get()->Now()).millis();
   if (n < 0) return 0;
   if (n > INT_MAX) return -1;
   return static_cast<int>(n);

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

@@ -32,7 +32,6 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
-#include "src/core/lib/iomgr/ev_epollex_linux.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
@@ -126,12 +125,12 @@ const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
 // environment variable if that variable is set (which should be a
 // comma-separated list of one or more event engine names)
 static event_engine_factory g_factories[] = {
-    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
-    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
-    {"epollex", grpc_init_epollex_linux}, {"epoll1", grpc_init_epoll1_linux},
-    {"poll", grpc_init_poll_posix},       {"none", init_non_polling},
-    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
-    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_HEAD_CUSTOM, nullptr},      {ENGINE_HEAD_CUSTOM, nullptr},
+    {ENGINE_HEAD_CUSTOM, nullptr},      {ENGINE_HEAD_CUSTOM, nullptr},
+    {"epoll1", grpc_init_epoll1_linux}, {"poll", grpc_init_poll_posix},
+    {"none", init_non_polling},         {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_TAIL_CUSTOM, nullptr},      {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_TAIL_CUSTOM, nullptr},
 };
 
 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
@@ -316,13 +315,13 @@ static void pollset_destroy(grpc_pollset* pollset) {
 
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker,
-                                      grpc_millis deadline) {
+                                      grpc_core::Timestamp deadline) {
   GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") begin", pollset,
-                         deadline);
+                         deadline.milliseconds_after_process_epoch());
   grpc_error_handle err =
       g_event_engine->pollset_work(pollset, worker, deadline);
   GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") end", pollset,
-                         deadline);
+                         deadline.milliseconds_after_process_epoch());
   return err;
 }
 

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

@@ -66,7 +66,7 @@ typedef struct grpc_event_engine_vtable {
   void (*pollset_destroy)(grpc_pollset* pollset);
   grpc_error_handle (*pollset_work)(grpc_pollset* pollset,
                                     grpc_pollset_worker** worker,
-                                    grpc_millis deadline);
+                                    grpc_core::Timestamp deadline);
   grpc_error_handle (*pollset_kick)(grpc_pollset* pollset,
                                     grpc_pollset_worker* specific_worker);
   void (*pollset_add_fd)(grpc_pollset* pollset, struct grpc_fd* fd);

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

@@ -39,7 +39,6 @@ namespace {
 
 using ::grpc_event_engine::experimental::EventEngine;
 using ::grpc_event_engine::experimental::ResolvedAddressToURI;
-using ::grpc_event_engine::experimental::SliceAllocator;
 using ::grpc_event_engine::experimental::SliceBuffer;
 
 void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
@@ -163,8 +162,8 @@ grpc_event_engine_endpoint* grpc_tcp_server_endpoint_create(
   return endpoint;
 }
 
-grpc_endpoint* grpc_tcp_create(const grpc_channel_args* channel_args,
-                               absl::string_view peer_address) {
+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;

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

@@ -18,7 +18,7 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/event_engine/iomgr.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"
@@ -30,7 +30,6 @@ 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;
-extern grpc_address_resolver_vtable grpc_event_engine_resolver_vtable;
 
 // Disabled by default. grpc_polling_trace must be defined in all iomgr
 // implementations due to its usage in lockfree_event.
@@ -38,25 +37,21 @@ grpc_core::DebugOnlyTraceFlag grpc_polling_trace(false, "polling");
 
 namespace {
 
-using ::grpc_event_engine::experimental::DefaultEventEngineFactory;
 using ::grpc_event_engine::experimental::EventEngine;
-
-EventEngine* g_event_engine = nullptr;
+using ::grpc_event_engine::experimental::GetDefaultEventEngine;
 
 // TODO(nnoble): Instantiate the default EventEngine if none have been provided.
-void iomgr_platform_init(void) { GPR_ASSERT(g_event_engine != nullptr); }
+void iomgr_platform_init(void) {}
 
 void iomgr_platform_flush(void) {}
 
-void iomgr_platform_shutdown(void) {
-  delete g_event_engine;
-  g_event_engine = nullptr;
-}
+void iomgr_platform_shutdown(void) {}
 
 void iomgr_platform_shutdown_background_closure(void) {}
 
 bool iomgr_platform_is_any_background_poller_thread(void) {
-  return g_event_engine->IsWorkerThread();
+  return grpc_event_engine::experimental::GetDefaultEventEngine()
+      ->IsWorkerThread();
 }
 
 bool iomgr_platform_add_closure_to_background_poller(
@@ -80,25 +75,11 @@ void grpc_set_default_iomgr_platform() {
   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_set_resolver_impl(&grpc_event_engine_resolver_vtable);
+  grpc_core::SetDNSResolver(
+      grpc_core::experimental::EventEngineDNSResolver::GetOrCreate());
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 
 bool grpc_iomgr_run_in_background() { return false; }
 
-grpc_event_engine::experimental::EventEngine* grpc_iomgr_event_engine() {
-  return g_event_engine;
-}
-
-namespace grpc_core {
-
-void SetDefaultEventEngine(
-    std::unique_ptr<grpc_event_engine::experimental::EventEngine>
-        event_engine) {
-  GPR_ASSERT(g_event_engine == nullptr);
-  g_event_engine = event_engine.release();
-}
-
-}  // namespace grpc_core
-
 #endif  // GRPC_USE_EVENT_ENGINE

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

@@ -42,10 +42,9 @@ void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
 void pollset_destroy(grpc_pollset* pollset) {}
 grpc_error_handle pollset_work(grpc_pollset* pollset,
                                grpc_pollset_worker** worker,
-                               grpc_millis deadline) {
+                               grpc_core::Timestamp deadline) {
   (void)worker;
-  gpr_cv_wait(&g_cv, &g_mu,
-              grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME));
+  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,

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

@@ -37,5 +37,11 @@ grpc_resolved_address CreateGRPCResolvedAddress(
   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

@@ -29,6 +29,8 @@ EventEngine::ResolvedAddress CreateResolvedAddress(
 grpc_resolved_address CreateGRPCResolvedAddress(
     const EventEngine::ResolvedAddress& ra);
 
+std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr);
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

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

@@ -19,96 +19,115 @@
 #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/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/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 DnsRequest {
+class EventEngineDNSRequest : 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)
+  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)),
-        cb_(on_done),
-        addresses_(addresses) {
+        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(&DnsRequest::OnLookupComplete, this), address,
-        default_port, absl::InfiniteFuture());
+        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) {
-    grpc_core::ExecCtx exec_ctx;
+    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()));
+    std::vector<grpc_resolved_address> result;
+    results.reserve(addresses->size());
     for (size_t i = 0; i < addresses->size(); ++i) {
-      (*addresses_)->addrs[i] = CreateGRPCResolvedAddress((*addresses)[i]);
+      results.push_back(CreateGRPCResolvedAddress(addresses[i]));
     }
-    grpc_closure* cb = cb_;
-    delete this;
-    grpc_core::Closure::Run(DEBUG_LOCATION, cb,
-                            absl_status_to_grpc_error(addresses.status()));
+    if (addresses.ok()) {
+      on_done_(std::move(result));
+    } else {
+      on_done_(addresses.status());
+    }
+    Unref();
   }
 
   std::unique_ptr<EventEngine::DNSResolver> dns_resolver_;
-  grpc_closure* cb_;
-  grpc_resolved_addresses** addresses_;
+  const std::string name_;
+  const std::string default_port_;
+  std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+      on_done_;
 };
 
-void resolve_address(const char* addr, const char* default_port,
-                     grpc_pollset_set* /* interested_parties */,
-                     grpc_closure* on_done,
-                     grpc_resolved_addresses** addresses) {
-  std::unique_ptr<EventEngine::DNSResolver> dns_resolver =
-      grpc_iomgr_event_engine()->GetDNSResolver();
-  if (dns_resolver == nullptr) {
-    grpc_core::ExecCtx::Run(
-        DEBUG_LOCATION, on_done,
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to get DNS Resolver."));
-    return;
-  }
-  new DnsRequest(std::move(dns_resolver), addr, default_port, on_done,
-                 addresses);
+}  // namespace
+
+DNSResolver* EventEngineDNSResolver::GetOrCreate() {
+  static EventEngineDNSResolver* instance = new EventEngineDNSResolver();
+  return instance;
 }
 
-void blocking_handle_async_resolve_done(void* arg, grpc_error_handle error) {
-  static_cast<Promise<grpc_error_handle>*>(arg)->Set(std::move(error));
+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));
 }
 
-grpc_error_handle blocking_resolve_address(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) {
+absl::StatusOr<std::vector<grpc_resolved_address>>
+EventEngineDNSResolver::ResolveNameBlocking(absl::string_view name,
+                                            absl::string_view default_port) {
   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);
+  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
-
-grpc_address_resolver_vtable grpc_event_engine_resolver_vtable{
-    resolve_address, blocking_resolve_address};
+}  // namespace experimental
+}  // namespace grpc_core
 
 #endif  // GRPC_USE_EVENT_ENGINE

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

@@ -0,0 +1,56 @@
+//
+// Copyright 2015 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_RESOLVER_H
+#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string.h>
+#include <sys/types.h>
+
+#include <functional>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_core {
+namespace experimental {
+
+class EventEngineDNSResolver : public DNSResolver {
+ public:
+  // Gets the singleton instance, creating it first if it doesn't exist
+  static EventEngineDNSResolver* GetOrCreate();
+
+  OrphanablePtr<DNSResolver::Request> 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) override;
+
+  absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
+      absl::string_view name, absl::string_view default_port) override;
+};
+
+}  // namespace experimental
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVER_H