grpc 1.56.2 → 1.57.0.pre1

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_override_host.cc

@@ -39,7 +39,6 @@
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
 
-#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
@@ -66,6 +65,7 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
+#include "src/core/lib/load_balancing/delegating_helper.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
@@ -95,12 +95,10 @@ struct PtrLessThan {
 };
 
 XdsHealthStatus GetAddressHealthStatus(const ServerAddress& address) {
-  auto attribute = address.GetAttribute(XdsEndpointHealthStatusAttribute::kKey);
-  if (attribute == nullptr) {
-    return XdsHealthStatus(XdsHealthStatus::HealthStatus::kUnknown);
-  }
-  return static_cast<const XdsEndpointHealthStatusAttribute*>(attribute)
-      ->status();
+  return XdsHealthStatus(static_cast<XdsHealthStatus::HealthStatus>(
+      address.args()
+          .GetInt(GRPC_ARG_XDS_HEALTH_STATUS)
+          .value_or(XdsHealthStatus::HealthStatus::kUnknown)));
 }
 
 //
@@ -215,27 +213,17 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
     XdsHealthStatusSet override_host_health_status_set_;
   };
 
-  class Helper : public ChannelControlHelper {
+  class Helper
+      : public ParentOwningDelegatingChannelControlHelper<XdsOverrideHostLb> {
    public:
     explicit Helper(RefCountedPtr<XdsOverrideHostLb> xds_override_host_policy)
-        : xds_override_host_policy_(std::move(xds_override_host_policy)) {}
-
-    ~Helper() override {
-      xds_override_host_policy_.reset(DEBUG_LOCATION, "Helper");
-    }
+        : ParentOwningDelegatingChannelControlHelper(
+              std::move(xds_override_host_policy)) {}
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
         ServerAddress address, const ChannelArgs& args) override;
     void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      RefCountedPtr<SubchannelPicker> picker) override;
