grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

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

@@ -0,0 +1,364 @@
+//
+// Copyright 2022 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 <cstdint>
+#include <map>
+#include <memory>
+#include <string>
+#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 <grpc/event_engine/event_engine.h>
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/support/log.h>
+
+#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_attributes.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"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+#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/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 {
+
+TraceFlag grpc_xds_wrr_locality_lb_trace(false, "xds_wrr_locality_lb");
+
+namespace {
+
+constexpr absl::string_view kXdsWrrLocality = "xds_wrr_locality_experimental";
+
+// Config for xds_wrr_locality LB policy.
+class XdsWrrLocalityLbConfig : public LoadBalancingPolicy::Config {
+ public:
+  XdsWrrLocalityLbConfig() = default;
+
+  XdsWrrLocalityLbConfig(const XdsWrrLocalityLbConfig&) = delete;
+  XdsWrrLocalityLbConfig& operator=(const XdsWrrLocalityLbConfig&) = delete;
+
+  XdsWrrLocalityLbConfig(XdsWrrLocalityLbConfig&& other) = delete;
+  XdsWrrLocalityLbConfig& operator=(XdsWrrLocalityLbConfig&& other) = delete;
+
+  absl::string_view name() const override { return kXdsWrrLocality; }
+
+  const Json& child_config() const { return child_config_; }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    // Note: The "childPolicy" field requires custom processing, so
+    // it's handled in JsonPostLoad() instead.
+    static const auto* loader =
+        JsonObjectLoader<XdsWrrLocalityLbConfig>().Finish();
+    return loader;
+  }
+
+  void JsonPostLoad(const Json& json, const JsonArgs&,
+                    ValidationErrors* errors) {
+    ValidationErrors::ScopedField field(errors, ".childPolicy");
+    auto it = json.object_value().find("childPolicy");
+    if (it == json.object_value().end()) {
+      errors->AddError("field not present");
+      return;
+    }
+    auto lb_config =
+        CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
+            it->second);
+    if (!lb_config.ok()) {
+      errors->AddError(lb_config.status().message());
+      return;
+    }
+    child_config_ = it->second;
+  }
+
+ private:
+  Json child_config_;
+};
+
+// xds_wrr_locality LB policy.
+class XdsWrrLocalityLb : public LoadBalancingPolicy {
+ public:
+  explicit XdsWrrLocalityLb(Args args);
+
+  absl::string_view name() const override { return kXdsWrrLocality; }
+
+  absl::Status UpdateLocked(UpdateArgs args) override;
+  void ExitIdleLocked() override;
+  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,
+                     std::unique_ptr<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_;
+  };
+
+  ~XdsWrrLocalityLb() override;
+
+  void ShutdownLocked() override;
+
+  OrphanablePtr<LoadBalancingPolicy> CreateChildPolicyLocked(
+      const ChannelArgs& args);
+
+  OrphanablePtr<LoadBalancingPolicy> child_policy_;
+};
+
+//
+// XdsWrrLocalityLb
+//
+
+XdsWrrLocalityLb::XdsWrrLocalityLb(Args args)
+    : LoadBalancingPolicy(std::move(args)) {}
+
+XdsWrrLocalityLb::~XdsWrrLocalityLb() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_wrr_locality_lb_trace)) {
+    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] destroying", this);
+  }
+}
+
+void XdsWrrLocalityLb::ShutdownLocked() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_wrr_locality_lb_trace)) {
+    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] shutting down", this);
+  }
+  if (child_policy_ != nullptr) {
+    grpc_pollset_set_del_pollset_set(child_policy_->interested_parties(),
+                                     interested_parties());
+    child_policy_.reset();
+  }
+}
+
+void XdsWrrLocalityLb::ExitIdleLocked() {
+  if (child_policy_ != nullptr) child_policy_->ExitIdleLocked();
+}
+
+void XdsWrrLocalityLb::ResetBackoffLocked() {
+  if (child_policy_ != nullptr) child_policy_->ResetBackoffLocked();
+}
+
+absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_wrr_locality_lb_trace)) {
+    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] Received update", this);
+  }
+  RefCountedPtr<XdsWrrLocalityLbConfig> config = std::move(args.config);
+  // Scan the addresses to find the weight for each locality.
+  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 p = locality_weights.emplace(
+            attribute->locality_name()->AsHumanReadableString(),
+            attribute->weight());
+        if (!p.second && p.first->second != attribute->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());
+        }
+      }
+    }
+  }
+  // Construct the config for the weighted_target policy.
+  Json::Object weighted_targets;
+  for (const auto& p : locality_weights) {
+    const std::string& locality_name = p.first;
+    uint32_t weight = p.second;
+    // Add weighted target entry.
+    weighted_targets[locality_name] = Json::Object{
+        {"weight", weight},
+        {"childPolicy", config->child_config()},
+    };
+  }
+  Json child_config_json = Json::Array{
+      Json::Object{
+          {"weighted_target_experimental",
+           Json::Object{
+               {"targets", std::move(weighted_targets)},
+           }},
+      },
+  };
+  // Parse config.
+  auto child_config =
+      CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
+          child_config_json);
+  if (!child_config.ok()) {
+    // This should never happen, but if it does, we basically have no
+    // way to fix it, so we put the channel in TRANSIENT_FAILURE.
+    gpr_log(GPR_ERROR,
+            "[xds_wrr_locality %p] error parsing generated child policy "
+            "config -- putting channel in TRANSIENT_FAILURE: %s",
+            this, child_config.status().ToString().c_str());
+    absl::Status status = absl::InternalError(absl::StrCat(
+        "xds_wrr_locality LB policy: error parsing generated child policy "
+        "config: ",
+        child_config.status().ToString()));
+    channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+        std::make_unique<TransientFailurePicker>(status));
+    return status;
+  }
+  // Create child policy if needed (i.e., on first update).
+  if (child_policy_ == nullptr) {
+    child_policy_ = CreateChildPolicyLocked(args.args);
+  }
+  // Construct update args.
+  UpdateArgs update_args;
+  update_args.addresses = std::move(args.addresses);
+  update_args.config = std::move(*child_config);
+  update_args.resolution_note = std::move(args.resolution_note);
+  update_args.args = std::move(args.args);
+  // Update the policy.
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_wrr_locality_lb_trace)) {
+    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] updating child policy %p", this,
+            child_policy_.get());
+  }
+  return child_policy_->UpdateLocked(std::move(update_args));
+}
+
+OrphanablePtr<LoadBalancingPolicy> XdsWrrLocalityLb::CreateChildPolicyLocked(
+    const ChannelArgs& args) {
+  LoadBalancingPolicy::Args lb_policy_args;
+  lb_policy_args.work_serializer = work_serializer();
+  lb_policy_args.args = args;
+  lb_policy_args.channel_control_helper =
+      std::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
+  auto lb_policy =
+      CoreConfiguration::Get().lb_policy_registry().CreateLoadBalancingPolicy(
+          "weighted_target_experimental", std::move(lb_policy_args));
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_wrr_locality_lb_trace)) {
+    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] created new child policy %p",
+            this, lb_policy.get());
+  }
+  // Add our interested_parties pollset_set to that of the newly created
+  // child policy. This will make the child policy progress upon activity on
+  // this LB policy, which in turn is tied to the application's call.
+  grpc_pollset_set_add_pollset_set(lb_policy->interested_parties(),
+                                   interested_parties());
+  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,
+    std::unique_ptr<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
+//
+
+class XdsWrrLocalityLbFactory : public LoadBalancingPolicyFactory {
+ public:
+  OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
+      LoadBalancingPolicy::Args args) const override {
+    return MakeOrphanable<XdsWrrLocalityLb>(std::move(args));
+  }
+
+  absl::string_view name() const override { return kXdsWrrLocality; }
+
+  absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
+  ParseLoadBalancingConfig(const Json& json) const override {
+    if (json.type() == Json::Type::JSON_NULL) {
+      // xds_wrr_locality was mentioned as a policy in the deprecated
+      // loadBalancingPolicy field or in the client API.
+      return absl::InvalidArgumentError(
+          "field:loadBalancingPolicy error:xds_wrr_locality policy requires "
+          "configuration.  Please use loadBalancingConfig field of service "
+          "config instead.");
+    }
+    return LoadRefCountedFromJson<XdsWrrLocalityLbConfig>(
+        json, JsonArgs(),
+        "errors validating xds_wrr_locality LB policy config");
+  }
+};
+
+}  // namespace
+
+void RegisterXdsWrrLocalityLbPolicy(CoreConfiguration::Builder* builder) {
+  builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
+      std::make_unique<XdsWrrLocalityLbFactory>());
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/resolver/binder/binder_resolver.cc

