grpc 1.50.0 → 1.52.0.pre2

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

@@ -21,6 +21,7 @@
 #include <inttypes.h>
 
 #include <functional>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -38,12 +39,13 @@
 #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/iomgr/timer.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 ChannelArgs& channel_args,
                                  Duration min_time_between_resolutions,
@@ -87,10 +89,11 @@ void PollingResolver::RequestReresolutionLocked() {
 }
 
 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() {
@@ -98,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 (GRPC_ERROR_IS_NONE(error) && !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) {
@@ -189,10 +207,9 @@ void PollingResolver::GetResultStatus(absl::Status status) {
     // 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 - Timestamp::Now();
-    GPR_ASSERT(!have_next_resolution_timer_);
-    have_next_resolution_timer_ = true;
+    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",
@@ -201,9 +218,7 @@ void PollingResolver::GetResultStatus(absl::Status status) {
         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_);
+    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.
@@ -214,7 +229,7 @@ void PollingResolver::GetResultStatus(absl::Status status) {
 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.
@@ -235,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_,
-                      Timestamp::Now() + time_until_next_resolution,
-                      &on_next_resolution_);
+      ScheduleNextResolutionTimer(time_until_next_resolution);
       return;
     }
   }

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

@@ -25,16 +25,15 @@
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
+#include <grpc/event_engine/event_engine.h>
+
 #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/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
 
@@ -77,11 +76,11 @@ class PollingResolver : public Resolver {
   void StartResolvingLocked();
 
   void OnRequestCompleteLocked(Result result);
-
   void GetResultStatus(absl::Status status);
 
-  static void OnNextResolution(void* arg, grpc_error_handle error);
-  void OnNextResolutionLocked(grpc_error_handle error);
+  void ScheduleNextResolutionTimer(const Duration& timeout);
+  void OnNextResolutionLocked();
+  void MaybeCancelNextResolutionTimer();
 
   /// authority
   std::string authority_;
@@ -98,10 +97,6 @@ class PollingResolver : public Resolver {
   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
@@ -116,6 +111,9 @@ class PollingResolver : public Resolver {
     kReresolutionRequestedWhileCallbackWasPending,
   };
   ResultStatusState result_status_state_ = ResultStatusState::kNone;
+  /// next resolution timer
+  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      next_resolution_timer_handle_;
 };
 
 }  // namespace grpc_core

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

@@ -20,9 +20,7 @@
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
-#include "absl/memory/memory.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
@@ -37,7 +35,6 @@
 #include "src/core/lib/iomgr/resolved_address.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/resolver/server_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
@@ -179,14 +176,14 @@ class UnixAbstractResolverFactory : public ResolverFactory {
 
 void RegisterSockaddrResolver(CoreConfiguration::Builder* builder) {
   builder->resolver_registry()->RegisterResolverFactory(
-      absl::make_unique<IPv4ResolverFactory>());
+      std::make_unique<IPv4ResolverFactory>());
   builder->resolver_registry()->RegisterResolverFactory(
-      absl::make_unique<IPv6ResolverFactory>());
+      std::make_unique<IPv6ResolverFactory>());
 #ifdef GRPC_HAVE_UNIX_SOCKET
   builder->resolver_registry()->RegisterResolverFactory(
-      absl::make_unique<UnixResolverFactory>());
+      std::make_unique<UnixResolverFactory>());
   builder->resolver_registry()->RegisterResolverFactory(
-      absl::make_unique<UnixAbstractResolverFactory>());
+      std::make_unique<UnixAbstractResolverFactory>());
 #endif
 }