grpc 1.54.3 → 1.55.0

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

@@ -17,11 +17,9 @@
 #include <grpc/support/port_platform.h>
 
 #include <stdint.h>
-#include <stdlib.h>
 
 #include <algorithm>
 #include <functional>
-#include <map>
 #include <memory>
 #include <string>
 #include <utility>
@@ -40,6 +38,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/filters/client_channel/resolver/dns/event_engine/service_config_helper.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -60,8 +59,6 @@
 
 #if GRPC_ARES == 1
 
-#include <stdio.h>
-
 #include <address_sorting/address_sorting.h>
 
 #include "absl/container/flat_hash_set.h"
@@ -74,9 +71,7 @@
 #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/gethostname.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/json/json.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"
@@ -235,97 +230,6 @@ OrphanablePtr<Orphanable> AresClientChannelDNSResolver::StartRequest() {
       Ref(DEBUG_LOCATION, "dns-resolving"));
 }
 
-bool ValueInJsonArray(const Json::Array& array, const char* value) {
-  for (const Json& entry : array) {
-    if (entry.type() == Json::Type::STRING && entry.string_value() == value) {
-      return true;
-    }
-  }
-  return false;
-}
-
-std::string ChooseServiceConfig(char* service_config_choice_json,
-                                grpc_error_handle* error) {
-  auto json = Json::Parse(service_config_choice_json);
-  if (!json.ok()) {
-    *error = absl_status_to_grpc_error(json.status());
-    return "";
-  }
-  if (json->type() != Json::Type::ARRAY) {
-    *error = GRPC_ERROR_CREATE(
-        "Service Config Choices, error: should be of type array");
-    return "";
-  }
-  const Json* service_config = nullptr;
-  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(
-          "Service Config Choice, error: should be of type object"));
-      continue;
-    }
-    // Check client language, if specified.
-    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(
-            "field:clientLanguage error:should be of type array"));
-      } else if (!ValueInJsonArray(it->second.array_value(), "c++")) {
-        continue;
-      }
-    }
-    // Check client hostname, if specified.
-    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(
-            "field:clientHostname error:should be of type array"));
-      } else {
-        char* hostname = grpc_gethostname();
-        if (hostname == nullptr ||
-            !ValueInJsonArray(it->second.array_value(), hostname)) {
-          continue;
-        }
-      }
-    }
-    // Check percentage, if specified.
-    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(
-            "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(
-              "field:percentage error:should be of type integer"));
-        } else if (random_pct > percentage || percentage == 0) {
-          continue;
-        }
-      }
-    }
-    // Found service config.
-    it = choice.object_value().find("serviceConfig");
-    if (it == choice.object_value().end()) {
-      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(
-          "field:serviceConfig error:should be of type object"));
-    } else if (service_config == nullptr) {
-      service_config = &it->second;
-    }
-  }
-  if (!error_list.empty()) {
-    service_config = nullptr;
-    *error = GRPC_ERROR_CREATE_FROM_VECTOR("Service Config Choices Parser",
-                                           &error_list);
-  }
-  if (service_config == nullptr) return "";
-  return service_config->Dump();
-}
-
 void AresClientChannelDNSResolver::AresRequestWrapper::OnHostnameResolved(
     void* arg, grpc_error_handle error) {
   auto* self = static_cast<AresRequestWrapper*>(arg);
@@ -400,18 +304,16 @@ AresClientChannelDNSResolver::AresRequestWrapper::OnResolvedLocked(
       result.addresses = ServerAddressList();
     }
     if (service_config_json_ != nullptr) {
-      grpc_error_handle service_config_error;
-      std::string service_config_string =
-          ChooseServiceConfig(service_config_json_, &service_config_error);
-      if (!service_config_error.ok()) {
+      auto service_config_string = ChooseServiceConfig(service_config_json_);
+      if (!service_config_string.ok()) {
         result.service_config = absl::UnavailableError(
             absl::StrCat("failed to parse service config: ",
-                         StatusToString(service_config_error)));
-      } else if (!service_config_string.empty()) {
+                         StatusToString(service_config_string.status())));
+      } else if (!service_config_string->empty()) {
         GRPC_CARES_TRACE_LOG("resolver:%p selected service config choice: %s",
-                             this, service_config_string.c_str());
+                             this, service_config_string->c_str());
         result.service_config = ServiceConfigImpl::Create(
-            resolver_->channel_args(), service_config_string);
+            resolver_->channel_args(), *service_config_string);
         if (!result.service_config.ok()) {
           result.service_config = absl::UnavailableError(
               absl::StrCat("failed to parse service config: ",
@@ -809,27 +711,22 @@ class AresDNSResolver : public DNSResolver {
   intptr_t aba_token_ ABSL_GUARDED_BY(mu_) = 0;
 };
 
-bool ShouldUseAres(absl::string_view resolver_env) {
-  return resolver_env.empty() || absl::EqualsIgnoreCase(resolver_env, "ares");
-}
+}  // namespace
 
-bool UseAresDnsResolver() {
-  return ShouldUseAres(ConfigVars::Get().DnsResolver());
+bool ShouldUseAresDnsResolver(absl::string_view resolver_env) {
+  return resolver_env.empty() || absl::EqualsIgnoreCase(resolver_env, "ares");
 }
 
-}  // namespace
-
 void RegisterAresDnsResolver(CoreConfiguration::Builder* builder) {
-  if (UseAresDnsResolver()) {
-    builder->resolver_registry()->RegisterResolverFactory(
-        std::make_unique<AresClientChannelDNSResolverFactory>());
-  }
+  builder->resolver_registry()->RegisterResolverFactory(
+      std::make_unique<AresClientChannelDNSResolverFactory>());
 }
 
 }  // namespace grpc_core
 
 void grpc_resolver_dns_ares_init() {
-  if (grpc_core::UseAresDnsResolver()) {
+  if (grpc_core::ShouldUseAresDnsResolver(
+          grpc_core::ConfigVars::Get().DnsResolver())) {
     address_sorting_init();
     grpc_error_handle error = grpc_ares_init();
     if (!error.ok()) {
@@ -841,7 +738,8 @@ void grpc_resolver_dns_ares_init() {
 }
 
 void grpc_resolver_dns_ares_shutdown() {
-  if (grpc_core::UseAresDnsResolver()) {
+  if (grpc_core::ShouldUseAresDnsResolver(
+          grpc_core::ConfigVars::Get().DnsResolver())) {
     address_sorting_shutdown();
     grpc_ares_cleanup();
   }
@@ -850,6 +748,9 @@ void grpc_resolver_dns_ares_shutdown() {
 #else  // GRPC_ARES == 1
 
 namespace grpc_core {
+bool ShouldUseAresDnsResolver(absl::string_view /* resolver_env */) {
+  return false;
+}
 void RegisterAresDnsResolver(CoreConfiguration::Builder*) {}
 }  // namespace grpc_core
 

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

@@ -0,0 +1,30 @@
+// Copyright 2022 The 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_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_DNS_RESOLVER_ARES_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_DNS_RESOLVER_ARES_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/config/core_configuration.h"
+
+namespace grpc_core {
+
+bool ShouldUseAresDnsResolver(absl::string_view resolver_env);
+void RegisterAresDnsResolver(CoreConfiguration::Builder*);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_DNS_RESOLVER_ARES_H

data/src/core/ext/filters/client_channel/resolver/dns/dns_resolver_plugin.cc

@@ -0,0 +1,60 @@
+// Copyright 2022 The 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/dns/dns_resolver_plugin.h"
+
+#include <memory>
+
+#include "absl/strings/match.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.h"
+#include "src/core/ext/filters/client_channel/resolver/dns/event_engine/event_engine_client_channel_resolver.h"
+#include "src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.h"
+#include "src/core/lib/config/config_vars.h"
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/resolver/resolver_factory.h"
+
+namespace grpc_core {
+
+void RegisterDnsResolver(CoreConfiguration::Builder* builder) {
+  if (IsEventEngineDnsEnabled()) {
+    gpr_log(GPR_DEBUG, "Using EventEngine dns resolver");
+    builder->resolver_registry()->RegisterResolverFactory(
+        std::make_unique<EventEngineClientChannelDNSResolverFactory>());
+    return;
+  }
+  auto resolver = ConfigVars::Get().DnsResolver();
+  // ---- Ares resolver ----
+  if (ShouldUseAresDnsResolver(resolver)) {
+    gpr_log(GPR_DEBUG, "Using ares dns resolver");
+    RegisterAresDnsResolver(builder);
+    return;
+  }
+  // ---- Native resolver ----
+  if (absl::EqualsIgnoreCase(resolver, "native") ||
+      !builder->resolver_registry()->HasResolverFactory("dns")) {
+    gpr_log(GPR_DEBUG, "Using native dns resolver");
+    RegisterNativeDnsResolver(builder);
+    return;
+  }
+  Crash(
+      "Unable to set DNS resolver! Likely a logic error in gRPC-core, "
+      "please file a bug.");
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/resolver/dns/dns_resolver_plugin.h

@@ -0,0 +1,27 @@
+// Copyright 2022 The 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_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/core_configuration.h"
+
+namespace grpc_core {
+
+// Centralized decision logic about which client channel DNS resolver to enable.
+void RegisterDnsResolver(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H