grpc 1.33.0.pre1 → 1.34.0

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

@@ -16,18 +16,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <inttypes.h>
-#include <limits.h>
-#include <string.h>
+#include <set>
+#include <string>
+#include <vector>
 
-#include "absl/container/inlined_vector.h"
-#include "absl/strings/match.h"
-#include "absl/strings/numbers.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
-#include "re2/re2.h"
 
 #include <grpc/grpc.h>
 
@@ -36,7 +31,6 @@
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver.h"
-#include "src/core/ext/xds/xds_api.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/orphanable.h"
@@ -109,17 +103,13 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
 
     // It is required that the keys of cluster_map have to live at least as long
     // as the ClusterPicker instance.
-    ClusterPicker(ClusterMap cluster_map,
-                  RefCountedPtr<XdsClusterManagerLbConfig> config)
-        : cluster_map_(std::move(cluster_map)), config_(std::move(config)) {}
+    explicit ClusterPicker(ClusterMap cluster_map)
+        : cluster_map_(std::move(cluster_map)) {}
 
     PickResult Pick(PickArgs args) override;
 
    private:
     ClusterMap cluster_map_;
-    // Take a reference to config so that we can use
-    // XdsApi::RdsUpdate::RdsRoute::Matchers from it.
-    RefCountedPtr<XdsClusterManagerLbConfig> config_;
   };
 
   // Each ClusterChild holds a ref to its parent XdsClusterManagerLb.
@@ -127,7 +117,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
    public:
     ClusterChild(RefCountedPtr<XdsClusterManagerLb> xds_cluster_manager_policy,
                  const std::string& name);
-    ~ClusterChild();
+    ~ClusterChild() override;
 
     void Orphan() override;
 
@@ -151,7 +141,9 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
       explicit Helper(RefCountedPtr<ClusterChild> xds_cluster_manager_child)
           : xds_cluster_manager_child_(std::move(xds_cluster_manager_child)) {}
 
-      ~Helper() { xds_cluster_manager_child_.reset(DEBUG_LOCATION, "Helper"); }
+      ~Helper() override {
+        xds_cluster_manager_child_.reset(DEBUG_LOCATION, "Helper");
+      }
 
       RefCountedPtr<SubchannelInterface> CreateSubchannel(
           ServerAddress address, const grpc_channel_args& args) override;
@@ -192,7 +184,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
     bool shutdown_ = false;
   };
 
-  ~XdsClusterManagerLb();
+  ~XdsClusterManagerLb() override;
 
   void ShutdownLocked() override;
 
@@ -368,8 +360,7 @@ void XdsClusterManagerLb::UpdateStateLocked() {
                                 Ref(DEBUG_LOCATION, "QueuePicker")));
         }
       }
-      picker =
-          absl::make_unique<ClusterPicker>(std::move(cluster_map), config_);
+      picker = absl::make_unique<ClusterPicker>(std::move(cluster_map));
       break;
     }
     case GRPC_CHANNEL_CONNECTING:
@@ -547,8 +538,9 @@ void XdsClusterManagerLb::ClusterChild::OnDelayedRemovalTimerLocked(
 RefCountedPtr<SubchannelInterface>
 XdsClusterManagerLb::ClusterChild::Helper::CreateSubchannel(
     ServerAddress address, const grpc_channel_args& args) {
-  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_)
+  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_) {
     return nullptr;
+  }
   return xds_cluster_manager_child_->xds_cluster_manager_policy_
       ->channel_control_helper()
       ->CreateSubchannel(std::move(address), args);
@@ -566,8 +558,9 @@ void XdsClusterManagerLb::ClusterChild::Helper::UpdateState(
         xds_cluster_manager_child_->name_.c_str(), ConnectivityStateName(state),
         status.ToString().c_str(), picker.get());
   }