-    void RequestReresolution() override;
-    absl::string_view GetAuthority() override;
-    grpc_event_engine::experimental::EventEngine* GetEventEngine() override;
-    void AddTraceEvent(TraceSeverity severity,
-                       absl::string_view message) override;
-
-   private:
-    RefCountedPtr<XdsOverrideHostLb> xds_override_host_policy_;
   };
 
   class SubchannelEntry {
@@ -619,42 +607,20 @@ void XdsOverrideHostLb::OnSubchannelConnectivityStateChange(
 RefCountedPtr<SubchannelInterface> XdsOverrideHostLb::Helper::CreateSubchannel(
     ServerAddress address, const ChannelArgs& args) {
   auto subchannel =
-      xds_override_host_policy_->channel_control_helper()->CreateSubchannel(
-          address, args);
-  return xds_override_host_policy_->AdoptSubchannel(address, subchannel);
+      parent()->channel_control_helper()->CreateSubchannel(address, args);
+  return parent()->AdoptSubchannel(address, subchannel);
 }
 
 void XdsOverrideHostLb::Helper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
     RefCountedPtr<SubchannelPicker> picker) {
-  if (xds_override_host_policy_->shutting_down_) return;
+  if (parent()->shutting_down_) return;
   // Save the state and picker.
-  xds_override_host_policy_->state_ = state;
-  xds_override_host_policy_->status_ = status;
-  xds_override_host_policy_->picker_ = std::move(picker);
+  parent()->state_ = state;
+  parent()->status_ = status;
+  parent()->picker_ = std::move(picker);
   // Wrap the picker and return it to the channel.
-  xds_override_host_policy_->MaybeUpdatePickerLocked();
-}
-
-void XdsOverrideHostLb::Helper::RequestReresolution() {
-  if (xds_override_host_policy_->shutting_down_) return;
-  xds_override_host_policy_->channel_control_helper()->RequestReresolution();
-}
-
-absl::string_view XdsOverrideHostLb::Helper::GetAuthority() {
-  return xds_override_host_policy_->channel_control_helper()->GetAuthority();
-}
-
-grpc_event_engine::experimental::EventEngine*
-XdsOverrideHostLb::Helper::GetEventEngine() {
-  return xds_override_host_policy_->channel_control_helper()->GetEventEngine();
-}
-
-void XdsOverrideHostLb::Helper::AddTraceEvent(TraceSeverity severity,
-                                              absl::string_view message) {
-  if (xds_override_host_policy_->shutting_down_) return;
-  xds_override_host_policy_->channel_control_helper()->AddTraceEvent(severity,
-                                                                     message);
+  parent()->MaybeUpdatePickerLocked();
 }
 
 //

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_wrr_locality.cc

@@ -27,13 +27,13 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
-#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_attributes.h"
+#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -47,12 +47,11 @@
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/json/json_writer.h"
+#include "src/core/lib/load_balancing/delegating_helper.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
 #include "src/core/lib/resolver/server_address.h"
-#include "src/core/lib/transport/connectivity_state.h"
 
 namespace grpc_core {
 
@@ -119,26 +118,7 @@ class XdsWrrLocalityLb : public LoadBalancingPolicy {
   void ResetBackoffLocked() override;
 
  private:
-  class Helper : public ChannelControlHelper {
-   public:
-    explicit Helper(RefCountedPtr<XdsWrrLocalityLb> xds_wrr_locality)
-        : xds_wrr_locality_(std::move(xds_wrr_locality)) {}
-
-    ~Helper() override { xds_wrr_locality_.reset(DEBUG_LOCATION, "Helper"); }
-
-    RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        ServerAddress address, const ChannelArgs& args) override;
-    void UpdateState(grpc_connectivity_state state, const absl::Status& status,
-                     RefCountedPtr<SubchannelPicker> picker) override;
-    void RequestReresolution() override;
-    absl::string_view GetAuthority() override;
-    grpc_event_engine::experimental::EventEngine* GetEventEngine() override;
-    void AddTraceEvent(TraceSeverity severity,
-                       absl::string_view message) override;
-
-   private:
-    RefCountedPtr<XdsWrrLocalityLb> xds_wrr_locality_;
-  };
+  using Helper = ParentOwningDelegatingChannelControlHelper<XdsWrrLocalityLb>;
 
   ~XdsWrrLocalityLb() override;
 
@@ -191,17 +171,17 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
   std::map<std::string, uint32_t> locality_weights;
   if (args.addresses.ok()) {
     for (const auto& address : *args.addresses) {
-      auto* attribute = static_cast<const XdsLocalityAttribute*>(
-          address.GetAttribute(kXdsLocalityNameAttributeKey));
-      if (attribute != nullptr) {
+      auto* locality_name = address.args().GetObject<XdsLocalityName>();
+      uint32_t weight =
+          address.args().GetInt(GRPC_ARG_XDS_LOCALITY_WEIGHT).value_or(0);
+      if (locality_name != nullptr && weight > 0) {
         auto p = locality_weights.emplace(
-            attribute->locality_name()->AsHumanReadableString(),
-            attribute->weight());
-        if (!p.second && p.first->second != attribute->weight()) {
+            locality_name->AsHumanReadableString(), weight);
+        if (!p.second && p.first->second != weight) {
           gpr_log(GPR_ERROR,
                   "INTERNAL ERROR: xds_wrr_locality found different weights "
-                  "for locality %s (%d vs %d); using first value",
-                  p.first->first.c_str(), p.first->second, attribute->weight());
+                  "for locality %s (%u vs %u); using first value",
+                  p.first->first.c_str(), p.first->second, weight);
         }
       }
     }
@@ -290,48 +270,6 @@ OrphanablePtr<LoadBalancingPolicy> XdsWrrLocalityLb::CreateChildPolicyLocked(
   return lb_policy;
 }
 
-//
-// XdsWrrLocalityLb::Helper
-//
-
-RefCountedPtr<SubchannelInterface> XdsWrrLocalityLb::Helper::CreateSubchannel(
-    ServerAddress address, const ChannelArgs& args) {
-  return xds_wrr_locality_->channel_control_helper()->CreateSubchannel(
-      std::move(address), args);
-}
-
-void XdsWrrLocalityLb::Helper::UpdateState(
-    grpc_connectivity_state state, const absl::Status& status,
-    RefCountedPtr<SubchannelPicker> picker) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_wrr_locality_lb_trace)) {
-    gpr_log(
-        GPR_INFO,
-        "[xds_wrr_locality_lb %p] update from child: state=%s (%s) picker=%p",
-        xds_wrr_locality_.get(), ConnectivityStateName(state),
-        status.ToString().c_str(), picker.get());
-  }
-  xds_wrr_locality_->channel_control_helper()->UpdateState(state, status,
-                                                           std::move(picker));
-}
-
-void XdsWrrLocalityLb::Helper::RequestReresolution() {
-  xds_wrr_locality_->channel_control_helper()->RequestReresolution();
-}
-
-absl::string_view XdsWrrLocalityLb::Helper::GetAuthority() {
-  return xds_wrr_locality_->channel_control_helper()->GetAuthority();
-}
-
-grpc_event_engine::experimental::EventEngine*
-XdsWrrLocalityLb::Helper::GetEventEngine() {
-  return xds_wrr_locality_->channel_control_helper()->GetEventEngine();
-}
-
-void XdsWrrLocalityLb::Helper::AddTraceEvent(TraceSeverity severity,
-                                             absl::string_view message) {
-  xds_wrr_locality_->channel_control_helper()->AddTraceEvent(severity, message);
-}
-
 //
 // factory
 //

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -33,7 +33,6 @@
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 
-#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -70,7 +69,6 @@
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/config_vars.h"
-#include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/service_config/service_config_impl.h"
@@ -706,8 +704,7 @@ class AresDNSResolver : public DNSResolver {
   // the previous default DNS resolver, used to delegate blocking DNS calls to
   std::shared_ptr<DNSResolver> default_resolver_ = GetDNSResolver();
   Mutex mu_;
-  grpc_event_engine::experimental::LookupTaskHandleSet open_requests_
-      ABSL_GUARDED_BY(mu_);
+  TaskHandleSet open_requests_ ABSL_GUARDED_BY(mu_);
   intptr_t aba_token_ ABSL_GUARDED_BY(mu_) = 0;
 };
 

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

