[EventEngine] Change `GetDNSResolver` to return `absl::StatusOr<std::unique_ptr<DNSResolver>>` (#33744)

Based on the discussion at:
595a75cc5d..e3b402a8fa (r1244325752)


<!--

If you know who should review your pull request, please assign it to
that
person, otherwise the pull request would get assigned randomly.

If your pull request is for a specific language, please add the
appropriate
lang label.

-->

include/grpc/event_engine/event_engine.h

@@ -397,8 +397,11 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
   virtual bool IsWorkerThread() = 0;
 
   /// Creates and returns an instance of a DNSResolver, optionally configured by
-  /// the \a options struct.
-  virtual std::unique_ptr<DNSResolver> GetDNSResolver(
+  /// the \a options struct. This method may return a non-OK status if an error
+  /// occurred when creating the DNSResolver. If the caller requests a custom
+  /// DNS server, and the EventEngine implementation does not support it, this
+  /// must return an error.
+  virtual absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& options) = 0;
 
   /// Asynchronously executes a task as soon as possible.

src/core/ext/filters/client_channel/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -200,9 +200,17 @@ EventEngineClientChannelDNSResolver::EventEngineClientChannelDNSResolver(
       event_engine_(channel_args().GetObjectRef<EventEngine>()) {}
 
 OrphanablePtr<Orphanable> EventEngineClientChannelDNSResolver::StartRequest() {
+  auto dns_resolver =
+      event_engine_->GetDNSResolver({/*dns_server=*/authority()});
+  if (!dns_resolver.ok()) {
+    Result result;
+    result.addresses = dns_resolver.status();
+    result.service_config = dns_resolver.status();
+    OnRequestComplete(std::move(result));
+    return nullptr;
+  }
   return MakeOrphanable<EventEngineDNSRequestWrapper>(
-      Ref(DEBUG_LOCATION, "dns-resolving"),
-      event_engine_->GetDNSResolver({/*dns_server=*/authority()}));
+      Ref(DEBUG_LOCATION, "dns-resolving"), std::move(*dns_resolver));
 }
 
 // ----------------------------------------------------------------------------

src/core/ext/filters/client_channel/resolver/polling_resolver.cc

@@ -260,8 +260,13 @@ void PollingResolver::StartResolvingLocked() {
   request_ = StartRequest();
   last_resolution_timestamp_ = Timestamp::Now();
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] starting resolution, request_=%p",
-            this, request_.get());
+    if (request_ != nullptr) {
+      gpr_log(GPR_INFO,
+              "[polling resolver %p] starting resolution, request_=%p", this,
+              request_.get());
+    } else {
+      gpr_log(GPR_INFO, "[polling resolver %p] StartRequest failed", this);
+    }
   }
 }
 

src/core/lib/event_engine/cf_engine/cf_engine.cc