-  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_)
+  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_) {
     return;
+  }
   // Cache the picker in the ClusterChild.
   xds_cluster_manager_child_->picker_wrapper_ =
       MakeRefCounted<ChildPickerWrapper>(xds_cluster_manager_child_->name_,
@@ -591,8 +584,9 @@ void XdsClusterManagerLb::ClusterChild::Helper::UpdateState(
 }
 
 void XdsClusterManagerLb::ClusterChild::Helper::RequestReresolution() {
-  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_)
+  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_) {
     return;
+  }
   xds_cluster_manager_child_->xds_cluster_manager_policy_
       ->channel_control_helper()
       ->RequestReresolution();
@@ -600,8 +594,9 @@ void XdsClusterManagerLb::ClusterChild::Helper::RequestReresolution() {
 
 void XdsClusterManagerLb::ClusterChild::Helper::AddTraceEvent(
     TraceSeverity severity, absl::string_view message) {
-  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_)
+  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_) {
     return;
+  }
   xds_cluster_manager_child_->xds_cluster_manager_policy_
       ->channel_control_helper()
       ->AddTraceEvent(severity, message);

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

@@ -31,7 +31,9 @@ namespace grpc_core {
 
 Resolver::Resolver(std::shared_ptr<WorkSerializer> work_serializer,
                    std::unique_ptr<ResultHandler> result_handler)
-    : InternallyRefCounted(&grpc_trace_resolver_refcount),
+    : InternallyRefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_trace_resolver_refcount)
+                               ? "Resolver"
+                               : nullptr),
       work_serializer_(std::move(work_serializer)),
       result_handler_(std::move(result_handler)) {}
 

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

@@ -32,6 +32,9 @@
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount;
 
+// Name associated with individual address, if available.
+#define GRPC_ARG_ADDRESS_NAME "grpc.address_name"
+
 namespace grpc_core {
 
 /// Interface for name resolution.
@@ -87,7 +90,7 @@ class Resolver : public InternallyRefCounted<Resolver> {
   // Not copyable nor movable.
   Resolver(const Resolver&) = delete;
   Resolver& operator=(const Resolver&) = delete;
-  virtual ~Resolver() = default;
+  ~Resolver() override = default;
 
   /// Starts resolving.
   virtual void StartLocked() = 0;

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

@@ -75,7 +75,7 @@ class AresDnsResolver : public Resolver {
   void ShutdownLocked() override;
 
  private:
-  virtual ~AresDnsResolver();
+  ~AresDnsResolver() override;
 
   void MaybeStartResolvingLocked();
   void StartResolvingLocked();

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

@@ -49,7 +49,7 @@ class GrpcPolledFdPosix : public GrpcPolledFd {
     grpc_pollset_set_add_fd(driver_pollset_set_, fd_);
   }
 
-  ~GrpcPolledFdPosix() {
+  ~GrpcPolledFdPosix() override {
     grpc_pollset_set_del_fd(driver_pollset_set_, fd_);
     /* c-ares library will close the fd inside grpc_fd. This fd may be picked up
        immediately by another thread, and should not be closed by the following

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

@@ -63,7 +63,7 @@ class NativeDnsResolver : public Resolver {
   void ShutdownLocked() override;
 
  private:
-  virtual ~NativeDnsResolver();
+  ~NativeDnsResolver() override;
 
   void MaybeStartResolvingLocked();
   void StartResolvingLocked();

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc

@@ -59,7 +59,7 @@ class FakeResolver : public Resolver {
   friend class FakeResolverResponseGenerator;
   friend class FakeResolverResponseSetter;
 
-  virtual ~FakeResolver();
+  ~FakeResolver() override;
 
   void ShutdownLocked() override;
 

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h

@@ -43,7 +43,7 @@ class FakeResolverResponseGenerator
     : public RefCounted<FakeResolverResponseGenerator> {
  public:
   FakeResolverResponseGenerator();
-  ~FakeResolverResponseGenerator();
+  ~FakeResolverResponseGenerator() override;
 
   // Instructs the fake resolver associated with the response generator
   // instance to trigger a new resolution with the specified result. If the

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

@@ -168,6 +168,24 @@ class UnixResolverFactory : public ResolverFactory {
 
   const char* scheme() const override { return "unix"; }
 };
+
+class UnixAbstractResolverFactory : public ResolverFactory {
+ public:
+  bool IsValidUri(const grpc_uri* uri) const override {
+    return ParseUri(uri, grpc_parse_unix_abstract, nullptr);
+  }
+
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    return CreateSockaddrResolver(std::move(args), grpc_parse_unix_abstract);
+  }
+
+  grpc_core::UniquePtr<char> GetDefaultAuthority(
+      grpc_uri* /*uri*/) const override {
+    return grpc_core::UniquePtr<char>(gpr_strdup("localhost"));
+  }
+
+  const char* scheme() const override { return "unix-abstract"; }
+};
 #endif  // GRPC_HAVE_UNIX_SOCKET
 
 }  // namespace
@@ -182,6 +200,8 @@ void grpc_resolver_sockaddr_init() {
 #ifdef GRPC_HAVE_UNIX_SOCKET
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
       absl::make_unique<grpc_core::UnixResolverFactory>());
+  grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
+      absl::make_unique<grpc_core::UnixAbstractResolverFactory>());
 #endif
 }
 

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

