grpc 1.53.0.pre2 → 1.54.0

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

@@ -25,6 +25,7 @@
 #include "absl/functional/bind_front.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
@@ -33,16 +34,13 @@
 #include <grpc/grpc.h>
 #include <grpc/support/log.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/config_vars.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/debug_location.h"
-#include "src/core/lib/gprpp/global_config_generic.h"
-#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/time.h"
@@ -67,7 +65,7 @@ TraceFlag grpc_trace_dns_resolver(false, "dns_resolver");
 class NativeClientChannelDNSResolver : public PollingResolver {
  public:
   NativeClientChannelDNSResolver(ResolverArgs args,
-                                 const ChannelArgs& channel_args);
+                                 Duration min_time_between_resolutions);
   ~NativeClientChannelDNSResolver() override;
 
   OrphanablePtr<Orphanable> StartRequest() override;
@@ -88,22 +86,16 @@ class NativeClientChannelDNSResolver : public PollingResolver {
 };
 
 NativeClientChannelDNSResolver::NativeClientChannelDNSResolver(
-    ResolverArgs args, const ChannelArgs& channel_args)
-    : PollingResolver(
-          std::move(args), channel_args,
-          std::max(Duration::Zero(),
-                   channel_args
-                       .GetDurationFromIntMillis(
-                           GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS)
-                       .value_or(Duration::Seconds(30))),
-          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) {
+    ResolverArgs args, Duration min_time_between_resolutions)
+    : PollingResolver(std::move(args), min_time_between_resolutions,
+                      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);
   }