@@ -155,7 +155,8 @@ bool CFEventEngine::CancelConnectInternal(ConnectionHandle handle,
 
 bool CFEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
 
-std::unique_ptr<EventEngine::DNSResolver> CFEventEngine::GetDNSResolver(
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+CFEventEngine::GetDNSResolver(
     const DNSResolver::ResolverOptions& /* options */) {
   grpc_core::Crash("unimplemented");
 }

src/core/lib/event_engine/cf_engine/cf_engine.h

@@ -51,7 +51,7 @@ class CFEventEngine : public EventEngine,
                            Duration timeout) override;
   bool CancelConnect(ConnectionHandle handle) override;
   bool IsWorkerThread() override;
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(absl::AnyInvocable<void()> closure) override;

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

@@ -487,7 +487,8 @@ EventEngine::TaskHandle PosixEventEngine::RunAfterInternal(
   return handle;
 }
 
-std::unique_ptr<EventEngine::DNSResolver> PosixEventEngine::GetDNSResolver(
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+PosixEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
   grpc_core::Crash("unimplemented");
 }

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

@@ -188,7 +188,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
 
   bool CancelConnect(ConnectionHandle handle) override;
   bool IsWorkerThread() override;
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(absl::AnyInvocable<void()> closure) override;

src/core/lib/event_engine/thready_event_engine/thready_event_engine.cc

@@ -82,9 +82,10 @@ bool ThreadyEventEngine::IsWorkerThread() {
   grpc_core::Crash("we should remove this");
 }
 
-std::unique_ptr<EventEngine::DNSResolver> ThreadyEventEngine::GetDNSResolver(
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+ThreadyEventEngine::GetDNSResolver(
     const DNSResolver::ResolverOptions& options) {
-  return std::make_unique<ThreadyDNSResolver>(impl_->GetDNSResolver(options));
+  return std::make_unique<ThreadyDNSResolver>(*impl_->GetDNSResolver(options));
 }
 
 void ThreadyEventEngine::Run(Closure* closure) {

src/core/lib/event_engine/thready_event_engine/thready_event_engine.h

@@ -63,7 +63,7 @@ class ThreadyEventEngine final : public EventEngine {
 
   bool IsWorkerThread() override;
 
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& options) override;
 
   void Run(Closure* closure) override;

src/core/lib/event_engine/windows/windows_engine.cc

@@ -194,7 +194,8 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
   return handle;
 }
 
-std::unique_ptr<EventEngine::DNSResolver> WindowsEventEngine::GetDNSResolver(
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+WindowsEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
   grpc_core::Crash("unimplemented");
 }

src/core/lib/event_engine/windows/windows_engine.h

@@ -75,7 +75,7 @@ class WindowsEventEngine : public EventEngine,
 
   bool CancelConnect(ConnectionHandle handle) override;
   bool IsWorkerThread() override;
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(absl::AnyInvocable<void()> closure) override;

test/core/event_engine/default_engine_methods_test.cc

@@ -66,7 +66,7 @@ class DefaultEngineTest : public testing::Test {
       return false;
     };
     bool IsWorkerThread() override { return false; };
-    std::unique_ptr<DNSResolver> GetDNSResolver(
+    absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
         const DNSResolver::ResolverOptions& /* options */) override {
       return nullptr;
     };

test/core/event_engine/fuzzing_event_engine/fuzzing_event_engine.cc

@@ -461,8 +461,8 @@ bool FuzzingEventEngine::CancelConnect(ConnectionHandle connection_handle) {
 
 bool FuzzingEventEngine::IsWorkerThread() { abort(); }
 
-std::unique_ptr<EventEngine::DNSResolver> FuzzingEventEngine::GetDNSResolver(
-    const DNSResolver::ResolverOptions&) {
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+FuzzingEventEngine::GetDNSResolver(const DNSResolver::ResolverOptions&) {
   abort();
 }
 

test/core/event_engine/fuzzing_event_engine/fuzzing_event_engine.h

@@ -85,7 +85,7 @@ class FuzzingEventEngine : public EventEngine {
 
   bool IsWorkerThread() override;
 
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& options) override;
 
   void Run(Closure* closure) ABSL_LOCKS_EXCLUDED(mu_) override;

test/core/event_engine/mock_event_engine.h

@@ -44,7 +44,7 @@ class MockEventEngine : public EventEngine {
                Duration timeout));
   MOCK_METHOD(bool, CancelConnect, (ConnectionHandle handle));
   MOCK_METHOD(bool, IsWorkerThread, ());
-  MOCK_METHOD(std::unique_ptr<DNSResolver>, GetDNSResolver,
+  MOCK_METHOD(absl::StatusOr<std::unique_ptr<DNSResolver>>, GetDNSResolver,
               (const DNSResolver::ResolverOptions& options));
   MOCK_METHOD(void, Run, (Closure * closure));
   MOCK_METHOD(void, Run, (absl::AnyInvocable<void()> closure));

test/core/event_engine/test_suite/posix/oracle_event_engine_posix.h

@@ -171,7 +171,7 @@ class PosixOracleEventEngine final : public EventEngine {
     grpc_core::Crash("unimplemented");
   }
   bool IsWorkerThread() override { return false; };
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& /*options*/) override {
     grpc_core::Crash("unimplemented");
   }

test/core/event_engine/util/aborting_event_engine.h

@@ -49,7 +49,7 @@ class AbortingEventEngine : public EventEngine {
     abort();
   };
   bool IsWorkerThread() override { abort(); }
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& /* options */) override {
     abort();
   }

test/core/ext/filters/event_engine_client_channel_resolver/resolver_fuzzer.cc

@@ -132,7 +132,7 @@ class FuzzingResolverEventEngine
     }
   }
 
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& /* options */) override {
     return std::make_unique<FuzzingDNSResolver>(this);
   }