@@ -16,6 +16,9 @@
 
 #include <algorithm>
 
+#include "absl/status/status.h"
+
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/port.h"  // IWYU pragma: keep
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
@@ -28,7 +31,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -44,7 +46,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"
 
@@ -94,7 +95,7 @@ class BinderResolverFactory : public ResolverFactory {
       absl::string_view path, grpc_resolved_address* resolved_addr) {
     path = absl::StripPrefix(path, "/");
     if (path.empty()) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING("path is empty");
+      return GRPC_ERROR_CREATE("path is empty");
     }
     // Store parsed path in a unix socket so it can be reinterpreted as
     // sockaddr. An invalid address family (AF_MAX) is set to make sure it won't
@@ -106,14 +107,14 @@ class BinderResolverFactory : public ResolverFactory {
     static_assert(sizeof(un->sun_path) >= 101,
                   "unix socket path size is unexpectedly short");
     if (path.size() + 1 > sizeof(un->sun_path)) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      return GRPC_ERROR_CREATE(
           absl::StrCat(path, " is too long to be handled"));
     }
     // `un` has already be set to zero, no need to append null after the string
     memcpy(un->sun_path, path.data(), path.size());
     resolved_addr->len =
         static_cast<socklen_t>(sizeof(un->sun_family) + path.size() + 1);
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
 
   static bool ParseUri(const URI& uri, ServerAddressList* addresses) {
@@ -124,9 +125,8 @@ class BinderResolverFactory : public ResolverFactory {
         return false;
       }
       grpc_error_handle error = BinderAddrPopulate(uri.path(), &addr);
-      if (!GRPC_ERROR_IS_NONE(error)) {
-        gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
-        GRPC_ERROR_UNREF(error);
+      if (!error.ok()) {
+        gpr_log(GPR_ERROR, "%s", StatusToString(error).c_str());
         return false;
       }
     }
@@ -141,7 +141,7 @@ class BinderResolverFactory : public ResolverFactory {
 
 void RegisterBinderResolver(CoreConfiguration::Builder* builder) {
   builder->resolver_registry()->RegisterResolverFactory(
-      absl::make_unique<BinderResolverFactory>());
+      std::make_unique<BinderResolverFactory>());
 }
 
 }  // namespace grpc_core

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

