grpc 1.69.0 → 1.70.1

data/src/core/server/xds_server_config_fetcher.cc

@@ -97,7 +97,7 @@ using ReadDelayHandle = XdsClient::ReadDelayHandle;
 
 // A server config fetcher that fetches the information for configuring server
 // listeners from the xDS control plane.
-class XdsServerConfigFetcher final : public grpc_server_config_fetcher {
+class XdsServerConfigFetcher final : public ServerConfigFetcher {
  public:
   XdsServerConfigFetcher(RefCountedPtr<GrpcXdsClient> xds_client,
                          grpc_server_xds_status_notifier notifier);
@@ -106,12 +106,11 @@ class XdsServerConfigFetcher final : public grpc_server_config_fetcher {
     xds_client_.reset(DEBUG_LOCATION, "XdsServerConfigFetcher");
   }
 
-  void StartWatch(std::string listening_address,
-                  std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
-                      watcher) override;
+  void StartWatch(
+      std::string listening_address,
+      std::unique_ptr<ServerConfigFetcher::WatcherInterface> watcher) override;
 
-  void CancelWatch(
-      grpc_server_config_fetcher::WatcherInterface* watcher) override;
+  void CancelWatch(ServerConfigFetcher::WatcherInterface* watcher) override;
 
   // Return the interested parties from the xds client so that it can be polled.
   grpc_pollset_set* interested_parties() override {
@@ -124,7 +123,7 @@ class XdsServerConfigFetcher final : public grpc_server_config_fetcher {
   RefCountedPtr<GrpcXdsClient> xds_client_;
   const grpc_server_xds_status_notifier serving_status_notifier_;
   Mutex mu_;
-  std::map<grpc_server_config_fetcher::WatcherInterface*, ListenerWatcher*>
+  std::map<ServerConfigFetcher::WatcherInterface*, ListenerWatcher*>
       listener_watchers_ ABSL_GUARDED_BY(mu_);
 };
 
@@ -142,7 +141,7 @@ class XdsServerConfigFetcher::ListenerWatcher final
     : public XdsListenerResourceType::WatcherInterface {
  public:
   ListenerWatcher(RefCountedPtr<GrpcXdsClient> xds_client,
-                  std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
+                  std::unique_ptr<ServerConfigFetcher::WatcherInterface>
                       server_config_watcher,
                   grpc_server_xds_status_notifier serving_status_notifier,
                   std::string listening_address);
@@ -152,13 +151,11 @@ class XdsServerConfigFetcher::ListenerWatcher final
   }
 
   void OnResourceChanged(
-      std::shared_ptr<const XdsListenerResource> listener,
+      absl::StatusOr<std::shared_ptr<const XdsListenerResource>> listener,
       RefCountedPtr<ReadDelayHandle> read_delay_handle) override;
 
-  void OnError(absl::Status status,
-               RefCountedPtr<ReadDelayHandle> read_delay_handle) override;
-
-  void OnResourceDoesNotExist(
+  void OnAmbientError(
+      absl::Status status,
       RefCountedPtr<ReadDelayHandle> read_delay_handle) override;
 
   const std::string& listening_address() const { return listening_address_; }
@@ -182,7 +179,7 @@ class XdsServerConfigFetcher::ListenerWatcher final
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
 
   RefCountedPtr<GrpcXdsClient> xds_client_;
-  const std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
+  const std::unique_ptr<ServerConfigFetcher::WatcherInterface>
       server_config_watcher_;
   const grpc_server_xds_status_notifier serving_status_notifier_;
   const std::string listening_address_;
@@ -199,7 +196,7 @@ class XdsServerConfigFetcher::ListenerWatcher final
 // args that configure the right mTLS certs and cause the right set of HTTP
 // filters to be injected.
 class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
-    : public grpc_server_config_fetcher::ConnectionManager {
+    : public ServerConfigFetcher::ConnectionManager {
  public:
   FilterChainMatchManager(RefCountedPtr<GrpcXdsClient> xds_client,
                           XdsListenerResource::FilterChainMap filter_chain_map,
@@ -248,9 +245,9 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
   // RDS resources.
   void OnRouteConfigChanged(
       const std::string& resource_name,
-      std::shared_ptr<const XdsRouteConfigResource> route_config);
-  void OnError(const std::string& resource_name, absl::Status status);
-  void OnResourceDoesNotExist(const std::string& resource_name);
+      absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+          route_config);
+  void OnAmbientError(const std::string& resource_name, absl::Status status);
 
   RefCountedPtr<GrpcXdsClient> xds_client_;
   // This ref is only kept around till the FilterChainMatchManager becomes
@@ -288,21 +285,18 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
         filter_chain_match_manager_(std::move(filter_chain_match_manager)) {}
 
   void OnResourceChanged(
-      std::shared_ptr<const XdsRouteConfigResource> route_config,
+      absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+          route_config,
       RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) override {
     filter_chain_match_manager_->OnRouteConfigChanged(resource_name_,
                                                       std::move(route_config));
   }
 
-  void OnError(
+  void OnAmbientError(
       absl::Status status,
       RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) override {
-    filter_chain_match_manager_->OnError(resource_name_, status);
-  }
-
-  void OnResourceDoesNotExist(
-      RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) override {
-    filter_chain_match_manager_->OnResourceDoesNotExist(resource_name_);
+    filter_chain_match_manager_->OnAmbientError(resource_name_,
+                                                std::move(status));
   }
 
  private:
@@ -458,9 +452,8 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 
   void Orphaned() override;
   void OnRouteConfigChanged(
-      std::shared_ptr<const XdsRouteConfigResource> rds_update);
-  void OnError(absl::Status status);
-  void OnResourceDoesNotExist();
+      absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>> rds_update);
+  void OnAmbientError(absl::Status status);
 
   RefCountedPtr<GrpcXdsClient> xds_client_;
   std::string resource_name_;
@@ -488,20 +481,16 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       : parent_(std::move(parent)) {}
 
   void OnResourceChanged(
-      std::shared_ptr<const XdsRouteConfigResource> route_config,
+      absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+          route_config,
       RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) override {
     parent_->OnRouteConfigChanged(std::move(route_config));
   }
 
-  void OnError(
+  void OnAmbientError(
       absl::Status status,
       RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) override {
-    parent_->OnError(status);
-  }
-
-  void OnResourceDoesNotExist(
-      RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) override {
-    parent_->OnResourceDoesNotExist();
+    parent_->OnAmbientError(std::move(status));
   }
 
  private:
@@ -532,8 +521,8 @@ std::string ListenerResourceName(absl::string_view resource_name_template,
 
 void XdsServerConfigFetcher::StartWatch(
     std::string listening_address,
-    std::unique_ptr<grpc_server_config_fetcher::WatcherInterface> watcher) {
-  grpc_server_config_fetcher::WatcherInterface* watcher_ptr = watcher.get();
+    std::unique_ptr<ServerConfigFetcher::WatcherInterface> watcher) {
+  ServerConfigFetcher::WatcherInterface* watcher_ptr = watcher.get();
   auto listener_watcher = MakeRefCounted<ListenerWatcher>(
       xds_client_.Ref(DEBUG_LOCATION, "ListenerWatcher"), std::move(watcher),
       serving_status_notifier_, listening_address);
@@ -550,7 +539,7 @@ void XdsServerConfigFetcher::StartWatch(
 }
 
 void XdsServerConfigFetcher::CancelWatch(
-    grpc_server_config_fetcher::WatcherInterface* watcher) {
+    ServerConfigFetcher::WatcherInterface* watcher) {
   MutexLock lock(&mu_);
   auto it = listener_watchers_.find(watcher);
   if (it != listener_watchers_.end()) {
@@ -572,7 +561,7 @@ void XdsServerConfigFetcher::CancelWatch(
 
 XdsServerConfigFetcher::ListenerWatcher::ListenerWatcher(
     RefCountedPtr<GrpcXdsClient> xds_client,
-    std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
+    std::unique_ptr<ServerConfigFetcher::WatcherInterface>
         server_config_watcher,
     grpc_server_xds_status_notifier serving_status_notifier,
     std::string listening_address)
@@ -582,13 +571,20 @@ XdsServerConfigFetcher::ListenerWatcher::ListenerWatcher(
       listening_address_(std::move(listening_address)) {}
 
 void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
-    std::shared_ptr<const XdsListenerResource> listener,
+    absl::StatusOr<std::shared_ptr<const XdsListenerResource>> listener,
     RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) {
+  if (!listener.ok()) {
+    MutexLock lock(&mu_);
+    OnFatalError(absl::Status(
+        listener.status().code(),
+        absl::StrCat("LDS resource: ", listener.status().message())));
+    return;
+  }
   GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
       << "[ListenerWatcher " << this << "] Received LDS update from xds client "
-      << xds_client_.get() << ": " << listener->ToString();
+      << xds_client_.get() << ": " << (*listener)->ToString();
   auto* tcp_listener =
-      absl::get_if<XdsListenerResource::TcpListener>(&listener->listener);
+      absl::get_if<XdsListenerResource::TcpListener>(&(*listener)->listener);
   if (tcp_listener == nullptr) {
     MutexLock lock(&mu_);
     OnFatalError(
@@ -617,27 +613,12 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
   }
 }
 
-void XdsServerConfigFetcher::ListenerWatcher::OnError(
-    absl::Status status,
-    RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) {
-  MutexLock lock(&mu_);
-  if (filter_chain_match_manager_ != nullptr ||
-      pending_filter_chain_match_manager_ != nullptr) {
-    LOG(ERROR) << "ListenerWatcher:" << this
-               << " XdsClient reports error: " << status << " for "
-               << listening_address_
-               << "; ignoring in favor of existing resource";
-  } else {
-    if (serving_status_notifier_.on_serving_status_update != nullptr) {
-      serving_status_notifier_.on_serving_status_update(
-          serving_status_notifier_.user_data, listening_address_.c_str(),
-          {GRPC_STATUS_UNAVAILABLE, status.ToString().c_str()});
-    } else {
-      LOG(ERROR) << "ListenerWatcher:" << this
-                 << " error obtaining xDS Listener resource: " << status
-                 << "; not serving on " << listening_address_;
-    }
-  }
+void XdsServerConfigFetcher::ListenerWatcher::OnAmbientError(
+    absl::Status status, RefCountedPtr<ReadDelayHandle> /*read_delay_handle*/) {
+  LOG(ERROR) << "ListenerWatcher:" << this
+             << " XdsClient reports ambient error: " << status << " for "
+             << listening_address_
+             << "; ignoring in favor of existing resource";
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::OnFatalError(
@@ -660,12 +641,6 @@ void XdsServerConfigFetcher::ListenerWatcher::OnFatalError(
   }
 }
 
-void XdsServerConfigFetcher::ListenerWatcher::OnResourceDoesNotExist(
-    RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) {
-  MutexLock lock(&mu_);
-  OnFatalError(absl::NotFoundError("Requested listener does not exist"));
-}
-
 void XdsServerConfigFetcher::ListenerWatcher::
     PendingFilterChainMatchManagerReadyLocked(
         XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager*
@@ -843,7 +818,8 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     OnRouteConfigChanged(
         const std::string& resource_name,
-        std::shared_ptr<const XdsRouteConfigResource> route_config) {
+        absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+            route_config) {
   RefCountedPtr<ListenerWatcher> listener_watcher;
   {
     MutexLock lock(&mu_);
@@ -853,32 +829,12 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
         listener_watcher = std::move(listener_watcher_);
       }
     }
-    state.rds_update = std::move(route_config);
-  }
-  // Promote the filter chain match manager object if all the referenced
-  // resources are fetched.
-  if (listener_watcher != nullptr) {
-    listener_watcher->PendingFilterChainMatchManagerReady(this);
-  }
-}
-
-void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::OnError(
-    const std::string& resource_name, absl::Status status) {
-  RefCountedPtr<ListenerWatcher> listener_watcher;
-  {
-    MutexLock lock(&mu_);
-    auto& state = rds_map_[resource_name];
-    if (!state.rds_update.has_value()) {
-      if (--rds_resources_yet_to_fetch_ == 0) {
-        listener_watcher = std::move(listener_watcher_);
-      }
-      state.rds_update = status;
-    } else {
-      // Prefer existing good version over current errored version
-      if (!state.rds_update->ok()) {
-        state.rds_update = status;
-      }
+    if (!route_config.ok()) {
+      route_config = absl::UnavailableError(
+          absl::StrCat("RDS resource ", resource_name, ": ",
+                       route_config.status().message()));
     }
+    state.rds_update = std::move(route_config);
   }
   // Promote the filter chain match manager object if all the referenced
   // resources are fetched.
@@ -888,24 +844,10 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::OnError(
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    OnResourceDoesNotExist(const std::string& resource_name) {
-  RefCountedPtr<ListenerWatcher> listener_watcher;
-  {
-    MutexLock lock(&mu_);
-    auto& state = rds_map_[resource_name];
-    if (!state.rds_update.has_value()) {
-      if (--rds_resources_yet_to_fetch_ == 0) {
-        listener_watcher = std::move(listener_watcher_);
-      }
-    }
-    state.rds_update =
-        absl::NotFoundError("Requested route config does not exist");
-  }
-  // Promote the filter chain match manager object if all the referenced
-  // resources are fetched.
-  if (listener_watcher != nullptr) {
-    listener_watcher->PendingFilterChainMatchManagerReady(this);
-  }
+    OnAmbientError(const std::string& resource_name, absl::Status status) {
+  LOG(ERROR) << "RouteConfigWatcher:" << this
+             << " XdsClient reports ambient error: " << status << " for "
+             << resource_name << "; ignoring in favor of existing resource";
 }
 
 const XdsListenerResource::FilterChainData* FindFilterChainDataForSourcePort(
@@ -1309,8 +1251,13 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     DynamicXdsServerConfigSelectorProvider::OnRouteConfigChanged(
-        std::shared_ptr<const XdsRouteConfigResource> rds_update) {
+        absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
+            rds_update) {
   MutexLock lock(&mu_);
+  if (!rds_update.ok()) {
+    rds_update = absl::UnavailableError(absl::StrCat(
+        "RDS resource ", resource_name_, ": ", rds_update.status().message()));
+  }
   resource_ = std::move(rds_update);
   if (watcher_ == nullptr) {
     return;
@@ -1319,34 +1266,22 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
   // DynamicXdsServerConfigSelectorProvider while holding a lock, but if that
   // ever changes, we would want to invoke the update outside the critical
   // region with the use of a WorkSerializer.
-  watcher_->OnServerConfigSelectorUpdate(XdsServerConfigSelector::Create(
-      static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
-          .http_filter_registry(),
-      *resource_, http_filters_));
-}
-
-void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    DynamicXdsServerConfigSelectorProvider::OnError(absl::Status status) {
-  MutexLock lock(&mu_);
-  // Prefer existing good update.
-  if (resource_.ok()) {
-    return;
-  }
-  resource_ = status;
-  if (watcher_ == nullptr) {
-    return;
+  if (!resource_.ok()) {
+    watcher_->OnServerConfigSelectorUpdate(resource_.status());
+  } else {
+    watcher_->OnServerConfigSelectorUpdate(XdsServerConfigSelector::Create(
+        static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+            .http_filter_registry(),
+        *resource_, http_filters_));
   }
-  watcher_->OnServerConfigSelectorUpdate(resource_.status());
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    DynamicXdsServerConfigSelectorProvider::OnResourceDoesNotExist() {
-  MutexLock lock(&mu_);
-  resource_ = absl::NotFoundError("Requested route config does not exist");
-  if (watcher_ == nullptr) {
-    return;
-  }
-  watcher_->OnServerConfigSelectorUpdate(resource_.status());
+    DynamicXdsServerConfigSelectorProvider::OnAmbientError(
+        absl::Status status) {
+  LOG(ERROR) << "RouteConfigWatcher:" << this
+             << " XdsClient reports ambient error: " << status << " for "
+             << resource_name_ << "; ignoring in favor of existing resource";
 }
 
 }  // namespace
@@ -1379,6 +1314,7 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
                   "bootstrap file.";
     return nullptr;
   }
-  return new grpc_core::XdsServerConfigFetcher(std::move(*xds_client),
-                                               notifier);
+  return (new grpc_core::XdsServerConfigFetcher(std::move(*xds_client),
+                                                notifier))
+      ->c_ptr();
 }

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -298,7 +298,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
     if (details.size > 0) {
       error = absl::StrCat("Status ", code, " from handshaker service: ",
                            absl::string_view(details.data, details.size));
-      LOG(ERROR) << error;
+      LOG_EVERY_N_SEC(INFO, 1) << error;
     }
   }
   // TODO(apolcyn): consider short ciruiting handle_response_done and

data/src/core/util/backoff.cc

@@ -22,16 +22,27 @@
 
 #include <algorithm>
 
+#include "src/core/lib/experiments/experiments.h"
+
 namespace grpc_core {
 
 BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 
 Duration BackOff::NextAttemptDelay() {
-  if (initial_) {
-    initial_ = false;
+  if (IsBackoffCapInitialAtMaxEnabled()) {
+    if (initial_) {
+      initial_ = false;
+    } else {
+      current_backoff_ *= options_.multiplier();
+    }
+    current_backoff_ = std::min(current_backoff_, options_.max_backoff());
   } else {
-    current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
-                                options_.max_backoff());
+    if (initial_) {
+      initial_ = false;
+    } else {
+      current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
+                                  options_.max_backoff());
+    }
   }
   const double jitter =
       absl::Uniform(rand_gen_, 1 - options_.jitter(), 1 + options_.jitter());

data/src/core/util/http_client/httpcli.cc

@@ -35,9 +35,10 @@
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/handshaker/tcp_connect/tcp_connect_handshaker.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -55,6 +56,9 @@ namespace grpc_core {
 
 namespace {
 
+using grpc_event_engine::experimental::EventEngine;
+using grpc_event_engine::experimental::ResolvedAddressToURI;
+
 grpc_httpcli_get_override g_get_override;
 grpc_httpcli_post_override g_post_override;
 grpc_httpcli_put_override g_put_override;
@@ -171,7 +175,15 @@ HttpRequest::HttpRequest(
       pollent_(pollent),
       pollset_set_(grpc_pollset_set_create()),
       test_only_generate_response_(std::move(test_only_generate_response)),
-      resolver_(GetDNSResolver()) {
+      use_event_engine_dns_resolver_(IsEventEngineDnsNonClientChannelEnabled()),
+      resolver_(!use_event_engine_dns_resolver_ ? GetDNSResolver() : nullptr),
+      ee_resolver_(
+          use_event_engine_dns_resolver_
+              ? ChannelArgs::FromC(channel_args_)
+                    .GetObjectRef<EventEngine>()
+                    ->GetDNSResolver(
+                        EventEngine::DNSResolver::ResolverOptions())
+              : absl::InternalError("EventEngine DNS is not enabled")) {
   grpc_http_parser_init(&parser_, GRPC_HTTP_RESPONSE, response);
   grpc_slice_buffer_init(&incoming_);
   grpc_slice_buffer_init(&outgoing_);
@@ -204,11 +216,39 @@ void HttpRequest::Start() {
   if (test_only_generate_response_.has_value()) {
     if (test_only_generate_response_.value()()) return;
   }
+  if (use_event_engine_dns_resolver_ && !ee_resolver_.ok()) {
+    Finish(ee_resolver_.status());
+    return;
+  }
   Ref().release();  // ref held by pending DNS resolution
-  dns_request_handle_ = resolver_->LookupHostname(
-      absl::bind_front(&HttpRequest::OnResolved, this), uri_.authority(),
-      uri_.scheme(), kDefaultDNSRequestTimeout, pollset_set_,
-      /*name_server=*/"");
+  if (use_event_engine_dns_resolver_) {
+    (*ee_resolver_)
+        ->LookupHostname(
+            [this](absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
+                       addresses_or) {
+              ApplicationCallbackExecCtx callback_exec_ctx;
+              ExecCtx exec_ctx;
+              OnResolved(addresses_or);
+            },
+            uri_.authority(), uri_.scheme());
+  } else {
+    dns_request_handle_ = resolver_->LookupHostname(
+        [this](absl::StatusOr<std::vector<grpc_resolved_address>> addresses) {
+          if (addresses.ok()) {
+            std::vector<EventEngine::ResolvedAddress> ee_addresses;
+            for (const auto& addr : *addresses) {
+              ee_addresses.push_back(
+                  grpc_event_engine::experimental::CreateResolvedAddress(addr));
+            }
+            OnResolved(ee_addresses);
+          } else {
+            OnResolved(addresses.status());
+          }
+        },
+        uri_.authority(), uri_.scheme(), kDefaultDNSRequestTimeout,
+        pollset_set_,
+        /*name_server=*/"");
+  }
 }
 
 void HttpRequest::Orphan() {
@@ -217,10 +257,16 @@ void HttpRequest::Orphan() {
     CHECK(!cancelled_);
     cancelled_ = true;
     // cancel potentially pending DNS resolution.
-    if (dns_request_handle_.has_value() &&
-        resolver_->Cancel(dns_request_handle_.value())) {
-      Finish(GRPC_ERROR_CREATE("cancelled during DNS resolution"));
-      Unref();
+    if (use_event_engine_dns_resolver_) {
+      if (*ee_resolver_ != nullptr) {
+        ee_resolver_->reset();
+      }
+    } else {
+      if (dns_request_handle_.has_value() &&
+          resolver_->Cancel(dns_request_handle_.value())) {
+        Finish(GRPC_ERROR_CREATE("cancelled during DNS resolution"));
+        Unref();
+      }
     }
     if (handshake_mgr_ != nullptr) {
       // Shutdown will cancel any ongoing tcp connect.
@@ -236,8 +282,7 @@ void HttpRequest::AppendError(grpc_error_handle error) {
   if (overall_error_.ok()) {
     overall_error_ = GRPC_ERROR_CREATE("Failed HTTP/1 client request");
   }
-  const grpc_resolved_address* addr = &addresses_[next_address_ - 1];
-  auto addr_text = grpc_sockaddr_to_uri(addr);
+  auto addr_text = ResolvedAddressToURI(addresses_[next_address_ - 1]);
   if (addr_text.ok()) error = AddMessagePrefix(*addr_text, std::move(error));
   overall_error_ = grpc_error_add_child(overall_error_, std::move(error));
 }
@@ -311,7 +356,7 @@ void HttpRequest::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
   StartWrite();
 }
 
-void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
+void HttpRequest::DoHandshake(const EventEngine::ResolvedAddress& addr) {
   // Create the security connector using the credentials and target name.
   ChannelArgs args = ChannelArgs::FromC(channel_args_);
   RefCountedPtr<grpc_channel_security_connector> sc =
@@ -322,7 +367,7 @@ void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
                                          &overall_error_, 1));
     return;
   }
-  absl::StatusOr<std::string> address = grpc_sockaddr_to_uri(addr);
+  absl::StatusOr<std::string> address = ResolvedAddressToURI(addr);
   if (!address.ok()) {
     Finish(GRPC_ERROR_CREATE_REFERENCING("Failed to extract URI from address",
                                          &overall_error_, 1));
@@ -355,15 +400,18 @@ void HttpRequest::NextAddress(grpc_error_handle error) {
                                          &overall_error_, 1));
     return;
   }
-  const grpc_resolved_address* addr = &addresses_[next_address_++];
-  DoHandshake(addr);
+  DoHandshake(addresses_[next_address_++]);
 }
 
 void HttpRequest::OnResolved(
-    absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
+    absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses_or) {
   RefCountedPtr<HttpRequest> unreffer(this);
   MutexLock lock(&mu_);
-  dns_request_handle_.reset();
+  if (use_event_engine_dns_resolver_) {
+    ee_resolver_->reset();
+  } else {
+    dns_request_handle_.reset();
+  }
   if (cancelled_) {
     Finish(GRPC_ERROR_CREATE("cancelled during DNS resolution"));
     return;

data/src/core/util/http_client/httpcli.h

@@ -19,6 +19,7 @@
 #ifndef GRPC_SRC_CORE_UTIL_HTTP_CLIENT_HTTPCLI_H
 #define GRPC_SRC_CORE_UTIL_HTTP_CLIENT_HTTPCLI_H
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
 #include <grpc/support/port_platform.h>
@@ -42,7 +43,6 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/http_client/parser.h"
@@ -225,13 +225,16 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
 
   void OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result);
 
-  void DoHandshake(const grpc_resolved_address* addr)
+  void DoHandshake(
+      const grpc_event_engine::experimental::EventEngine::ResolvedAddress& addr)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   void NextAddress(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   void OnResolved(
-      absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or);
+      absl::StatusOr<std::vector<
+          grpc_event_engine::experimental::EventEngine::ResolvedAddress>>
+          addresses_or);
 
   const URI uri_;
   const grpc_slice request_text_;
@@ -252,16 +255,23 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   RefCountedPtr<HandshakeManager> handshake_mgr_ ABSL_GUARDED_BY(mu_);
   bool cancelled_ ABSL_GUARDED_BY(mu_) = false;
   grpc_http_parser parser_ ABSL_GUARDED_BY(mu_);
-  std::vector<grpc_resolved_address> addresses_ ABSL_GUARDED_BY(mu_);
+  std::vector<grpc_event_engine::experimental::EventEngine::ResolvedAddress>
+      addresses_ ABSL_GUARDED_BY(mu_);
   size_t next_address_ ABSL_GUARDED_BY(mu_) = 0;
   int have_read_byte_ ABSL_GUARDED_BY(mu_) = 0;
   grpc_iomgr_object iomgr_obj_ ABSL_GUARDED_BY(mu_);
   grpc_slice_buffer incoming_ ABSL_GUARDED_BY(mu_);
   grpc_slice_buffer outgoing_ ABSL_GUARDED_BY(mu_);
   grpc_error_handle overall_error_ ABSL_GUARDED_BY(mu_) = absl::OkStatus();
+  // TODO(yijiem): remove these once event_engine_dns_non_client_channel
+  // experiment is fully enabled.
+  bool use_event_engine_dns_resolver_;
   std::shared_ptr<DNSResolver> resolver_;
   absl::optional<DNSResolver::TaskHandle> dns_request_handle_
       ABSL_GUARDED_BY(mu_) = DNSResolver::kNullHandle;
+  absl::StatusOr<std::unique_ptr<
+      grpc_event_engine::experimental::EventEngine::DNSResolver>>
+      ee_resolver_;
 };
 
 }  // namespace grpc_core