grpc 1.44.0.pre2 → 1.45.0

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

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015-2016 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.
- *
- */
+//
+// Copyright 2015 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>
 
@@ -30,6 +28,7 @@
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
@@ -91,6 +90,10 @@ bool ParseUri(const URI& uri,
   // Construct addresses.
   bool errors_found = false;
   for (absl::string_view ith_path : absl::StrSplit(uri.path(), ',')) {
+    if (ith_path.empty()) {
+      // Skip targets which are empty.
+      continue;
+    }
     auto ith_uri = URI::Create(uri.scheme(), "", std::string(ith_path), {}, "");
     grpc_resolved_address addr;
     if (!ith_uri.ok() || !parse(*ith_uri, &addr)) {
@@ -123,7 +126,7 @@ class IPv4ResolverFactory : public ResolverFactory {
     return CreateSockaddrResolver(std::move(args), grpc_parse_ipv4);
   }
 
-  const char* scheme() const override { return "ipv4"; }
+  absl::string_view scheme() const override { return "ipv4"; }
 };
 
 class IPv6ResolverFactory : public ResolverFactory {
@@ -136,7 +139,7 @@ class IPv6ResolverFactory : public ResolverFactory {
     return CreateSockaddrResolver(std::move(args), grpc_parse_ipv6);
   }
 
-  const char* scheme() const override { return "ipv6"; }
+  absl::string_view scheme() const override { return "ipv6"; }
 };
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
@@ -154,11 +157,13 @@ class UnixResolverFactory : public ResolverFactory {
     return "localhost";
   }
 
-  const char* scheme() const override { return "unix"; }
+  absl::string_view scheme() const override { return "unix"; }
 };
 
 class UnixAbstractResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "unix-abstract"; }
+
   bool IsValidUri(const URI& uri) const override {
     return ParseUri(uri, grpc_parse_unix_abstract, nullptr);
   }
@@ -170,26 +175,22 @@ class UnixAbstractResolverFactory : public ResolverFactory {
   std::string GetDefaultAuthority(const URI& /*uri*/) const override {
     return "localhost";
   }
-
-  const char* scheme() const override { return "unix-abstract"; }
 };
 #endif  // GRPC_HAVE_UNIX_SOCKET
 
 }  // namespace
 
-}  // namespace grpc_core
-
-void grpc_resolver_sockaddr_init() {
-  grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      absl::make_unique<grpc_core::IPv4ResolverFactory>());
-  grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      absl::make_unique<grpc_core::IPv6ResolverFactory>());
+void RegisterSockaddrResolver(CoreConfiguration::Builder* builder) {
+  builder->resolver_registry()->RegisterResolverFactory(
+      absl::make_unique<IPv4ResolverFactory>());
+  builder->resolver_registry()->RegisterResolverFactory(
+      absl::make_unique<IPv6ResolverFactory>());
 #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>());
+  builder->resolver_registry()->RegisterResolverFactory(
+      absl::make_unique<UnixResolverFactory>());
+  builder->resolver_registry()->RegisterResolverFactory(
+      absl::make_unique<UnixAbstractResolverFactory>());
 #endif
 }
 
-void grpc_resolver_sockaddr_shutdown() {}
+}  // namespace grpc_core

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

@@ -18,6 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/random/random.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_replace.h"
@@ -35,9 +36,11 @@
 #include "src/core/ext/xds/xds_route_config.h"
 #include "src/core/ext/xds/xds_routing.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/service_config/service_config_impl.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 
