grpc 1.46.3 → 1.53.1

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h

@@ -14,15 +14,20 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_args.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/grpc.h>
+
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/resolver/resolver.h"
 
 #define GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR \
@@ -79,6 +84,15 @@ class FakeResolverResponseGenerator
   static RefCountedPtr<FakeResolverResponseGenerator> GetFromArgs(
       const grpc_channel_args* args);
 
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR;
+  }
+
+  static int ChannelArgsCompare(const FakeResolverResponseGenerator* a,
+                                const FakeResolverResponseGenerator* b) {
+    return QsortCompare(a, b);
+  }
+
  private:
   friend class FakeResolver;
   // Set the corresponding FakeResolver to this generator.
@@ -93,4 +107,4 @@ class FakeResolverResponseGenerator
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -16,21 +16,58 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <random>
+#include <string.h>
 
-#include "src/core/ext/xds/xds_client.h"
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
+#include <cstdint>
+#include <initializer_list>
+#include <memory>
+#include <random>
+#include <string>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
+#include "absl/types/optional.h"
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/log.h>
+
+#include "src/core/ext/xds/xds_bootstrap.h"
+#include "src/core/ext/xds/xds_client_grpc.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/env.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/http/httpcli.h"
+#include "src/core/lib/http/parser.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/json/json.h"
+#include "src/core/lib/resolver/resolver.h"
+#include "src/core/lib/resolver/resolver_factory.h"
 #include "src/core/lib/resolver/resolver_registry.h"
