grpc 1.45.0 → 1.46.3

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -16,24 +16,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <inttypes.h>
-
-#include <climits>
-#include <cstring>
-
 #include "absl/functional/bind_front.h"
 #include "absl/strings/str_cat.h"
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/time.h>
-
 #include "src/core/ext/filters/client_channel/resolver/dns/dns_resolver_selection.h"
+#include "src/core/ext/filters/client_channel/resolver/polling_resolver.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/work_serializer.h"
@@ -49,247 +41,83 @@ namespace grpc_core {
 
 namespace {
 
-class NativeClientChannelDNSResolver : public Resolver {
- public:
-  explicit NativeClientChannelDNSResolver(ResolverArgs args);
-
-  void StartLocked() override;
+TraceFlag grpc_trace_dns_resolver(false, "dns_resolver");
 
-  void RequestReresolutionLocked() override;
-
-  void ResetBackoffLocked() override;
-
-  void ShutdownLocked() override;
-
- private:
+class NativeClientChannelDNSResolver : public PollingResolver {
+ public:
+  NativeClientChannelDNSResolver(ResolverArgs args,
+                                 const grpc_channel_args* channel_args);
   ~NativeClientChannelDNSResolver() override;
 
-  void MaybeStartResolvingLocked();
-  void StartResolvingLocked();
+  OrphanablePtr<Orphanable> StartRequest() override;
 
-  static void OnNextResolution(void* arg, grpc_error_handle error);
-  void OnNextResolutionLocked(grpc_error_handle error);
+ private:
   void OnResolved(
       absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or);
-  void OnResolvedLocked(
-      absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or);
-
-  /// name to resolve
-  std::string name_to_resolve_;
-  /// channel args
-  grpc_channel_args* channel_args_ = nullptr;
-  std::shared_ptr<WorkSerializer> work_serializer_;
-  std::unique_ptr<ResultHandler> result_handler_;
-  /// pollset_set to drive the name resolution process
-  grpc_pollset_set* interested_parties_ = nullptr;
-  /// are we shutting down?
-  bool shutdown_ = false;
-  /// are we currently resolving?
-  bool resolving_ = false;
-  /// next resolution timer
-  bool have_next_resolution_timer_ = false;
-  grpc_timer next_resolution_timer_;
-  grpc_closure on_next_resolution_;
-  /// min time between DNS requests
-  Duration min_time_between_resolutions_;
-  /// timestamp of last DNS request
-  absl::optional<Timestamp> last_resolution_timestamp_;
-  /// retry backoff state
-  BackOff backoff_;
-  /// tracks pending resolutions
-  OrphanablePtr<DNSResolver::Request> dns_request_;
 };
 
 NativeClientChannelDNSResolver::NativeClientChannelDNSResolver(
-    ResolverArgs args)
-    : name_to_resolve_(absl::StripPrefix(args.uri.path(), "/")),
-      channel_args_(grpc_channel_args_copy(args.args)),
-      work_serializer_(std::move(args.work_serializer)),
-      result_handler_(std::move(args.result_handler)),
-      interested_parties_(grpc_pollset_set_create()),
-      min_time_between_resolutions_(
+    ResolverArgs args, const grpc_channel_args* channel_args)
+    : PollingResolver(
+          std::move(args), channel_args,
           Duration::Milliseconds(grpc_channel_args_find_integer(
-              channel_args_, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
-              {1000 * 30, 0, INT_MAX}))),
-      backoff_(BackOff::Options()
-                   .set_initial_backoff(Duration::Seconds(
-                       GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS))
-                   .set_multiplier(GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER)
-                   .set_jitter(GRPC_DNS_RECONNECT_JITTER)
-                   .set_max_backoff(Duration::Seconds(
-                       GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS))) {
-  if (args.pollset_set != nullptr) {
-    grpc_pollset_set_add_pollset_set(interested_parties_, args.pollset_set);
+              channel_args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
+              {1000 * 30, 0, INT_MAX})),
+          BackOff::Options()
+              .set_initial_backoff(Duration::Milliseconds(
+                  GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS * 1000))
+              .set_multiplier(GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER)
+              .set_jitter(GRPC_DNS_RECONNECT_JITTER)
+              .set_max_backoff(Duration::Milliseconds(
+                  GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000)),
+          &grpc_trace_dns_resolver) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
+    gpr_log(GPR_DEBUG, "[dns_resolver=%p] created", this);
   }
 }
 
 NativeClientChannelDNSResolver::~NativeClientChannelDNSResolver() {
-  grpc_channel_args_destroy(channel_args_);
-  grpc_pollset_set_destroy(interested_parties_);
-}
-
-void NativeClientChannelDNSResolver::StartLocked() {
-  MaybeStartResolvingLocked();
-}
-
-void NativeClientChannelDNSResolver::RequestReresolutionLocked() {
-  if (!resolving_) {
-    MaybeStartResolvingLocked();
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
+    gpr_log(GPR_DEBUG, "[dns_resolver=%p] destroyed", this);
   }
 }
 