@@ -28,7 +28,6 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/cleanup/cleanup.h"
-#include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
@@ -46,9 +45,7 @@
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
-#include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -73,8 +70,6 @@ namespace {
 #define GRPC_DNS_DEFAULT_QUERY_TIMEOUT_MS 120000
 
 using grpc_event_engine::experimental::EventEngine;
-using grpc_event_engine::experimental::HandleToString;
-using grpc_event_engine::experimental::LookupTaskHandleSet;
 
 // TODO(hork): Investigate adding a resolver test scenario where the first
 // balancer hostname lookup result is an error, and the second contains valid
@@ -121,6 +116,7 @@ class EventEngineClientChannelDNSResolver : public PollingResolver {
     void Orphan() override ABSL_NO_THREAD_SAFETY_ANALYSIS;
 
    private:
+    void OnTimeout() ABSL_LOCKS_EXCLUDED(on_resolved_mu_);
     void OnHostnameResolved(
         absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses);
     void OnSRVResolved(
@@ -149,14 +145,9 @@ class EventEngineClientChannelDNSResolver : public PollingResolver {
     RefCountedPtr<EventEngineClientChannelDNSResolver> resolver_;
     Mutex on_resolved_mu_;
     // Lookup callbacks
-    absl::optional<EventEngine::DNSResolver::LookupTaskHandle> hostname_handle_
-        ABSL_GUARDED_BY(on_resolved_mu_);
-    absl::optional<EventEngine::DNSResolver::LookupTaskHandle> srv_handle_
-        ABSL_GUARDED_BY(on_resolved_mu_);
-    absl::optional<EventEngine::DNSResolver::LookupTaskHandle> txt_handle_
-        ABSL_GUARDED_BY(on_resolved_mu_);
-    LookupTaskHandleSet balancer_hostname_handles_
-        ABSL_GUARDED_BY(on_resolved_mu_);
+    bool is_hostname_inflight_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
+    bool is_srv_inflight_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
+    bool is_txt_inflight_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
     // Output fields from requests.
     ServerAddressList addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
     ServerAddressList balancer_addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
@@ -164,9 +155,13 @@ class EventEngineClientChannelDNSResolver : public PollingResolver {
     absl::StatusOr<std::string> service_config_json_
         ABSL_GUARDED_BY(on_resolved_mu_);
     // Other internal state
+    size_t number_of_balancer_hostnames_initiated_
+        ABSL_GUARDED_BY(on_resolved_mu_) = 0;
     size_t number_of_balancer_hostnames_resolved_
         ABSL_GUARDED_BY(on_resolved_mu_) = 0;
     bool orphaned_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
+    absl::optional<EventEngine::TaskHandle> timeout_handle_
+        ABSL_GUARDED_BY(on_resolved_mu_);
     std::unique_ptr<EventEngine::DNSResolver> event_engine_resolver_;
   };
 
@@ -205,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));
 }
 
 // ----------------------------------------------------------------------------