-#include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 
 namespace {
 
+const char* kC2PAuthority = "traffic-director-c2p.xds.googleapis.com";
+
 class GoogleCloud2ProdResolver : public Resolver {
  public:
   explicit GoogleCloud2ProdResolver(ResolverArgs args);
@@ -53,7 +90,7 @@ class GoogleCloud2ProdResolver : public Resolver {
    private:
     static void OnHttpRequestDone(void* arg, grpc_error_handle error);
 
-    // If error is not GRPC_ERROR_NONE, then it's not safe to look at response.
+    // If error is not absl::OkStatus(), then it's not safe to look at response.
     virtual void OnDone(GoogleCloud2ProdResolver* resolver,
                         const grpc_http_response* response,
                         grpc_error_handle error) = 0;
@@ -131,12 +168,12 @@ GoogleCloud2ProdResolver::MetadataQuery::MetadataQuery(
       const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA),
       resolver_->resource_quota_.get(), grpc_resource_quota_arg_vtable());
   grpc_channel_args args = {1, &resource_quota_arg};
-  http_request_ = HttpRequest::Get(
-      std::move(*uri), &args, pollent, &request,
-      ExecCtx::Get()->Now() + Duration::Seconds(10),  // 10s timeout
-      &on_done_, &response_,
-      RefCountedPtr<grpc_channel_credentials>(
-          grpc_insecure_credentials_create()));
+  http_request_ =
+      HttpRequest::Get(std::move(*uri), &args, pollent, &request,
+                       Timestamp::Now() + Duration::Seconds(10),  // 10s timeout
+                       &on_done_, &response_,
+                       RefCountedPtr<grpc_channel_credentials>(
+                           grpc_insecure_credentials_create()));
   http_request_->Start();
 }
 
@@ -154,7 +191,6 @@ void GoogleCloud2ProdResolver::MetadataQuery::OnHttpRequestDone(
   auto* self = static_cast<MetadataQuery*>(arg);
   // Hop back into WorkSerializer to call OnDone().
   // Note: We implicitly pass our ref to the callback here.
-  (void)GRPC_ERROR_REF(error);
   self->resolver_->work_serializer_->Run(
       [self, error]() {
         self->OnDone(self->resolver_.get(), &self->response_, error);
@@ -177,10 +213,9 @@ void GoogleCloud2ProdResolver::ZoneQuery::OnDone(
     GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
     grpc_error_handle error) {
   absl::StatusOr<std::string> zone;
-  if (error != GRPC_ERROR_NONE) {
-    zone = absl::UnknownError(
-        absl::StrCat("error fetching zone from metadata server: ",
-                     grpc_error_std_string(error)));
+  if (!error.ok()) {
+    zone = absl::UnknownError(absl::StrCat(
+        "error fetching zone from metadata server: ", StatusToString(error)));
   } else if (response->status != 200) {
     zone = absl::UnknownError(absl::StrFormat(
         "zone query received non-200 status: %d", response->status));
@@ -201,7 +236,6 @@ void GoogleCloud2ProdResolver::ZoneQuery::OnDone(
   } else {
     resolver->ZoneQueryDone(std::move(*zone));
   }
-  GRPC_ERROR_UNREF(error);
 }
 
 //
@@ -218,58 +252,67 @@ GoogleCloud2ProdResolver::IPv6Query::IPv6Query(
 void GoogleCloud2ProdResolver::IPv6Query::OnDone(
     GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
     grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!error.ok()) {
     gpr_log(GPR_ERROR, "error fetching IPv6 address from metadata server: %s",
-            grpc_error_std_string(error).c_str());
+            StatusToString(error).c_str());
   }
-  resolver->IPv6QueryDone(error == GRPC_ERROR_NONE && response->status == 200);
-  GRPC_ERROR_UNREF(error);
+  resolver->IPv6QueryDone(error.ok() && response->status == 200);
 }
 
 //
 // GoogleCloud2ProdResolver
 //
 
+bool XdsBootstrapConfigured() {
+  return GetEnv("GRPC_XDS_BOOTSTRAP").has_value() ||
+         GetEnv("GRPC_XDS_BOOTSTRAP_CONFIG").has_value();
+}
+
 GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
-    : resource_quota_(ResourceQuotaFromChannelArgs(args.args)),
+    : resource_quota_(args.args.GetObjectRef<ResourceQuota>()),
       work_serializer_(std::move(args.work_serializer)),
       pollent_(grpc_polling_entity_create_from_pollset_set(args.pollset_set)) {
   absl::string_view name_to_resolve = absl::StripPrefix(args.uri.path(), "/");
   // If we're not running on GCP, we can't use DirectPath, so delegate
   // to the DNS resolver.
-  bool test_only_pretend_running_on_gcp = grpc_channel_args_find_bool(
-      args.args, "grpc.testing.google_c2p_resolver_pretend_running_on_gcp",
-      false);
-  bool running_on_gcp =
+  const bool test_only_pretend_running_on_gcp =
+      args.args
+          .GetBool("grpc.testing.google_c2p_resolver_pretend_running_on_gcp")
+          .value_or(false);
+  const bool running_on_gcp =
       test_only_pretend_running_on_gcp || grpc_alts_is_running_on_gcp();
+  const bool federation_enabled = XdsFederationEnabled();
   if (!running_on_gcp ||
-      // If the client is already using xDS, we can't use it here, because
-      // they may be talking to a completely different xDS server than we
-      // want to.
-      // TODO(roth): When we implement xDS federation, remove this constraint.
-      UniquePtr<char>(gpr_getenv("GRPC_XDS_BOOTSTRAP")) != nullptr ||
-      UniquePtr<char>(gpr_getenv("GRPC_XDS_BOOTSTRAP_CONFIG")) != nullptr) {
+      // If the client is already using xDS and federation is not enabled,
+      // we can't use it here, because they may be talking to a completely
+      // different xDS server than we want to.
+      // TODO(roth): When we remove xDS federation env var protection,
+      // remove this constraint.
+      (!federation_enabled && XdsBootstrapConfigured())) {
     using_dns_ = true;
     child_resolver_ =
         CoreConfiguration::Get().resolver_registry().CreateResolver(
-            absl::StrCat("dns:", name_to_resolve).c_str(), args.args,
-            args.pollset_set, work_serializer_, std::move(args.result_handler));
+            absl::StrCat("dns:", name_to_resolve), args.args, args.pollset_set,
+            work_serializer_, std::move(args.result_handler));
     GPR_ASSERT(child_resolver_ != nullptr);
     return;
   }
   // Maybe override metadata server name for testing
-  const char* test_only_metadata_server_override =
-      grpc_channel_args_find_string(
-          args.args,
+  absl::optional<std::string> test_only_metadata_server_override =
+      args.args.GetOwnedString(
           "grpc.testing.google_c2p_resolver_metadata_server_override");
-  if (test_only_metadata_server_override != nullptr &&
-      strlen(test_only_metadata_server_override) > 0) {
-    metadata_server_name_ = std::string(test_only_metadata_server_override);
+  if (test_only_metadata_server_override.has_value() &&
+      !test_only_metadata_server_override->empty()) {
+    metadata_server_name_ = std::move(*test_only_metadata_server_override);
   }
   // Create xds resolver.
+  std::string xds_uri =
+      federation_enabled
+          ? absl::StrCat("xds://", kC2PAuthority, "/", name_to_resolve)
+          : absl::StrCat("xds:", name_to_resolve);
   child_resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(
-      absl::StrCat("xds:", name_to_resolve).c_str(), args.args,
-      args.pollset_set, work_serializer_, std::move(args.result_handler));
+      xds_uri, args.args, args.pollset_set, work_serializer_,
+      std::move(args.result_handler));
   GPR_ASSERT(child_resolver_ != nullptr);
 }
 
@@ -336,25 +379,32 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
     };
   }
   // Allow the TD server uri to be overridden for testing purposes.
-  UniquePtr<char> override_server(
-      gpr_getenv("GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI"));
+  auto override_server =
+      GetEnv("GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI");
   const char* server_uri =
-      override_server != nullptr && strlen(override_server.get()) > 0
-          ? override_server.get()
+      override_server.has_value() && !override_server->empty()
+          ? override_server->c_str()
           : "directpath-pa.googleapis.com";
+  Json xds_server = Json::Array{
+      Json::Object{
+          {"server_uri", server_uri},
+          {"channel_creds",
+           Json::Array{
+               Json::Object{
+                   {"type", "google_default"},
+               },
+           }},
+          {"server_features", Json::Array{"xds_v3"}},
+      },
+  };
   Json bootstrap = Json::Object{
-      {"xds_servers",
-       Json::Array{
-           Json::Object{
-               {"server_uri", server_uri},
-               {"channel_creds",
-                Json::Array{
-                    Json::Object{
-                        {"type", "google_default"},
-                    },
-                }},
-               {"server_features", Json::Array{"xds_v3"}},
-           },
+      {"xds_servers", xds_server},
+      {"authorities",
+       Json::Object{
+           {kC2PAuthority,
+            Json::Object{
+                {"xds_servers", std::move(xds_server)},
+            }},
        }},
       {"node", std::move(node)},
   };
@@ -370,15 +420,35 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
 
 class GoogleCloud2ProdResolverFactory : public ResolverFactory {
  public:
-  // TODO(roth): Remove experimental suffix once this code is proven stable,
-  // and update the scheme in google_c2p_resolver_test.cc when doing so.
+  absl::string_view scheme() const override { return "google-c2p"; }
+
+  bool IsValidUri(const URI& uri) const override {
+    if (GPR_UNLIKELY(!uri.authority().empty())) {
+      gpr_log(GPR_ERROR, "google-c2p URI scheme does not support authorities");
+      return false;
+    }
+    return true;
+  }
+
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    if (!IsValidUri(args.uri)) return nullptr;
+    return MakeOrphanable<GoogleCloud2ProdResolver>(std::move(args));
+  }
+};
+
+// TODO(apolcyn): remove this class after user code has updated to the
+// stable "google-c2p" URI scheme.
+class ExperimentalGoogleCloud2ProdResolverFactory : public ResolverFactory {
+ public:
   absl::string_view scheme() const override {
     return "google-c2p-experimental";
   }
 
   bool IsValidUri(const URI& uri) const override {
     if (GPR_UNLIKELY(!uri.authority().empty())) {
-      gpr_log(GPR_ERROR, "google-c2p URI scheme does not support authorities");
+      gpr_log(
+          GPR_ERROR,
+          "google-c2p-experimental URI scheme does not support authorities");
       return false;
     }
     return true;
@@ -394,7 +464,9 @@ class GoogleCloud2ProdResolverFactory : public ResolverFactory {
 
 void RegisterCloud2ProdResolver(CoreConfiguration::Builder* builder) {
   builder->resolver_registry()->RegisterResolverFactory(
-      absl::make_unique<GoogleCloud2ProdResolverFactory>());
+      std::make_unique<GoogleCloud2ProdResolverFactory>());
+  builder->resolver_registry()->RegisterResolverFactory(
+      std::make_unique<ExperimentalGoogleCloud2ProdResolverFactory>());
 }
 
 }  // namespace grpc_core

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

@@ -18,24 +18,42 @@
 
 #include "src/core/ext/filters/client_channel/resolver/polling_resolver.h"
 
+#include <inttypes.h>
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/work_serializer.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/service_config/service_config.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 
+using ::grpc_event_engine::experimental::EventEngine;
+
 PollingResolver::PollingResolver(ResolverArgs args,
-                                 const grpc_channel_args* channel_args,
+                                 const ChannelArgs& channel_args,
                                  Duration min_time_between_resolutions,
                                  BackOff::Options backoff_options,
                                  TraceFlag* tracer)
     : authority_(args.uri.authority()),
       name_to_resolve_(absl::StripPrefix(args.uri.path(), "/")),
-      channel_args_(grpc_channel_args_copy(channel_args)),
+      channel_args_(channel_args),
       work_serializer_(std::move(args.work_serializer)),
       result_handler_(std::move(args.result_handler)),
       tracer_(tracer),
@@ -51,22 +69,31 @@ PollingResolver::~PollingResolver() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
     gpr_log(GPR_INFO, "[polling resolver %p] destroying", this);
   }
-  grpc_channel_args_destroy(channel_args_);
 }
 
 void PollingResolver::StartLocked() { MaybeStartResolvingLocked(); }
 
 void PollingResolver::RequestReresolutionLocked() {
   if (request_ == nullptr) {
-    MaybeStartResolvingLocked();
+    // If we're still waiting for a result-health callback from the last
+    // result we reported, don't trigger the re-resolution until we get
+    // that callback.
+    if (result_status_state_ ==
+        ResultStatusState::kResultHealthCallbackPending) {
+      result_status_state_ =
+          ResultStatusState::kReresolutionRequestedWhileCallbackWasPending;
+    } else {
+      MaybeStartResolvingLocked();
+    }
   }
 }
 
 void PollingResolver::ResetBackoffLocked() {
-  if (have_next_resolution_timer_) {
-    grpc_timer_cancel(&next_resolution_timer_);
-  }
   backoff_.Reset();
+  if (next_resolution_timer_handle_.has_value()) {
+    MaybeCancelNextResolutionTimer();
+    StartResolvingLocked();
+  }
 }
 
 void PollingResolver::ShutdownLocked() {
@@ -74,32 +101,47 @@ void PollingResolver::ShutdownLocked() {
     gpr_log(GPR_INFO, "[polling resolver %p] shutting down", this);
   }
   shutdown_ = true;
-  if (have_next_resolution_timer_) {
-    grpc_timer_cancel(&next_resolution_timer_);
-  }
+  MaybeCancelNextResolutionTimer();
   request_.reset();
 }
 
-void PollingResolver::OnNextResolution(void* arg, grpc_error_handle error) {
-  auto* self = static_cast<PollingResolver*>(arg);
-  (void)GRPC_ERROR_REF(error);  // ref owned by lambda
-  self->work_serializer_->Run(
-      [self, error]() { self->OnNextResolutionLocked(error); }, DEBUG_LOCATION);
+void PollingResolver::ScheduleNextResolutionTimer(const Duration& timeout) {
+  RefCountedPtr<PollingResolver> self = Ref();
+  next_resolution_timer_handle_ =
+      channel_args_.GetObject<EventEngine>()->RunAfter(
+          timeout, [self = std::move(self)]() mutable {
+            ApplicationCallbackExecCtx callback_exec_ctx;
+            ExecCtx exec_ctx;
+            auto* self_ptr = self.get();
+            self_ptr->work_serializer_->Run(
+                [self = std::move(self)]() { self->OnNextResolutionLocked(); },
+                DEBUG_LOCATION);
+          });
 }
 
-void PollingResolver::OnNextResolutionLocked(grpc_error_handle error) {
+void PollingResolver::OnNextResolutionLocked() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
     gpr_log(GPR_INFO,
-            "[polling resolver %p] re-resolution timer fired: error=\"%s\", "
-            "shutdown_=%d",
-            this, grpc_error_std_string(error).c_str(), shutdown_);
+            "[polling resolver %p] re-resolution timer fired: shutdown_=%d",
+            this, shutdown_);
   }
-  have_next_resolution_timer_ = false;
-  if (error == GRPC_ERROR_NONE && !shutdown_) {
+  // If we haven't been cancelled nor shutdown, then start resolving.
+  if (next_resolution_timer_handle_.has_value() && !shutdown_) {
+    next_resolution_timer_handle_.reset();
     StartResolvingLocked();
   }
-  Unref(DEBUG_LOCATION, "retry-timer");
-  GRPC_ERROR_UNREF(error);
+}
+
+void PollingResolver::MaybeCancelNextResolutionTimer() {
+  if (next_resolution_timer_handle_.has_value()) {
+    if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+      gpr_log(GPR_INFO, "[polling resolver %p] cancel re-resolution timer",
+              this);
+    }
+    channel_args_.GetObject<EventEngine>()->Cancel(
+        *next_resolution_timer_handle_);
+    next_resolution_timer_handle_.reset();
+  }
 }
 
 void PollingResolver::OnRequestComplete(Result result) {
@@ -115,48 +157,79 @@ void PollingResolver::OnRequestCompleteLocked(Result result) {
   }
   request_.reset();
   if (!shutdown_) {
-    if (result.service_config.ok() && result.addresses.ok()) {
-      // Reset backoff state so that we start from the beginning when the
-      // next request gets triggered.
-      backoff_.Reset();
-    } else {
-      if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-        gpr_log(GPR_INFO,
-                "[polling resolver %p] resolution failed (will retry): "
-                "address status \"%s\"; service config status \"%s\"",
-                this, result.addresses.status().ToString().c_str(),
-                result.service_config.status().ToString().c_str());
-      }
-      // Set up for retry.
-      // InvalidateNow to avoid getting stuck re-initializing this timer
-      // in a loop while draining the currently-held WorkSerializer.
-      // Also see https://github.com/grpc/grpc/issues/26079.
-      ExecCtx::Get()->InvalidateNow();
-      Timestamp next_try = backoff_.NextAttemptTime();
-      Duration timeout = next_try - ExecCtx::Get()->Now();
-      GPR_ASSERT(!have_next_resolution_timer_);
-      have_next_resolution_timer_ = true;
-      if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-        if (timeout > Duration::Zero()) {
-          gpr_log(GPR_INFO, "[polling resolver %p] retrying in %" PRId64 " ms",
-                  this, timeout.millis());
-        } else {
-          gpr_log(GPR_INFO, "[polling resolver %p] retrying immediately", this);
-        }
-      }
-      Ref(DEBUG_LOCATION, "next_resolution_timer").release();
-      GRPC_CLOSURE_INIT(&on_next_resolution_, OnNextResolution, this, nullptr);
-      grpc_timer_init(&next_resolution_timer_, next_try, &on_next_resolution_);
+    if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+      gpr_log(GPR_INFO,
+              "[polling resolver %p] returning result: "
+              "addresses=%s, service_config=%s",
+              this,
+              result.addresses.ok()
+                  ? absl::StrCat("<", result.addresses->size(), " addresses>")
+                        .c_str()
+                  : result.addresses.status().ToString().c_str(),
+              result.service_config.ok()
+                  ? (*result.service_config == nullptr
+                         ? "<null>"
+                         : std::string((*result.service_config)->json_string())
+                               .c_str())
+                  : result.service_config.status().ToString().c_str());
     }
+    GPR_ASSERT(result.result_health_callback == nullptr);
+    RefCountedPtr<PollingResolver> self =
+        Ref(DEBUG_LOCATION, "result_health_callback");
+    result.result_health_callback = [self =
+                                         std::move(self)](absl::Status status) {
+      self->GetResultStatus(std::move(status));
+    };
+    result_status_state_ = ResultStatusState::kResultHealthCallbackPending;
     result_handler_->ReportResult(std::move(result));
   }
   Unref(DEBUG_LOCATION, "OnRequestComplete");
 }
 