-void NativeClientChannelDNSResolver::ResetBackoffLocked() {
-  if (have_next_resolution_timer_) {
-    grpc_timer_cancel(&next_resolution_timer_);
-  }
-  backoff_.Reset();
-}
-
-void NativeClientChannelDNSResolver::ShutdownLocked() {
-  shutdown_ = true;
-  if (have_next_resolution_timer_) {
-    grpc_timer_cancel(&next_resolution_timer_);
-  }
-  dns_request_.reset();
-}
-
-void NativeClientChannelDNSResolver::OnNextResolution(void* arg,
-                                                      grpc_error_handle error) {
-  NativeClientChannelDNSResolver* r =
-      static_cast<NativeClientChannelDNSResolver*>(arg);
-  (void)GRPC_ERROR_REF(error);  // ref owned by lambda
-  r->work_serializer_->Run([r, error]() { r->OnNextResolutionLocked(error); },
-                           DEBUG_LOCATION);
-}
-
-void NativeClientChannelDNSResolver::OnNextResolutionLocked(
-    grpc_error_handle error) {
-  have_next_resolution_timer_ = false;
-  if (error == GRPC_ERROR_NONE && !resolving_) {
-    StartResolvingLocked();
+OrphanablePtr<Orphanable> NativeClientChannelDNSResolver::StartRequest() {
+  Ref(DEBUG_LOCATION, "dns_request").release();
+  auto dns_request = GetDNSResolver()->ResolveName(
+      name_to_resolve(), kDefaultSecurePort, interested_parties(),
+      absl::bind_front(&NativeClientChannelDNSResolver::OnResolved, this));
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
+    gpr_log(GPR_DEBUG, "[dns_resolver=%p] starting request=%p", this,
+            dns_request.get());
   }
-  Unref(DEBUG_LOCATION, "retry-timer");
-  GRPC_ERROR_UNREF(error);
+  dns_request->Start();
+  // Explicit type conversion to work around issue with older compilers.
+  return OrphanablePtr<Orphanable>(dns_request.release());
 }
 
 void NativeClientChannelDNSResolver::OnResolved(
     absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
-  work_serializer_->Run(
-      [this, addresses_or]() mutable {
-        OnResolvedLocked(std::move(addresses_or));
-      },
-      DEBUG_LOCATION);
-}
-
-void NativeClientChannelDNSResolver::OnResolvedLocked(
-    absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
-  GPR_ASSERT(resolving_);
-  resolving_ = false;
-  dns_request_.reset();
-  if (shutdown_) {
-    Unref(DEBUG_LOCATION, "dns-resolving");
-    return;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
+    gpr_log(GPR_DEBUG, "[dns_resolver=%p] request complete, status=\"%s\"",
+            this, addresses_or.status().ToString().c_str());
   }
+  // Convert result from iomgr DNS API into Resolver::Result.
+  Result result;
   if (addresses_or.ok()) {
     ServerAddressList addresses;
     for (auto& addr : *addresses_or) {
       addresses.emplace_back(addr, nullptr /* args */);
     }
-    Result result;
     result.addresses = std::move(addresses);
-    result.args = grpc_channel_args_copy(channel_args_);
-    result_handler_->ReportResult(std::move(result));
-    // Reset backoff state so that we start from the beginning when the
-    // next request gets triggered.
-    backoff_.Reset();
   } else {
-    std::string error_message = addresses_or.status().ToString();
-    gpr_log(GPR_INFO, "dns resolution failed (will retry): %s",
-            error_message.c_str());
-    // Return transient error.
-    Result result;
-    result.addresses = absl::UnavailableError(absl::StrCat(
-        "DNS resolution failed for ", name_to_resolve_, ": ", error_message));
-    result.args = grpc_channel_args_copy(channel_args_);
-    result_handler_->ReportResult(std::move(result));
-    // 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;
-    // TODO(roth): We currently deal with this ref manually.  Once the
-    // new closure API is done, find a way to track this ref with the timer
-    // callback as part of the type system.
-    Ref(DEBUG_LOCATION, "next_resolution_timer").release();
-    if (timeout > Duration::Zero()) {
-      gpr_log(GPR_DEBUG, "retrying in %" PRId64 " milliseconds",
-              timeout.millis());
-    } else {
-      gpr_log(GPR_DEBUG, "retrying immediately");
-    }
-    GRPC_CLOSURE_INIT(&on_next_resolution_,
-                      NativeClientChannelDNSResolver::OnNextResolution, this,
-                      grpc_schedule_on_exec_ctx);
-    grpc_timer_init(&next_resolution_timer_, next_try, &on_next_resolution_);
+    result.addresses = absl::UnavailableError(
+        absl::StrCat("DNS resolution failed for ", name_to_resolve(), ": ",
+                     addresses_or.status().ToString()));
   }
-  Unref(DEBUG_LOCATION, "dns-resolving");
-}
-
-void NativeClientChannelDNSResolver::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 (last_resolution_timestamp_.has_value()) {
-    // 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 earliest_next_resolution =
-        *last_resolution_timestamp_ + min_time_between_resolutions_;
-    const Duration time_until_next_resolution =
-        earliest_next_resolution - ExecCtx::Get()->Now();
-    if (time_until_next_resolution > Duration::Zero()) {
-      const Duration last_resolution_ago =
-          ExecCtx::Get()->Now() - *last_resolution_timestamp_;
-      gpr_log(GPR_DEBUG,
-              "In cooldown from last resolution (from %" PRId64
-              " ms ago). Will resolve again in %" PRId64 " ms",
-              last_resolution_ago.millis(),
-              time_until_next_resolution.millis());
-      have_next_resolution_timer_ = true;
-      // TODO(roth): We currently deal with this ref manually.  Once the
-      // new closure API is done, find a way to track this ref with the timer
-      // callback as part of the type system.
-      Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown").release();
-      GRPC_CLOSURE_INIT(&on_next_resolution_,
-                        NativeClientChannelDNSResolver::OnNextResolution, this,
-                        grpc_schedule_on_exec_ctx);
-      grpc_timer_init(&next_resolution_timer_,
-                      ExecCtx::Get()->Now() + time_until_next_resolution,
-                      &on_next_resolution_);
-      return;
-    }
-  }
-  StartResolvingLocked();
-}
-
-void NativeClientChannelDNSResolver::StartResolvingLocked() {
-  gpr_log(GPR_DEBUG, "Start resolving.");
-  // TODO(roth): We currently deal with this ref manually.  Once the
-  // new closure API is done, find a way to track this ref with the timer
-  // callback as part of the type system.
-  Ref(DEBUG_LOCATION, "dns-resolving").release();
-  GPR_ASSERT(!resolving_);
-  resolving_ = true;
-  dns_request_ = GetDNSResolver()->ResolveName(
-      name_to_resolve_, kDefaultSecurePort, interested_parties_,
-      absl::bind_front(&NativeClientChannelDNSResolver::OnResolved, this));
-  dns_request_->Start();
-  last_resolution_timestamp_ = ExecCtx::Get()->Now();
+  result.args = grpc_channel_args_copy(channel_args());
+  OnRequestComplete(std::move(result));
+  Unref(DEBUG_LOCATION, "dns_request");
 }
 
 //