@@ -225,41 +228,43 @@ EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   GRPC_EVENT_ENGINE_RESOLVER_TRACE(
       "DNSResolver::%p Starting hostname resolution for %s", resolver_.get(),
       resolver_->name_to_resolve().c_str());
-  hostname_handle_ = event_engine_resolver_->LookupHostname(
+  is_hostname_inflight_ = true;
+  event_engine_resolver_->LookupHostname(
       [self = Ref(DEBUG_LOCATION, "OnHostnameResolved")](
           absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses) {
         self->OnHostnameResolved(std::move(addresses));
       },
-      resolver_->name_to_resolve(), kDefaultSecurePort,
-      resolver_->query_timeout_ms_);
-  GRPC_EVENT_ENGINE_RESOLVER_TRACE("hostname lookup handle: %s",
-                                   HandleToString(*hostname_handle_).c_str());
+      resolver_->name_to_resolve(), kDefaultSecurePort);
   if (resolver_->enable_srv_queries_) {
     GRPC_EVENT_ENGINE_RESOLVER_TRACE(
         "DNSResolver::%p Starting SRV record resolution for %s",
         resolver_.get(), resolver_->name_to_resolve().c_str());
-    srv_handle_ = event_engine_resolver_->LookupSRV(
+    is_srv_inflight_ = true;
+    event_engine_resolver_->LookupSRV(
         [self = Ref(DEBUG_LOCATION, "OnSRVResolved")](
             absl::StatusOr<std::vector<EventEngine::DNSResolver::SRVRecord>>
                 srv_records) { self->OnSRVResolved(std::move(srv_records)); },
-        resolver_->name_to_resolve(), resolver_->query_timeout_ms_);
-    GRPC_EVENT_ENGINE_RESOLVER_TRACE("srv lookup handle: %s",
-                                     HandleToString(*srv_handle_).c_str());
+        resolver_->name_to_resolve());
   }
   if (resolver_->request_service_config_) {
     GRPC_EVENT_ENGINE_RESOLVER_TRACE(
         "DNSResolver::%p Starting TXT record resolution for %s",
         resolver_.get(), resolver_->name_to_resolve().c_str());
-    txt_handle_ = event_engine_resolver_->LookupTXT(
+    is_txt_inflight_ = true;
+    event_engine_resolver_->LookupTXT(
         [self = Ref(DEBUG_LOCATION, "OnTXTResolved")](
             absl::StatusOr<std::vector<std::string>> service_config) {
           self->OnTXTResolved(std::move(service_config));
         },
-        absl::StrCat("_grpc_config.", resolver_->name_to_resolve()),
-        resolver_->query_timeout_ms_);
-    GRPC_EVENT_ENGINE_RESOLVER_TRACE("txt lookup handle: %s",
-                                     HandleToString(*txt_handle_).c_str());
+        absl::StrCat("_grpc_config.", resolver_->name_to_resolve()));
   }
+  // Initialize overall DNS resolution timeout alarm.
+  auto timeout = resolver_->query_timeout_ms_.count() == 0
+                     ? EventEngine::Duration::max()
+                     : resolver_->query_timeout_ms_;
+  timeout_handle_ = resolver_->event_engine_->RunAfter(
+      timeout,
+      [self = Ref(DEBUG_LOCATION, "OnTimeout")]() { self->OnTimeout(); });
 }
 
 EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
@@ -272,24 +277,26 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   {
     MutexLock lock(&on_resolved_mu_);
     orphaned_ = true;
-    // Event if cancellation fails here, OnResolvedLocked will return early, and
-    // the resolver will never see a completed request.
-    if (hostname_handle_.has_value()) {
-      event_engine_resolver_->CancelLookup(*hostname_handle_);
-    }
-    if (srv_handle_.has_value()) {
-      event_engine_resolver_->CancelLookup(*srv_handle_);
-    }
-    for (const auto& handle : balancer_hostname_handles_) {
-      event_engine_resolver_->CancelLookup(handle);
-    }
-    if (txt_handle_.has_value()) {
-      event_engine_resolver_->CancelLookup(*txt_handle_);
+    if (timeout_handle_.has_value()) {
+      resolver_->event_engine_->Cancel(*timeout_handle_);
+      timeout_handle_.reset();
     }
+    // Even if cancellation fails here, OnResolvedLocked will return early, and
+    // the resolver will never see a completed request.
+    event_engine_resolver_.reset();
   }
   Unref(DEBUG_LOCATION, "Orphan");
 }
 
