grpc 1.43.1 → 1.45.0

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

@@ -72,7 +72,7 @@ struct grpc_closure {
 
   /** Once queued, the result of the closure. Before then: scratch space */
   union {
-    grpc_error_handle error;
+    uintptr_t error;
     uintptr_t scratch;
   } error_data;
 
@@ -98,7 +98,7 @@ inline grpc_closure* grpc_closure_init(grpc_closure* closure,
 #endif
   closure->cb = cb;
   closure->cb_arg = cb_arg;
-  closure->error_data.error = GRPC_ERROR_NONE;
+  closure->error_data.error = 0;
 #ifndef NDEBUG
   closure->scheduled = false;
   closure->file_initiated = nullptr;
@@ -172,16 +172,12 @@ inline void grpc_closure_list_init(grpc_closure_list* closure_list) {
 }
 
 /** add \a closure to the end of \a list
-    and set \a closure's result to \a error
     Returns true if \a list becomes non-empty */
 inline bool grpc_closure_list_append(grpc_closure_list* closure_list,
-                                     grpc_closure* closure,
-                                     grpc_error_handle error) {
+                                     grpc_closure* closure) {
   if (closure == nullptr) {
-    GRPC_ERROR_UNREF(error);
     return false;
   }
-  closure->error_data.error = error;
   closure->next_data.next = nullptr;
   bool was_empty = (closure_list->head == nullptr);
   if (was_empty) {
@@ -193,12 +189,36 @@ inline bool grpc_closure_list_append(grpc_closure_list* closure_list,
   return was_empty;
 }
 
+/** add \a closure to the end of \a list
+    and set \a closure's result to \a error
+    Returns true if \a list becomes non-empty */
+inline bool grpc_closure_list_append(grpc_closure_list* closure_list,
+                                     grpc_closure* closure,
+                                     grpc_error_handle error) {
+  if (closure == nullptr) {
+    GRPC_ERROR_UNREF(error);
+    return false;
+  }
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  closure->error_data.error = grpc_core::internal::StatusAllocHeapPtr(error);
+#else
+  closure->error_data.error = reinterpret_cast<intptr_t>(error);
+#endif
+  return grpc_closure_list_append(closure_list, closure);
+}
+
 /** force all success bits in \a list to false */
 inline void grpc_closure_list_fail_all(grpc_closure_list* list,
                                        grpc_error_handle forced_failure) {
   for (grpc_closure* c = list->head; c != nullptr; c = c->next_data.next) {
-    if (c->error_data.error == GRPC_ERROR_NONE) {
-      c->error_data.error = GRPC_ERROR_REF(forced_failure);
+    if (c->error_data.error == 0) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+      c->error_data.error =
+          grpc_core::internal::StatusAllocHeapPtr(forced_failure);
+#else
+      c->error_data.error =
+          reinterpret_cast<intptr_t>(GRPC_ERROR_REF(forced_failure));
+#endif
     }
   }
   GRPC_ERROR_UNREF(forced_failure);

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

@@ -149,7 +149,11 @@ static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* cl,
   }
   GPR_ASSERT(last & STATE_UNORPHANED);  // ensure lock has not been destroyed
   assert(cl->cb);
-  cl->error_data.error = error;
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  cl->error_data.error = grpc_core::internal::StatusAllocHeapPtr(error);
+#else
+  cl->error_data.error = reinterpret_cast<intptr_t>(error);
+#endif
   lock->queue.Push(cl->next_data.mpscq_node.get());
 }
 
@@ -221,12 +225,21 @@ bool grpc_combiner_continue_exec_ctx() {
       return true;
     }
     grpc_closure* cl = reinterpret_cast<grpc_closure*>(n);
-    grpc_error_handle cl_err = cl->error_data.error;
 #ifndef NDEBUG
     cl->scheduled = false;
 #endif
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    grpc_error_handle cl_err =
+        grpc_core::internal::StatusMoveFromHeapPtr(cl->error_data.error);
+    cl->error_data.error = 0;
+    cl->cb(cl->cb_arg, std::move(cl_err));
+#else
+    grpc_error_handle cl_err =
+        reinterpret_cast<grpc_error_handle>(cl->error_data.error);
+    cl->error_data.error = 0;
     cl->cb(cl->cb_arg, cl_err);
     GRPC_ERROR_UNREF(cl_err);
+#endif
   } else {
     grpc_closure* c = lock->final_list.head;
     GPR_ASSERT(c != nullptr);
@@ -236,12 +249,21 @@ bool grpc_combiner_continue_exec_ctx() {
       GRPC_COMBINER_TRACE(
           gpr_log(GPR_INFO, "C:%p execute_final[%d] c=%p", lock, loops, c));
       grpc_closure* next = c->next_data.next;
-      grpc_error_handle error = c->error_data.error;
 #ifndef NDEBUG
       c->scheduled = false;
 #endif
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+      grpc_error_handle error =
+          grpc_core::internal::StatusMoveFromHeapPtr(c->error_data.error);
+      c->error_data.error = 0;
+      c->cb(c->cb_arg, std::move(error));
+#else
+      grpc_error_handle error =
+          reinterpret_cast<grpc_error_handle>(c->error_data.error);
+      c->error_data.error = 0;
       c->cb(c->cb_arg, error);
       GRPC_ERROR_UNREF(error);
+#endif
       c = next;
     }
   }

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_epollex_linux.cc

@@ -798,9 +798,9 @@ static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   *mu = &pollset->mu;
 }
 
-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) {
@@ -926,7 +926,8 @@ static void pollset_destroy(grpc_pollset* pollset) {
   gpr_mu_destroy(&pollset->mu);
 }
 
-static grpc_error_handle pollable_epoll(pollable* p, grpc_millis deadline) {
+static grpc_error_handle pollable_epoll(pollable* p,
+                                        grpc_core::Timestamp deadline) {
   GPR_TIMER_SCOPE("pollable_epoll", 0);
   int timeout = poll_deadline_to_millis_timeout(deadline);
 
@@ -1001,7 +1002,7 @@ static worker_remove_result worker_remove(grpc_pollset_worker** root_worker,
 /* Return true if this thread should poll */
 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);
   bool do_poll =
       (pollset->shutdown_closure == nullptr && !pollset->already_shutdown);
@@ -1027,7 +1028,7 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
     }
     while (do_poll && worker->pollable_obj->root_worker != worker) {
       if (gpr_cv_wait(&worker->cv, &worker->pollable_obj->mu,
-                      grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME))) {
+                      deadline.as_timespec(GPR_CLOCK_REALTIME))) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, "PS:%p timeout_wait %p w=%p", pollset,
                   worker->pollable_obj, worker);