@@ -314,7 +142,9 @@ class NativeClientChannelDNSResolverFactory : public ResolverFactory {
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     if (!IsValidUri(args.uri)) return nullptr;
-    return MakeOrphanable<NativeClientChannelDNSResolver>(std::move(args));
+    const grpc_channel_args* channel_args = args.args;
+    return MakeOrphanable<NativeClientChannelDNSResolver>(std::move(args),
+                                                          channel_args);
   }
 };
 

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

@@ -0,0 +1,201 @@
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/resolver/polling_resolver.h"
+
+#include "absl/strings/strip.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"
+
+namespace grpc_core {
+
+PollingResolver::PollingResolver(ResolverArgs args,
+                                 const grpc_channel_args* 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)),
+      work_serializer_(std::move(args.work_serializer)),
+      result_handler_(std::move(args.result_handler)),
+      tracer_(tracer),
+      interested_parties_(args.pollset_set),
+      min_time_between_resolutions_(min_time_between_resolutions),
+      backoff_(backoff_options) {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] created", this);
+  }
+}
+
+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();
+  }
+}
+
+void PollingResolver::ResetBackoffLocked() {
+  if (have_next_resolution_timer_) {
+    grpc_timer_cancel(&next_resolution_timer_);
+  }
+  backoff_.Reset();
+}
+
+void PollingResolver::ShutdownLocked() {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] shutting down", this);
+  }
+  shutdown_ = true;
+  if (have_next_resolution_timer_) {
+    grpc_timer_cancel(&next_resolution_timer_);
+  }
+  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::OnNextResolutionLocked(grpc_error_handle error) {
+  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_);
+  }
+  have_next_resolution_timer_ = false;
+  if (error == GRPC_ERROR_NONE && !shutdown_) {
+    StartResolvingLocked();
+  }
+  Unref(DEBUG_LOCATION, "retry-timer");
+  GRPC_ERROR_UNREF(error);
+}
+
+void PollingResolver::OnRequestComplete(Result result) {
+  Ref(DEBUG_LOCATION, "OnRequestComplete").release();
+  work_serializer_->Run(
+      [this, result]() mutable { OnRequestCompleteLocked(std::move(result)); },
+      DEBUG_LOCATION);
+}
+
+void PollingResolver::OnRequestCompleteLocked(Result result) {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] request complete", this);
+  }
+  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_);
+    }
+    result_handler_->ReportResult(std::move(result));
+  }
+  Unref(DEBUG_LOCATION, "OnRequestComplete");
+}
+
+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 (last_resolution_timestamp_.has_value()) {
+    // 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 earliest_next_resolution =
+        *last_resolution_timestamp_ + min_time_between_resolutions_;
+    const Duration time_until_next_resolution =
+        earliest_next_resolution - ExecCtx::Get()->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_;
+        gpr_log(GPR_INFO,
+                "[polling resolver %p] in cooldown from last resolution "
+                "(from %" PRId64 " ms ago); will resolve again in %" PRId64
+                " ms",
+                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_);
+      return;
+    }
+  }
+  StartResolvingLocked();
+}
+
+void PollingResolver::StartResolvingLocked() {
+  request_ = StartRequest();
+  last_resolution_timestamp_ = ExecCtx::Get()->Now();
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] starting resolution, request_=%p",
+            this, request_.get());
+  }
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,106 @@
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_POLLING_RESOLVER_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_POLLING_RESOLVER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/types/optional.h"
+
+#include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/resolver/resolver.h"
+#include "src/core/lib/resolver/resolver_factory.h"
+
+namespace grpc_core {
+
+// A base class for polling-based resolvers.
+// Handles cooldown and backoff timers.
+// Implementations need only to implement StartRequest().
+class PollingResolver : public Resolver {
+ public:
+  PollingResolver(ResolverArgs args, const grpc_channel_args* channel_args,
+                  Duration min_time_between_resolutions,
+                  BackOff::Options backoff_options, TraceFlag* tracer);
+  ~PollingResolver() override;
+
+  void StartLocked() override;
+  void RequestReresolutionLocked() override;
+  void ResetBackoffLocked() override;
+  void ShutdownLocked() override;
+
+ protected:
+  // Implemented by subclass.
+  // Starts a request, returning an object representing the pending
+  // request.  Orphaning that object should cancel the request.
+  // When the request is complete, the implementation must call
+  // OnRequestComplete() with the result.
+  virtual OrphanablePtr<Orphanable> StartRequest() = 0;
+
+  // To be invoked by the subclass when a request is complete.
+  void OnRequestComplete(Result result);
+
+  // Convenient accessor methods for subclasses.
+  const std::string& authority() const { return authority_; }
+  const std::string& name_to_resolve() const { return name_to_resolve_; }
+  grpc_pollset_set* interested_parties() const { return interested_parties_; }
+  const grpc_channel_args* channel_args() const { return channel_args_; }
+
+ private:
+  void MaybeStartResolvingLocked();
+  void StartResolvingLocked();
+
+  void OnRequestCompleteLocked(Result result);
+
+  static void OnNextResolution(void* arg, grpc_error_handle error);
+  void OnNextResolutionLocked(grpc_error_handle error);
+
+  /// authority
+  std::string authority_;
+  /// name to resolve
+  std::string name_to_resolve_;
+  /// channel args
+  const grpc_channel_args* channel_args_ = nullptr;
+  std::shared_ptr<WorkSerializer> work_serializer_;
+  std::unique_ptr<ResultHandler> result_handler_;
+  TraceFlag* tracer_;
+  /// pollset_set to drive the name resolution process
+  grpc_pollset_set* interested_parties_ = nullptr;
+  /// are we shutting down?
+  bool shutdown_ = false;
+  /// are we currently resolving?
+  OrphanablePtr<Orphanable> request_;
+  /// next resolution timer
+  bool have_next_resolution_timer_ = false;
+  grpc_timer next_resolution_timer_;
+  grpc_closure on_next_resolution_;
+  /// min time between DNS requests
+  Duration min_time_between_resolutions_;
+  /// timestamp of last DNS request
+  absl::optional<Timestamp> last_resolution_timestamp_;
+  /// retry backoff state
+  BackOff backoff_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_POLLING_RESOLVER_H