+void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
+    OnTimeout() {
+  MutexLock lock(&on_resolved_mu_);
+  GRPC_EVENT_ENGINE_RESOLVER_TRACE("DNSResolver::%p OnTimeout",
+                                   resolver_.get());
+  timeout_handle_.reset();
+  event_engine_resolver_.reset();
+}
+
 void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     OnHostnameResolved(absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
                            new_addresses) {
@@ -298,7 +305,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   {
     MutexLock lock(&on_resolved_mu_);
     if (orphaned_) return;
-    hostname_handle_.reset();
+    is_hostname_inflight_ = false;
     if (!new_addresses.ok()) {
       errors_.AddError(new_addresses.status().message());
     } else {
@@ -327,7 +334,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   });
   MutexLock lock(&on_resolved_mu_);
   if (orphaned_) return;
-  srv_handle_.reset();
+  is_srv_inflight_ = false;
   if (!srv_records.ok()) {
     // An error has occurred, finish resolving.
     errors_.AddError(srv_records.status().message());
@@ -338,12 +345,20 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     result = OnResolvedLocked();
     return;
   }
+  if (!timeout_handle_.has_value()) {
+    // We could reach here if timeout happened while an SRV query was finishing.
+    errors_.AddError(
+        "timed out - not initiating subsequent balancer hostname requests");
+    result = OnResolvedLocked();
+    return;
+  }
   // Do a subsequent hostname query since SRV records were returned
   for (auto& srv_record : *srv_records) {
     GRPC_EVENT_ENGINE_RESOLVER_TRACE(
         "DNSResolver::%p Starting balancer hostname resolution for %s:%d",
         resolver_.get(), srv_record.host.c_str(), srv_record.port);
-    auto handle = event_engine_resolver_->LookupHostname(
+    ++number_of_balancer_hostnames_initiated_;
+    event_engine_resolver_->LookupHostname(
         [host = std::move(srv_record.host),
          self = Ref(DEBUG_LOCATION, "OnBalancerHostnamesResolved")](
             absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
@@ -351,11 +366,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
           self->OnBalancerHostnamesResolved(std::move(host),
                                             std::move(new_balancer_addresses));
         },
-        srv_record.host, std::to_string(srv_record.port),
-        resolver_->query_timeout_ms_);
-    GRPC_EVENT_ENGINE_RESOLVER_TRACE("balancer hostname lookup handle: %s",
-                                     HandleToString(handle).c_str());
-    balancer_hostname_handles_.insert(handle);
+        srv_record.host, std::to_string(srv_record.port));
   }
 }
 
@@ -399,8 +410,8 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   {
     MutexLock lock(&on_resolved_mu_);
     if (orphaned_) return;
-    GPR_ASSERT(txt_handle_.has_value());
-    txt_handle_.reset();
+    GPR_ASSERT(is_txt_inflight_);
+    is_txt_inflight_ = false;
     if (!service_config.ok()) {
       errors_.AddError(service_config.status().message());
       service_config_json_ = service_config.status();
@@ -474,20 +485,19 @@ absl::optional<Resolver::Result> EventEngineClientChannelDNSResolver::
     EventEngineDNSRequestWrapper::OnResolvedLocked() {
   if (orphaned_) return absl::nullopt;
   // Wait for all requested queries to return.
-  if (hostname_handle_.has_value() || srv_handle_.has_value() ||
-      txt_handle_.has_value() ||
+  if (is_hostname_inflight_ || is_srv_inflight_ || is_txt_inflight_ ||
       number_of_balancer_hostnames_resolved_ !=
-          balancer_hostname_handles_.size()) {
+          number_of_balancer_hostnames_initiated_) {
     GRPC_EVENT_ENGINE_RESOLVER_TRACE(
         "DNSResolver::%p OnResolved() waiting for results (hostname: %s, "
         "srv: %s, "
         "txt: %s, "
         "balancer addresses: %" PRIuPTR "/%" PRIuPTR " complete",
-        this, hostname_handle_.has_value() ? "waiting" : "done",
-        srv_handle_.has_value() ? "waiting" : "done",
-        txt_handle_.has_value() ? "waiting" : "done",
+        this, is_hostname_inflight_ ? "waiting" : "done",
+        is_srv_inflight_ ? "waiting" : "done",
+        is_txt_inflight_ ? "waiting" : "done",
         number_of_balancer_hostnames_resolved_,
-        balancer_hostname_handles_.size());
+        number_of_balancer_hostnames_initiated_);
     return absl::nullopt;
   }
   GRPC_EVENT_ENGINE_RESOLVER_TRACE(

data/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);
+    }
   }
 }
 