@@ -79,7 +82,8 @@ class XdsResolver : public Resolver {
         args_(grpc_channel_args_copy(args.args)),
         interested_parties_(args.pollset_set),
         uri_(std::move(args.uri)),
-        data_plane_authority_(GetDataPlaneAuthority(*args.args, uri_)) {
+        data_plane_authority_(GetDataPlaneAuthority(*args.args, uri_)),
+        channel_id_(absl::Uniform<uint64_t>(absl::BitGen())) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
       gpr_log(
           GPR_INFO,
@@ -307,6 +311,7 @@ class XdsResolver : public Resolver {
   absl::StatusOr<RefCountedPtr<ServiceConfig>> CreateServiceConfig();
   void GenerateResult();
   void MaybeRemoveUnusedClusters();
+  uint64_t channel_id() const { return channel_id_; }
 
   std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
@@ -316,6 +321,7 @@ class XdsResolver : public Resolver {
   RefCountedPtr<XdsClient> xds_client_;
   std::string lds_resource_name_;
   std::string data_plane_authority_;
+  uint64_t channel_id_;
 
   ListenerWatcher* listener_watcher_ = nullptr;
   // This will not contain the RouteConfiguration, even if it comes with the
@@ -470,17 +476,18 @@ grpc_error_handle XdsResolver::XdsConfigSelector::CreateMethodConfig(
   if (route_action.retry_policy.has_value() &&
       !route_action.retry_policy->retry_on.Empty()) {
     std::vector<std::string> retry_parts;
+    const auto base_interval =
+        route_action.retry_policy->retry_back_off.base_interval.as_timespec();
+    const auto max_interval =
+        route_action.retry_policy->retry_back_off.max_interval.as_timespec();
     retry_parts.push_back(absl::StrFormat(
         "\"retryPolicy\": {\n"
         "      \"maxAttempts\": %d,\n"
         "      \"initialBackoff\": \"%d.%09ds\",\n"
         "      \"maxBackoff\": \"%d.%09ds\",\n"
         "      \"backoffMultiplier\": 2,\n",
-        route_action.retry_policy->num_retries + 1,
-        route_action.retry_policy->retry_back_off.base_interval.seconds,
-        route_action.retry_policy->retry_back_off.base_interval.nanos,
-        route_action.retry_policy->retry_back_off.max_interval.seconds,
-        route_action.retry_policy->retry_back_off.max_interval.nanos));
+        route_action.retry_policy->num_retries + 1, base_interval.tv_sec,
+        base_interval.tv_nsec, max_interval.tv_sec, max_interval.tv_nsec));
     std::vector<std::string> code_parts;
     if (route_action.retry_policy->retry_on.Contains(GRPC_STATUS_CANCELLED)) {
       code_parts.push_back("        \"CANCELLED\"");
@@ -507,12 +514,10 @@ grpc_error_handle XdsResolver::XdsConfigSelector::CreateMethodConfig(
   }
   // Set timeout.
   if (route_action.max_stream_duration.has_value() &&
-      (route_action.max_stream_duration->seconds != 0 ||
-       route_action.max_stream_duration->nanos != 0)) {
-    fields.emplace_back(
-        absl::StrFormat("    \"timeout\": \"%d.%09ds\"",
-                        route_action.max_stream_duration->seconds,
-                        route_action.max_stream_duration->nanos));
+      (route_action.max_stream_duration != Duration::Zero())) {
+    gpr_timespec ts = route_action.max_stream_duration->as_timespec();
+    fields.emplace_back(absl::StrFormat("    \"timeout\": \"%d.%09ds\"",
+                                        ts.tv_sec, ts.tv_nsec));
   }
   // Handle xDS HTTP filters.
   XdsRouting::GeneratePerHttpFilterConfigsResult result =
@@ -541,7 +546,8 @@ grpc_error_handle XdsResolver::XdsConfigSelector::CreateMethodConfig(
         absl::StrJoin(fields, ",\n"),
         "\n  } ]\n"
         "}");
-    *method_config = ServiceConfig::Create(result.args, json.c_str(), &error);
+    *method_config =
+        ServiceConfigImpl::Create(result.args, json.c_str(), &error);
   }
   grpc_channel_args_destroy(result.args);
   return error;
@@ -650,8 +656,7 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
         new_hash = HeaderHashHelper(hash_policy, args.initial_metadata);
         break;
       case XdsRouteConfigResource::Route::RouteAction::HashPolicy::CHANNEL_ID:
-        new_hash =
-            static_cast<uint64_t>(reinterpret_cast<uintptr_t>(resolver_.get()));
+        new_hash = resolver_->channel_id();
         break;
       default:
         GPR_ASSERT(0);
@@ -670,13 +675,7 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
     }
   }
   if (!hash.has_value()) {
-    // If there is no hash, we just choose a random value as a default.
-    // We cannot directly use the result of rand() as the hash value,
-    // since it is a 32-bit number and not a 64-bit number and will
-    // therefore not be evenly distributed.
-    uint32_t upper = rand();
-    uint32_t lower = rand();
-    hash = (static_cast<uint64_t>(upper) << 32) | lower;
+    hash = absl::Uniform<uint64_t>(absl::BitGen());
   }
   CallConfig call_config;
   if (method_config != nullptr) {
@@ -733,8 +732,9 @@ void XdsResolver::StartLocked() {
     std::string name_template =
         authority_config->client_listener_resource_name_template;
     if (name_template.empty()) {
-      name_template = absl::StrCat("xdstp://", uri_.authority(),
-                                   "/envoy.config.listener.v3.Listener/%s");
+      name_template = absl::StrCat(
+          "xdstp://", URI::PercentEncodeAuthority(uri_.authority()),
+          "/envoy.config.listener.v3.Listener/%s");
     }
     lds_resource_name_ = absl::StrReplaceAll(
         name_template,
@@ -877,7 +877,8 @@ void XdsResolver::OnError(grpc_error_handle error) {
   Result result;
   grpc_arg new_arg = xds_client_->MakeChannelArg();
   result.args = grpc_channel_args_copy_and_add(args_, &new_arg, 1);
-  result.service_config = grpc_error_to_absl_status(error);
+  result.service_config = absl::UnavailableError(absl::StrCat(
+      "error obtaining xDS resources: ", grpc_error_std_string(error)));
   result_handler_->ReportResult(std::move(result));
   GRPC_ERROR_UNREF(error);
 }
@@ -893,7 +894,7 @@ void XdsResolver::OnResourceDoesNotExist() {
   current_virtual_host_.routes.clear();
   Result result;
   grpc_error_handle error = GRPC_ERROR_NONE;
-  result.service_config = ServiceConfig::Create(args_, "{}", &error);
+  result.service_config = ServiceConfigImpl::Create(args_, "{}", &error);
   GPR_ASSERT(*result.service_config != nullptr);
   result.args = grpc_channel_args_copy(args_);
   result_handler_->ReportResult(std::move(result));
@@ -928,7 +929,7 @@ XdsResolver::CreateServiceConfig() {
   std::string json = absl::StrJoin(config_parts, "");
   grpc_error_handle error = GRPC_ERROR_NONE;
   absl::StatusOr<RefCountedPtr<ServiceConfig>> result =
-      ServiceConfig::Create(args_, json.c_str(), &error);
+      ServiceConfigImpl::Create(args_, json.c_str(), &error);
   if (error != GRPC_ERROR_NONE) {
     result = grpc_error_to_absl_status(error);
     GRPC_ERROR_UNREF(error);
@@ -952,7 +953,7 @@ void XdsResolver::GenerateResult() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] generated service config: %s", this,
             result.service_config.ok()
-                ? (*result.service_config)->json_string().c_str()
+                ? std::string((*result.service_config)->json_string()).c_str()
                 : result.service_config.status().ToString().c_str());
   }
   grpc_arg new_args[] = {
@@ -987,6 +988,8 @@ void XdsResolver::MaybeRemoveUnusedClusters() {
 
 class XdsResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "xds"; }
+
   bool IsValidUri(const URI& uri) const override {
     if (uri.path().empty() || uri.path().back() == '/') {
       gpr_log(GPR_ERROR,
@@ -1004,17 +1007,13 @@ class XdsResolverFactory : public ResolverFactory {
     if (!IsValidUri(args.uri)) return nullptr;
     return MakeOrphanable<XdsResolver>(std::move(args));
   }
-
-  const char* scheme() const override { return "xds"; }
 };
 
 }  // namespace
 
-}  // namespace grpc_core
-
-void grpc_resolver_xds_init() {
-  grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      absl::make_unique<grpc_core::XdsResolverFactory>());
+void RegisterXdsResolver(CoreConfiguration::Builder* builder) {
+  builder->resolver_registry()->RegisterResolverFactory(
+      absl::make_unique<XdsResolverFactory>());
 }
 
-void grpc_resolver_xds_shutdown() {}
+}  // namespace grpc_core

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

@@ -45,18 +45,15 @@
 namespace grpc_core {
 namespace internal {
 
-namespace {
-size_t g_client_channel_service_config_parser_index;
-}
-
 size_t ClientChannelServiceConfigParser::ParserIndex() {
-  return g_client_channel_service_config_parser_index;
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
 }
 
-void ClientChannelServiceConfigParser::Register() {
-  g_client_channel_service_config_parser_index =
-      ServiceConfigParser::RegisterParser(
-          absl::make_unique<ClientChannelServiceConfigParser>());
+void ClientChannelServiceConfigParser::Register(
+    CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      absl::make_unique<ClientChannelServiceConfigParser>());
 }
 
 namespace {
@@ -173,7 +170,7 @@ ClientChannelServiceConfigParser::ParsePerMethodParams(
     }
   }
   // Parse timeout.
-  grpc_millis timeout = 0;
+  Duration timeout;
   ParseJsonObjectFieldAsDuration(json.object_value(), "timeout", &timeout,
                                  &error_list, false);
   // Return result.

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

@@ -24,9 +24,10 @@
 #include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/exec_ctx.h"  // for grpc_millis
+#include "src/core/lib/iomgr/exec_ctx.h"  // for grpc_core::Timestamp
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/service_config/service_config_parser.h"
@@ -66,21 +67,23 @@ class ClientChannelGlobalParsedConfig
 class ClientChannelMethodParsedConfig
     : public ServiceConfigParser::ParsedConfig {
  public:
-  ClientChannelMethodParsedConfig(grpc_millis timeout,
+  ClientChannelMethodParsedConfig(Duration timeout,
                                   const absl::optional<bool>& wait_for_ready)
       : timeout_(timeout), wait_for_ready_(wait_for_ready) {}
 
-  grpc_millis timeout() const { return timeout_; }
+  Duration timeout() const { return timeout_; }
 
   absl::optional<bool> wait_for_ready() const { return wait_for_ready_; }
 
  private:
-  grpc_millis timeout_ = 0;
+  Duration timeout_;
   absl::optional<bool> wait_for_ready_;
 };
 
 class ClientChannelServiceConfigParser : public ServiceConfigParser::Parser {
  public:
+  absl::string_view name() const override { return parser_name(); }
+
   std::unique_ptr<ServiceConfigParser::ParsedConfig> ParseGlobalParams(
       const grpc_channel_args* /*args*/, const Json& json,
       grpc_error_handle* error) override;
@@ -90,7 +93,10 @@ class ClientChannelServiceConfigParser : public ServiceConfigParser::Parser {
       grpc_error_handle* error) override;
 
   static size_t ParserIndex();
-  static void Register();
+  static void Register(CoreConfiguration::Builder* builder);
+
+ private:
+  static absl::string_view parser_name() { return "client_channel"; }
 };
 
 }  // namespace internal