@@ -28,14 +28,12 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 
-#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -47,6 +45,7 @@
 #include "src/core/lib/gprpp/memory.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/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -80,7 +79,6 @@
 #include "src/core/lib/iomgr/gethostname.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/service_config/service_config_impl.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -142,7 +140,7 @@ class AresClientChannelDNSResolver : public PollingResolver {
             &service_config_json_, resolver_->query_timeout_ms_));
         GRPC_CARES_TRACE_LOG(
             "resolver:%p Started resolving TXT records. txt_request_:%p",
-            resolver_.get(), srv_request_.get());
+            resolver_.get(), txt_request_.get());
       }
     }
 
@@ -259,7 +257,7 @@ std::string ChooseServiceConfig(char* service_config_choice_json,
     return "";
   }
   if (json->type() != Json::Type::ARRAY) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    *error = GRPC_ERROR_CREATE(
         "Service Config Choices, error: should be of type array");
     return "";
   }
@@ -267,7 +265,7 @@ std::string ChooseServiceConfig(char* service_config_choice_json,
   std::vector<grpc_error_handle> error_list;
   for (const Json& choice : json->array_value()) {
     if (choice.type() != Json::Type::OBJECT) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      error_list.push_back(GRPC_ERROR_CREATE(
           "Service Config Choice, error: should be of type object"));
       continue;
     }
@@ -275,7 +273,7 @@ std::string ChooseServiceConfig(char* service_config_choice_json,
     auto it = choice.object_value().find("clientLanguage");
     if (it != choice.object_value().end()) {
       if (it->second.type() != Json::Type::ARRAY) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        error_list.push_back(GRPC_ERROR_CREATE(
             "field:clientLanguage error:should be of type array"));
       } else if (!ValueInJsonArray(it->second.array_value(), "c++")) {
         continue;
@@ -285,7 +283,7 @@ std::string ChooseServiceConfig(char* service_config_choice_json,
     it = choice.object_value().find("clientHostname");
     if (it != choice.object_value().end()) {
       if (it->second.type() != Json::Type::ARRAY) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        error_list.push_back(GRPC_ERROR_CREATE(
             "field:clientHostname error:should be of type array"));
       } else {
         char* hostname = grpc_gethostname();
@@ -299,13 +297,13 @@ std::string ChooseServiceConfig(char* service_config_choice_json,
     it = choice.object_value().find("percentage");
     if (it != choice.object_value().end()) {
       if (it->second.type() != Json::Type::NUMBER) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        error_list.push_back(GRPC_ERROR_CREATE(
             "field:percentage error:should be of type number"));
       } else {
         int random_pct = rand() % 100;
         int percentage;
         if (sscanf(it->second.string_value().c_str(), "%d", &percentage) != 1) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          error_list.push_back(GRPC_ERROR_CREATE(
               "field:percentage error:should be of type integer"));
         } else if (random_pct > percentage || percentage == 0) {
           continue;
@@ -315,10 +313,10 @@ std::string ChooseServiceConfig(char* service_config_choice_json,
     // Found service config.
     it = choice.object_value().find("serviceConfig");
     if (it == choice.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      error_list.push_back(GRPC_ERROR_CREATE(
           "field:serviceConfig error:required field missing"));
     } else if (it->second.type() != Json::Type::OBJECT) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      error_list.push_back(GRPC_ERROR_CREATE(
           "field:serviceConfig error:should be of type object"));
     } else if (service_config == nullptr) {
       service_config = &it->second;
@@ -407,14 +405,13 @@ AresClientChannelDNSResolver::AresRequestWrapper::OnResolvedLocked(
       result.addresses = ServerAddressList();
     }
     if (service_config_json_ != nullptr) {
-      grpc_error_handle service_config_error = GRPC_ERROR_NONE;
+      grpc_error_handle service_config_error;
       std::string service_config_string =
           ChooseServiceConfig(service_config_json_, &service_config_error);
-      if (!GRPC_ERROR_IS_NONE(service_config_error)) {
+      if (!service_config_error.ok()) {
         result.service_config = absl::UnavailableError(
             absl::StrCat("failed to parse service config: ",
-                         grpc_error_std_string(service_config_error)));
-        GRPC_ERROR_UNREF(service_config_error);
+                         StatusToString(service_config_error)));
       } else if (!service_config_string.empty()) {
         GRPC_CARES_TRACE_LOG("resolver:%p selected service config choice: %s",
                              this, service_config_string.c_str());
@@ -433,9 +430,9 @@ AresClientChannelDNSResolver::AresRequestWrapper::OnResolvedLocked(
     }
   } else {
     GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed: %s", this,
-                         grpc_error_std_string(error).c_str());
+                         StatusToString(error).c_str());
     std::string error_message;
-    grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION, &error_message);
+    grpc_error_get_str(error, StatusStrProperty::kDescription, &error_message);
     absl::Status status = absl::UnavailableError(
         absl::StrCat("DNS resolution failed for ", resolver_->name_to_resolve(),
                      ": ", error_message));
@@ -508,7 +505,7 @@ class AresDNSResolver : public DNSResolver {
         grpc_cancel_ares_request(grpc_ares_request_.get());
       } else {
         completed_ = true;
-        OnDnsLookupDone(this, GRPC_ERROR_CANCELLED);
+        OnDnsLookupDone(this, absl::CancelledError());
       }
       grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties_);
       return true;
@@ -618,7 +615,7 @@ class AresDNSResolver : public DNSResolver {
 
     void OnComplete(grpc_error_handle error) override {
       GRPC_CARES_TRACE_LOG("AresHostnameRequest:%p OnComplete", this);
-      if (!GRPC_ERROR_IS_NONE(error)) {
+      if (!error.ok()) {
         on_resolve_address_done_(grpc_error_to_absl_status(error));
         return;
       }
@@ -668,7 +665,7 @@ class AresDNSResolver : public DNSResolver {
 
     void OnComplete(grpc_error_handle error) override {
       GRPC_CARES_TRACE_LOG("AresSRVRequest:%p OnComplete", this);
-      if (!GRPC_ERROR_IS_NONE(error)) {
+      if (!error.ok()) {
         on_resolve_address_done_(grpc_error_to_absl_status(error));
         return;
       }
@@ -716,7 +713,7 @@ class AresDNSResolver : public DNSResolver {
 
     void OnComplete(grpc_error_handle error) override {
       GRPC_CARES_TRACE_LOG("AresSRVRequest:%p OnComplete", this);
-      if (!GRPC_ERROR_IS_NONE(error)) {
+      if (!error.ok()) {
         on_resolved_(grpc_error_to_absl_status(error));
         return;
       }
@@ -729,12 +726,6 @@ class AresDNSResolver : public DNSResolver {
     const std::function<void(absl::StatusOr<std::string>)> on_resolved_;
   };
 
-  // gets the singleton instance, possibly creating it first
-  static AresDNSResolver* GetOrCreate() {
-    static AresDNSResolver* instance = new AresDNSResolver();
-    return instance;
-  }
-
   TaskHandle LookupHostname(
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
           on_resolved,
@@ -812,7 +803,7 @@ class AresDNSResolver : public DNSResolver {
   }
 
   // the previous default DNS resolver, used to delegate blocking DNS calls to
-  DNSResolver* default_resolver_ = GetDNSResolver();
+  std::shared_ptr<DNSResolver> default_resolver_ = GetDNSResolver();
   Mutex mu_;
   grpc_event_engine::experimental::LookupTaskHandleSet open_requests_
       ABSL_GUARDED_BY(mu_);
@@ -839,7 +830,7 @@ bool UseAresDnsResolver() {
 void RegisterAresDnsResolver(CoreConfiguration::Builder* builder) {
   if (UseAresDnsResolver()) {
     builder->resolver_registry()->RegisterResolverFactory(
-        absl::make_unique<AresClientChannelDNSResolverFactory>());
+        std::make_unique<AresClientChannelDNSResolverFactory>());
   }
 }
 
@@ -849,11 +840,11 @@ void grpc_resolver_dns_ares_init() {
   if (grpc_core::UseAresDnsResolver()) {
     address_sorting_init();
     grpc_error_handle error = grpc_ares_init();
-    if (!GRPC_ERROR_IS_NONE(error)) {
+    if (!error.ok()) {
       GRPC_LOG_IF_ERROR("grpc_ares_init() failed", error);
       return;
     }
-    grpc_core::SetDNSResolver(grpc_core::AresDNSResolver::GetOrCreate());
+    grpc_core::ResetDNSResolver(std::make_unique<grpc_core::AresDNSResolver>());
   }
 }
 

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

@@ -21,7 +21,6 @@
 #include <string>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/memory/memory.h"
 
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -108,7 +107,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
 };
 
 std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(Mutex* /* mu */) {
-  return absl::make_unique<GrpcPolledFdFactoryPosix>();
+  return std::make_unique<GrpcPolledFdFactoryPosix>();
 }
 
 }  // namespace grpc_core