data/src/core/ext/filters/client_channel/resolver/polling_resolver.h

@@ -69,6 +69,7 @@ class PollingResolver : public Resolver {
   const std::string& name_to_resolve() const { return name_to_resolve_; }
   grpc_pollset_set* interested_parties() const { return interested_parties_; }
   const ChannelArgs& channel_args() const { return channel_args_; }
+  WorkSerializer* work_serializer() { return work_serializer_.get(); }
 
  private:
   void MaybeStartResolvingLocked();

data/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc

@@ -112,6 +112,8 @@ OrphanablePtr<Resolver> CreateSockaddrResolver(
 
 class IPv4ResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "ipv4"; }
+
   bool IsValidUri(const URI& uri) const override {
     return ParseUri(uri, grpc_parse_ipv4, nullptr);
   }
@@ -119,12 +121,12 @@ class IPv4ResolverFactory : public ResolverFactory {
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     return CreateSockaddrResolver(std::move(args), grpc_parse_ipv4);
   }
-
-  absl::string_view scheme() const override { return "ipv4"; }
 };
 
 class IPv6ResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "ipv6"; }
+
   bool IsValidUri(const URI& uri) const override {
     return ParseUri(uri, grpc_parse_ipv6, nullptr);
   }
@@ -132,13 +134,13 @@ class IPv6ResolverFactory : public ResolverFactory {
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     return CreateSockaddrResolver(std::move(args), grpc_parse_ipv6);
   }
-
-  absl::string_view scheme() const override { return "ipv6"; }
 };
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
 class UnixResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "unix"; }
+
   bool IsValidUri(const URI& uri) const override {
     return ParseUri(uri, grpc_parse_unix, nullptr);
   }
@@ -146,12 +148,6 @@ class UnixResolverFactory : public ResolverFactory {
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     return CreateSockaddrResolver(std::move(args), grpc_parse_unix);
   }
-
-  std::string GetDefaultAuthority(const URI& /*uri*/) const override {
-    return "localhost";
-  }
-
-  absl::string_view scheme() const override { return "unix"; }
 };
 
 class UnixAbstractResolverFactory : public ResolverFactory {
@@ -165,12 +161,24 @@ class UnixAbstractResolverFactory : public ResolverFactory {
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     return CreateSockaddrResolver(std::move(args), grpc_parse_unix_abstract);
   }
+};
+#endif  // GRPC_HAVE_UNIX_SOCKET
 
-  std::string GetDefaultAuthority(const URI& /*uri*/) const override {
-    return "localhost";
+#ifdef GRPC_HAVE_VSOCK
+class VSockResolverFactory : public ResolverFactory {
+ public:
+  absl::string_view scheme() const override { return "vsock"; }
+
+  bool IsValidUri(const URI& uri) const override {
+    return ParseUri(uri, grpc_parse_vsock, nullptr);
+  }
+
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    return CreateSockaddrResolver(std::move(args), grpc_parse_vsock);
   }
 };
-#endif  // GRPC_HAVE_UNIX_SOCKET
+
+#endif  // GRPC_HAVE_VSOCK
 
 }  // namespace
 
@@ -185,6 +193,10 @@ void RegisterSockaddrResolver(CoreConfiguration::Builder* builder) {
   builder->resolver_registry()->RegisterResolverFactory(
       std::make_unique<UnixAbstractResolverFactory>());
 #endif
+#ifdef GRPC_HAVE_VSOCK
+  builder->resolver_registry()->RegisterResolverFactory(
+      std::make_unique<VSockResolverFactory>());
+#endif
 }
 
 }  // namespace grpc_core