@@ -174,18 +166,20 @@ class NativeClientChannelDNSResolverFactory : public ResolverFactory {
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     if (!IsValidUri(args.uri)) return nullptr;
-    auto channel_args = args.args;
+    Duration min_time_between_resolutions = std::max(
+        Duration::Zero(), args.args
+                              .GetDurationFromIntMillis(
+                                  GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS)
+                              .value_or(Duration::Seconds(30)));
     return MakeOrphanable<NativeClientChannelDNSResolver>(
-        std::move(args), std::move(channel_args));
+        std::move(args), min_time_between_resolutions);
   }
 };
 
 }  // namespace
 
 void RegisterNativeDnsResolver(CoreConfiguration::Builder* builder) {
-  static const char* const resolver =
-      GPR_GLOBAL_CONFIG_GET(grpc_dns_resolver).release();
-  if (gpr_stricmp(resolver, "native") == 0) {
+  if (absl::EqualsIgnoreCase(ConfigVars::Get().DnsResolver(), "native")) {
     gpr_log(GPR_DEBUG, "Using native dns resolver");
     builder->resolver_registry()->RegisterResolverFactory(
         std::make_unique<NativeClientChannelDNSResolverFactory>());

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

@@ -16,27 +16,22 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
-
 #include <cstdint>
-#include <initializer_list>
 #include <memory>
 #include <random>
 #include <string>
+#include <type_traits>
 #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/gcp/metadata_query.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"
@@ -45,13 +40,8 @@
 #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"
@@ -59,7 +49,6 @@
 #include "src/core/lib/resolver/resolver_registry.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 {
@@ -78,53 +67,6 @@ class GoogleCloud2ProdResolver : public Resolver {
   void ShutdownLocked() override;
 
  private:
-  // Represents an HTTP request to the metadata server.
-  class MetadataQuery : public InternallyRefCounted<MetadataQuery> {
-   public:
-    MetadataQuery(RefCountedPtr<GoogleCloud2ProdResolver> resolver,
-                  const char* path, grpc_polling_entity* pollent);
-    ~MetadataQuery() override;
-
-    void Orphan() override;
-
-   private:
-    static void OnHttpRequestDone(void* arg, grpc_error_handle error);
-
-    // 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;
-
-    RefCountedPtr<GoogleCloud2ProdResolver> resolver_;
-    OrphanablePtr<HttpRequest> http_request_;
-    grpc_http_response response_;
-    grpc_closure on_done_;
-  };
-
-  // A metadata server query to get the zone.
-  class ZoneQuery : public MetadataQuery {
-   public:
-    ZoneQuery(RefCountedPtr<GoogleCloud2ProdResolver> resolver,
-              grpc_polling_entity* pollent);
-
-   private:
-    void OnDone(GoogleCloud2ProdResolver* resolver,
-                const grpc_http_response* response,
-                grpc_error_handle error) override;
-  };
-
-  // A metadata server query to get the IPv6 address.
-  class IPv6Query : public MetadataQuery {
-   public:
-    IPv6Query(RefCountedPtr<GoogleCloud2ProdResolver> resolver,
-              grpc_polling_entity* pollent);
-
-   private:
-    void OnDone(GoogleCloud2ProdResolver* resolver,
-                const grpc_http_response* response,
-                grpc_error_handle error) override;
-  };
-
   void ZoneQueryDone(std::string zone);
   void IPv6QueryDone(bool ipv6_supported);
   void StartXdsResolver();
@@ -137,128 +79,13 @@ class GoogleCloud2ProdResolver : public Resolver {
   std::string metadata_server_name_ = "metadata.google.internal.";
   bool shutdown_ = false;
 
-  OrphanablePtr<ZoneQuery> zone_query_;
+  OrphanablePtr<MetadataQuery> zone_query_;
   absl::optional<std::string> zone_;
 
-  OrphanablePtr<IPv6Query> ipv6_query_;
+  OrphanablePtr<MetadataQuery> ipv6_query_;
   absl::optional<bool> supports_ipv6_;
 };
 
-//
-// GoogleCloud2ProdResolver::MetadataQuery
-//
-
-GoogleCloud2ProdResolver::MetadataQuery::MetadataQuery(
-    RefCountedPtr<GoogleCloud2ProdResolver> resolver, const char* path,
-    grpc_polling_entity* pollent)
-    : resolver_(std::move(resolver)) {
-  // Start HTTP request.
-  GRPC_CLOSURE_INIT(&on_done_, OnHttpRequestDone, this, nullptr);
-  Ref().release();  // Ref held by callback.
-  grpc_http_request request;
-  memset(&request, 0, sizeof(grpc_http_request));
-  grpc_http_header header = {const_cast<char*>("Metadata-Flavor"),
-                             const_cast<char*>("Google")};
-  request.hdr_count = 1;
-  request.hdrs = &header;
-  auto uri = URI::Create("http", resolver_->metadata_server_name_, path,
-                         {} /* query params */, "" /* fragment */);
-  GPR_ASSERT(uri.ok());  // params are hardcoded
-  grpc_arg resource_quota_arg = grpc_channel_arg_pointer_create(
-      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,
-                       Timestamp::Now() + Duration::Seconds(10),  // 10s timeout
-                       &on_done_, &response_,
-                       RefCountedPtr<grpc_channel_credentials>(
-                           grpc_insecure_credentials_create()));
-  http_request_->Start();
-}
-
-GoogleCloud2ProdResolver::MetadataQuery::~MetadataQuery() {
-  grpc_http_response_destroy(&response_);
-}
-
-void GoogleCloud2ProdResolver::MetadataQuery::Orphan() {
-  http_request_.reset();
-  Unref();
-}
-
-void GoogleCloud2ProdResolver::MetadataQuery::OnHttpRequestDone(
-    void* arg, grpc_error_handle error) {
-  auto* self = static_cast<MetadataQuery*>(arg);
-  // Hop back into WorkSerializer to call OnDone().
-  // Note: We implicitly pass our ref to the callback here.
-  self->resolver_->work_serializer_->Run(
-      [self, error]() {
-        self->OnDone(self->resolver_.get(), &self->response_, error);
-        self->Unref();
-      },
-      DEBUG_LOCATION);
-}
-
-//
-// GoogleCloud2ProdResolver::ZoneQuery
-//
-
-GoogleCloud2ProdResolver::ZoneQuery::ZoneQuery(
-    RefCountedPtr<GoogleCloud2ProdResolver> resolver,
-    grpc_polling_entity* pollent)
-    : MetadataQuery(std::move(resolver), "/computeMetadata/v1/instance/zone",
-                    pollent) {}
-
-void GoogleCloud2ProdResolver::ZoneQuery::OnDone(
-    GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
-    grpc_error_handle error) {
-  absl::StatusOr<std::string> zone;
-  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));
-  } else {
-    absl::string_view body(response->body, response->body_length);
-    size_t i = body.find_last_of('/');
-    if (i == body.npos) {
-      zone = absl::UnknownError(
-          absl::StrCat("could not parse zone from metadata server: ", body));
-    } else {
-      zone = std::string(body.substr(i + 1));
-    }
-  }
-  if (!zone.ok()) {
-    gpr_log(GPR_ERROR, "zone query failed: %s",
-            zone.status().ToString().c_str());
-    resolver->ZoneQueryDone("");
-  } else {
-    resolver->ZoneQueryDone(std::move(*zone));
-  }
-}
-
-//
-// GoogleCloud2ProdResolver::IPv6Query
-//
-
-GoogleCloud2ProdResolver::IPv6Query::IPv6Query(
-    RefCountedPtr<GoogleCloud2ProdResolver> resolver,
-    grpc_polling_entity* pollent)
-    : MetadataQuery(std::move(resolver),
-                    "/computeMetadata/v1/instance/network-interfaces/0/ipv6s",
-                    pollent) {}
-
-void GoogleCloud2ProdResolver::IPv6Query::OnDone(
-    GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
-    grpc_error_handle error) {
-  if (!error.ok()) {
-    gpr_log(GPR_ERROR, "error fetching IPv6 address from metadata server: %s",
-            StatusToString(error).c_str());
-  }
-  resolver->IPv6QueryDone(error.ok() && response->status == 200);
-}
-
 //
 // GoogleCloud2ProdResolver
 //
@@ -322,8 +149,33 @@ void GoogleCloud2ProdResolver::StartLocked() {
     return;
   }
   // Using xDS.  Start metadata server queries.
-  zone_query_ = MakeOrphanable<ZoneQuery>(Ref(), &pollent_);
-  ipv6_query_ = MakeOrphanable<IPv6Query>(Ref(), &pollent_);
+  zone_query_ = MakeOrphanable<MetadataQuery>(
+      metadata_server_name_, std::string(MetadataQuery::kZoneAttribute),
+      &pollent_,
+      [resolver = static_cast<RefCountedPtr<GoogleCloud2ProdResolver>>(Ref())](
+          std::string /* attribute */,
+          absl::StatusOr<std::string> result) mutable {
+        resolver->work_serializer_->Run(
+            [resolver, result = std::move(result)]() mutable {
+              resolver->ZoneQueryDone(result.ok() ? std::move(result).value()
+                                                  : "");
+            },
+            DEBUG_LOCATION);
+      },
+      Duration::Seconds(10));
+  ipv6_query_ = MakeOrphanable<MetadataQuery>(
+      metadata_server_name_, std::string(MetadataQuery::kIPv6Attribute),
+      &pollent_,
+      [resolver = static_cast<RefCountedPtr<GoogleCloud2ProdResolver>>(Ref())](
+          std::string /* attribute */,
+          absl::StatusOr<std::string> result) mutable {
+        resolver->work_serializer_->Run(
+            [resolver, result = std::move(result)]() {
+              resolver->IPv6QueryDone(result.ok());
+            },
+            DEBUG_LOCATION);
+      },
+      Duration::Seconds(10));
 }
 
 void GoogleCloud2ProdResolver::RequestReresolutionLocked() {

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

@@ -47,13 +47,12 @@ namespace grpc_core {
 using ::grpc_event_engine::experimental::EventEngine;
 
 PollingResolver::PollingResolver(ResolverArgs 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_(channel_args),
+      channel_args_(std::move(args.args)),
       work_serializer_(std::move(args.work_serializer)),
       result_handler_(std::move(args.result_handler)),
       tracer_(tracer),

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

@@ -44,8 +44,7 @@ namespace grpc_core {
 // Implementations need only to implement StartRequest().
 class PollingResolver : public Resolver {
  public:
-  PollingResolver(ResolverArgs args, const ChannelArgs& channel_args,
-                  Duration min_time_between_resolutions,
+  PollingResolver(ResolverArgs args, Duration min_time_between_resolutions,
                   BackOff::Options backoff_options, TraceFlag* tracer);
   ~PollingResolver() override;
 

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -47,6 +47,7 @@
 #include <grpc/grpc.h>
 
 #include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/slice/slice.h"
 
 #define XXH_INLINE_ALL
 #include "xxhash.h"
@@ -84,7 +85,6 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_impl.h"
-#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/uri/uri_parser.h"
 
@@ -658,8 +658,10 @@ absl::optional<uint64_t> HeaderHashHelper(
 
 absl::StatusOr<ConfigSelector::CallConfig>
 XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
+  Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
+  GPR_ASSERT(path != nullptr);
   auto route_index = XdsRouting::GetRouteForRequest(
-      RouteListIterator(&route_table_), StringViewFromSlice(*args.path),
+      RouteListIterator(&route_table_), path->as_string_view(),
       args.initial_metadata);
   if (!route_index.has_value()) {
     return absl::UnavailableError(