@@ -138,8 +138,9 @@ class XdsResolver : public Resolver {
   class XdsConfigSelector : public ConfigSelector {
    public:
     XdsConfigSelector(RefCountedPtr<XdsResolver> resolver,
-                      const std::vector<XdsApi::Route>& routes);
-    ~XdsConfigSelector();
+                      const std::vector<XdsApi::Route>& routes,
+                      grpc_error* error);
+    ~XdsConfigSelector() override;
 
     const char* name() const override { return "XdsConfigSelector"; }
 
@@ -157,6 +158,7 @@ class XdsResolver : public Resolver {
       XdsApi::Route route;
       absl::InlinedVector<std::pair<uint32_t, absl::string_view>, 2>
           weighted_cluster_state;
+      RefCountedPtr<ServiceConfig> method_config;
       bool operator==(const Route& other) const {
         return route == other.route &&
                weighted_cluster_state == other.weighted_cluster_state;
@@ -165,6 +167,8 @@ class XdsResolver : public Resolver {
     using RouteTable = std::vector<Route>;
 
     void MaybeAddCluster(const std::string& name);
+    grpc_error* CreateMethodConfig(RefCountedPtr<ServiceConfig>* method_config,
+                                   const XdsApi::Route& route);
 
     RefCountedPtr<XdsResolver> resolver_;
     RouteTable route_table_;
@@ -189,6 +193,7 @@ class XdsResolver : public Resolver {
   XdsClient::RouteConfigWatcherInterface* route_config_watcher_ = nullptr;
   ClusterState::ClusterStateMap cluster_state_map_;
   std::vector<XdsApi::Route> current_update_;
+  XdsApi::Duration http_max_stream_duration_;
 };
 
 //
@@ -261,7 +266,7 @@ void XdsResolver::Notifier::RunInWorkSerializer(grpc_error* error) {
 
 XdsResolver::XdsConfigSelector::XdsConfigSelector(
     RefCountedPtr<XdsResolver> resolver,
-    const std::vector<XdsApi::Route>& routes)
+    const std::vector<XdsApi::Route>& routes, grpc_error* error)
     : resolver_(std::move(resolver)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] creating XdsConfigSelector %p",
@@ -285,6 +290,13 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
     route_table_.emplace_back();
     auto& route_entry = route_table_.back();
     route_entry.route = route;
+    // If the route doesn't specify a timeout, set its timeout to the global
+    // one.
+    if (!route.max_stream_duration.has_value()) {
+      route_entry.route.max_stream_duration =
+          resolver_->http_max_stream_duration_;
+    }
+    error = CreateMethodConfig(&route_entry.method_config, route_entry.route);
     if (route.weighted_clusters.empty()) {
       MaybeAddCluster(route.cluster_name);
     } else {
@@ -299,6 +311,34 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
   }
 }
 
+grpc_error* XdsResolver::XdsConfigSelector::CreateMethodConfig(
+    RefCountedPtr<ServiceConfig>* method_config, const XdsApi::Route& route) {
+  grpc_error* error = GRPC_ERROR_NONE;
+  std::vector<std::string> fields;
+  if (route.max_stream_duration.has_value() &&
+      (route.max_stream_duration->seconds != 0 ||
+       route.max_stream_duration->nanos != 0)) {
+    fields.emplace_back(absl::StrFormat("    \"timeout\": \"%d.%09ds\"",
+                                        route.max_stream_duration->seconds,
+                                        route.max_stream_duration->nanos));
+  }
+  if (!fields.empty()) {
+    std::string json = absl::StrCat(
+        "{\n"
+        "  \"methodConfig\": [ {\n"
+        "    \"name\": [\n"
+        "      {}\n"
+        "    ],\n"
+        "    ",
+        absl::StrJoin(fields, ",\n"),
+        "\n  } ]\n"
+        "}");
+    *method_config =
+        ServiceConfig::Create(resolver_->args_, json.c_str(), &error);
+  }
+  return error;
+}
+
 XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] destroying XdsConfigSelector %p",
@@ -325,10 +365,18 @@ bool PathMatch(const absl::string_view& path,
                const XdsApi::Route::Matchers::PathMatcher& path_matcher) {
   switch (path_matcher.type) {
     case XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PREFIX:
-      return absl::StartsWith(path, path_matcher.string_matcher);
+      return path_matcher.case_sensitive
+                 ? absl::StartsWith(path, path_matcher.string_matcher)
+                 : absl::StartsWithIgnoreCase(path,
+                                              path_matcher.string_matcher);
     case XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PATH:
-      return path == path_matcher.string_matcher;
+      return path_matcher.case_sensitive
+                 ? path == path_matcher.string_matcher
+                 : absl::EqualsIgnoreCase(path, path_matcher.string_matcher);
     case XdsApi::Route::Matchers::PathMatcher::PathMatcherType::REGEX:
+      // Note: Case-sensitive option will already have been set appropriately
+      // in path_matcher.regex_matcher when it was constructed, so no
+      // need to check it here.
       return RE2::FullMatch(path.data(), *path_matcher.regex_matcher);
     default:
       return false;
@@ -476,6 +524,11 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
         static_cast<XdsResolver*>(resolver_->Ref().release());
     ClusterState* cluster_state = it->second->Ref().release();
     CallConfig call_config;
+    if (entry.method_config != nullptr) {
+      call_config.service_config = entry.method_config;
+      call_config.method_configs =
+          entry.method_config->GetMethodParsedConfigVector(grpc_empty_slice());
+    }
     call_config.call_attributes[kXdsClusterAttribute] = it->first;
     call_config.on_call_committed = [resolver, cluster_state]() {
       cluster_state->Unref();
@@ -578,6 +631,7 @@ void XdsResolver::OnListenerUpdate(XdsApi::LdsUpdate listener) {
       xds_client_->WatchRouteConfigData(route_config_name_, std::move(watcher));
     }
   }
+  http_max_stream_duration_ = listener.http_max_stream_duration;
   if (route_config_name_.empty()) {
     GPR_ASSERT(listener.rds_update.has_value());
     OnRouteConfigUpdate(std::move(*listener.rds_update));
@@ -663,10 +717,15 @@ void XdsResolver::GenerateResult() {
   if (current_update_.empty()) return;
   // First create XdsConfigSelector, which may add new entries to the cluster
   // state map, and then CreateServiceConfig for LB policies.
+  grpc_error* error = GRPC_ERROR_NONE;
   auto config_selector =
-      MakeRefCounted<XdsConfigSelector>(Ref(), current_update_);
+      MakeRefCounted<XdsConfigSelector>(Ref(), current_update_, error);
+  if (error != GRPC_ERROR_NONE) {
+    OnError(error);
+    return;
+  }
   Result result;
-  grpc_error* error = CreateServiceConfig(&result.service_config);
+  error = CreateServiceConfig(&result.service_config);
   if (error != GRPC_ERROR_NONE) {
     OnError(error);
     return;

data/src/core/ext/filters/client_channel/resolver_registry.cc

@@ -68,18 +68,18 @@ class RegistryState {
   ResolverFactory* FindResolverFactory(const char* target, grpc_uri** uri,
                                        std::string* canonical_target) const {
     GPR_ASSERT(uri != nullptr);
-    *uri = grpc_uri_parse(target, 1);
+    *uri = grpc_uri_parse(target, true);
     ResolverFactory* factory =
         *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
     if (factory == nullptr) {
       grpc_uri_destroy(*uri);
       *canonical_target = absl::StrCat(default_prefix_.get(), target);
-      *uri = grpc_uri_parse(canonical_target->c_str(), 1);
+      *uri = grpc_uri_parse(canonical_target->c_str(), true);
       factory =
           *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
       if (factory == nullptr) {
-        grpc_uri_destroy(grpc_uri_parse(target, 0));
-        grpc_uri_destroy(grpc_uri_parse(canonical_target->c_str(), 0));
+        grpc_uri_destroy(grpc_uri_parse(target, false));
+        grpc_uri_destroy(grpc_uri_parse(canonical_target->c_str(), false));
         gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
                 canonical_target->c_str());
       }

data/src/core/ext/filters/client_channel/resolver_result_parsing.cc

@@ -95,26 +95,19 @@ std::unique_ptr<ClientChannelMethodParsedConfig::RetryPolicy> ParseRetryPolicy(
     }
   }
   // Parse initialBackoff.
-  it = json.object_value().find("initialBackoff");
-  if (it != json.object_value().end()) {
-    if (!ParseDurationFromJson(it->second, &retry_policy->initial_backoff)) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:initialBackoff error:Failed to parse"));
-    } else if (retry_policy->initial_backoff == 0) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:initialBackoff error:must be greater than 0"));
-    }
+  if (ParseJsonObjectFieldAsDuration(json.object_value(), "initialBackoff",
+                                     &retry_policy->initial_backoff,
+                                     &error_list) &&
+      retry_policy->initial_backoff == 0) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:initialBackoff error:must be greater than 0"));
   }
   // Parse maxBackoff.
-  it = json.object_value().find("maxBackoff");
-  if (it != json.object_value().end()) {
-    if (!ParseDurationFromJson(it->second, &retry_policy->max_backoff)) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:maxBackoff error:failed to parse"));
-    } else if (retry_policy->max_backoff == 0) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:maxBackoff error:should be greater than 0"));
-    }
+  if (ParseJsonObjectFieldAsDuration(json.object_value(), "maxBackoff",
+                                     &retry_policy->max_backoff, &error_list) &&
+      retry_policy->max_backoff == 0) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:maxBackoff error:should be greater than 0"));
   }
   // Parse backoffMultiplier.
   it = json.object_value().find("backoffMultiplier");
@@ -383,13 +376,8 @@ ClientChannelServiceConfigParser::ParsePerMethodParams(
     }
   }
   // Parse timeout.
-  it = json.object_value().find("timeout");
-  if (it != json.object_value().end()) {
-    if (!ParseDurationFromJson(it->second, &timeout)) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:timeout error:Failed parsing"));
-    };
-  }
+  ParseJsonObjectFieldAsDuration(json.object_value(), "timeout", &timeout,
+                                 &error_list, false);
   // Parse retry policy.
   it = json.object_value().find("retryPolicy");
   if (it != json.object_value().end()) {