@@ -1099,7 +1100,7 @@ static long sys_gettid(void) { return syscall(__NR_gettid); }
    ensure that it is held by the time the function returns */
 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);
 #ifdef GRPC_EPOLLEX_CREATE_WORKERS_ON_HEAP
   grpc_pollset_worker* worker =
@@ -1116,8 +1117,10 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
     gpr_log(GPR_INFO,
             "PS:%p work hdl=%p worker=%p now=%" PRId64 " deadline=%" PRId64
             " kwp=%d pollable=%p",
-            pollset, worker_hdl, WORKER_PTR, grpc_core::ExecCtx::Get()->Now(),
-            deadline, pollset->kicked_without_poller, pollset->active_pollable);
+            pollset, worker_hdl, WORKER_PTR,
+            grpc_core::ExecCtx::Get()->Now().milliseconds_after_process_epoch(),
+            deadline.milliseconds_after_process_epoch(),
+            pollset->kicked_without_poller, pollset->active_pollable);
   }
   static const char* err_desc = "pollset_work";
   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

@@ -316,13 +316,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/iomgr.cc

@@ -18,6 +18,7 @@
 
 #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"
@@ -29,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.
@@ -75,7 +75,8 @@ 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);
 }
 

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

@@ -24,11 +24,15 @@
 #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;
@@ -39,77 +43,91 @@ using ::grpc_event_engine::experimental::Promise;
 ///
 /// 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]));
+    }
+    if (addresses.ok()) {
+      on_done_(std::move(result));
+    } else {
+      on_done_(addresses.status());
     }
-    grpc_closure* cb = cb_;
-    delete this;
-    grpc_core::Closure::Run(DEBUG_LOCATION, cb,
-                            absl_status_to_grpc_error(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 =
-      GetDefaultEventEngine()->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