+void PollingResolver::GetResultStatus(absl::Status status) {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] result status from channel: %s",
+            this, status.ToString().c_str());
+  }
+  if (status.ok()) {
+    // Reset backoff state so that we start from the beginning when the
+    // next request gets triggered.
+    backoff_.Reset();
+    // If a re-resolution attempt was requested while the result-status
+    // callback was pending, trigger a new request now.
+    if (std::exchange(result_status_state_, ResultStatusState::kNone) ==
+        ResultStatusState::kReresolutionRequestedWhileCallbackWasPending) {
+      MaybeStartResolvingLocked();
+    }
+  } else {
+    // Set up for retry.
+    // InvalidateNow to avoid getting stuck re-initializing this timer
+    // in a loop while draining the currently-held WorkSerializer.
+    // Also see https://github.com/grpc/grpc/issues/26079.
+    ExecCtx::Get()->InvalidateNow();
+    const Timestamp next_try = backoff_.NextAttemptTime();
+    const Duration timeout = next_try - Timestamp::Now();
+    GPR_ASSERT(!next_resolution_timer_handle_.has_value());
+    if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+      if (timeout > Duration::Zero()) {
+        gpr_log(GPR_INFO, "[polling resolver %p] retrying in %" PRId64 " ms",
+                this, timeout.millis());
+      } else {
+        gpr_log(GPR_INFO, "[polling resolver %p] retrying immediately", this);
+      }
+    }
+    ScheduleNextResolutionTimer(timeout);
+    // Reset result_status_state_.  Note that even if re-resolution was
+    // requested while the result-health callback was pending, we can
+    // ignore it here, because we are in backoff to re-resolve anyway.
+    result_status_state_ = ResultStatusState::kNone;
+  }
+}
+
 void PollingResolver::MaybeStartResolvingLocked() {
   // If there is an existing timer, the time it fires is the earliest time we
   // can start the next resolution.
-  if (have_next_resolution_timer_) return;
+  if (next_resolution_timer_handle_.has_value()) return;
   if (last_resolution_timestamp_.has_value()) {
     // InvalidateNow to avoid getting stuck re-initializing this timer
     // in a loop while draining the currently-held WorkSerializer.
@@ -165,11 +238,11 @@ void PollingResolver::MaybeStartResolvingLocked() {
     const Timestamp earliest_next_resolution =
         *last_resolution_timestamp_ + min_time_between_resolutions_;
     const Duration time_until_next_resolution =
-        earliest_next_resolution - ExecCtx::Get()->Now();
+        earliest_next_resolution - Timestamp::Now();
     if (time_until_next_resolution > Duration::Zero()) {
       if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
         const Duration last_resolution_ago =
-            ExecCtx::Get()->Now() - *last_resolution_timestamp_;
+            Timestamp::Now() - *last_resolution_timestamp_;
         gpr_log(GPR_INFO,
                 "[polling resolver %p] in cooldown from last resolution "
                 "(from %" PRId64 " ms ago); will resolve again in %" PRId64
@@ -177,12 +250,7 @@ void PollingResolver::MaybeStartResolvingLocked() {
                 this, last_resolution_ago.millis(),
                 time_until_next_resolution.millis());
       }
-      have_next_resolution_timer_ = true;
-      Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown").release();
-      GRPC_CLOSURE_INIT(&on_next_resolution_, OnNextResolution, this, nullptr);
-      grpc_timer_init(&next_resolution_timer_,
-                      ExecCtx::Get()->Now() + time_until_next_resolution,
-                      &on_next_resolution_);
+      ScheduleNextResolutionTimer(time_until_next_resolution);
       return;
     }
   }
@@ -191,7 +259,7 @@ void PollingResolver::MaybeStartResolvingLocked() {
 
 void PollingResolver::StartResolvingLocked() {
   request_ = StartRequest();
-  last_resolution_timestamp_ = ExecCtx::Get()->Now();
+  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());