grpc 1.30.2 → 1.31.0.pre1

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

@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -65,22 +66,22 @@ class RegistryState {
   // If \a default_prefix_ needs to be prepended, sets \a canonical_target
   // to the canonical target string.
   ResolverFactory* FindResolverFactory(const char* target, grpc_uri** uri,
-                                       char** canonical_target) const {
+                                       std::string* canonical_target) const {
     GPR_ASSERT(uri != nullptr);
     *uri = grpc_uri_parse(target, 1);
     ResolverFactory* factory =
         *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
     if (factory == nullptr) {
       grpc_uri_destroy(*uri);
-      gpr_asprintf(canonical_target, "%s%s", default_prefix_.get(), target);
-      *uri = grpc_uri_parse(*canonical_target, 1);
+      *canonical_target = absl::StrCat(default_prefix_.get(), target);
+      *uri = grpc_uri_parse(canonical_target->c_str(), 1);
       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, 0));
+        grpc_uri_destroy(grpc_uri_parse(canonical_target->c_str(), 0));
         gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
-                *canonical_target);
+                canonical_target->c_str());
       }
     }
     return factory;
@@ -136,12 +137,11 @@ ResolverFactory* ResolverRegistry::LookupResolverFactory(const char* scheme) {
 
 bool ResolverRegistry::IsValidTarget(const char* target) {
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   bool result = factory == nullptr ? false : factory->IsValidUri(uri);
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return result;
 }
 
@@ -152,7 +152,7 @@ OrphanablePtr ResolverRegistry::CreateResolver(
     std::unique_ptr<Resolver::ResultHandler> result_handler) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   ResolverArgs resolver_args;
@@ -165,7 +165,6 @@ OrphanablePtr ResolverRegistry::CreateResolver(
       factory == nullptr ? nullptr
                          : factory->CreateResolver(std::move(resolver_args));
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return resolver;
 }
 
@@ -173,13 +172,12 @@ grpc_core::UniquePtr ResolverRegistry::GetDefaultAuthority(
     const char* target) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   grpc_core::UniquePtr<char> authority =
       factory == nullptr ? nullptr : factory->GetDefaultAuthority(uri);
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return authority;
 }
 
@@ -187,11 +185,12 @@ grpc_core::UniquePtr ResolverRegistry::AddDefaultPrefixIfNeeded(
     const char* target) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   g_state->FindResolverFactory(target, &uri, &canonical_target);
   grpc_uri_destroy(uri);
-  return grpc_core::UniquePtr<char>(
-      canonical_target == nullptr ? gpr_strdup(target) : canonical_target);
+  return grpc_core::UniquePtr<char>(canonical_target.empty()
+                                        ? gpr_strdup(target)
+                                        : gpr_strdup(canonical_target.c_str()));
 }
 
 }  // namespace grpc_core

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

@@ -24,6 +24,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
 #include <grpc/support/alloc.h>
@@ -353,13 +354,11 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const Json& json,
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "field:loadBalancingPolicy error:Unknown lb policy"));
       } else if (requires_config) {
-        char* error_msg;
-        gpr_asprintf(&error_msg,
-                     "field:loadBalancingPolicy error:%s requires a config. "
-                     "Please use loadBalancingConfig instead.",
-                     lb_policy_name.c_str());
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg));
-        gpr_free(error_msg);
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+            absl::StrCat("field:loadBalancingPolicy error:", lb_policy_name,
+                         " requires a config. Please use loadBalancingConfig "
+                         "instead.")
+                .c_str()));
       }
     }
   }

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

@@ -145,14 +145,12 @@ class ResolvingLoadBalancingPolicy::ResolvingControlHelper
 
 ResolvingLoadBalancingPolicy::ResolvingLoadBalancingPolicy(
     Args args, TraceFlag* tracer, grpc_core::UniquePtr<char> target_uri,
-    ProcessResolverResultCallback process_resolver_result,
-    void* process_resolver_result_user_data)
+    ChannelConfigHelper* helper)
     : LoadBalancingPolicy(std::move(args)),
       tracer_(tracer),
       target_uri_(std::move(target_uri)),
-      process_resolver_result_(process_resolver_result),
-      process_resolver_result_user_data_(process_resolver_result_user_data) {
-  GPR_ASSERT(process_resolver_result != nullptr);
+      helper_(helper) {
+  GPR_ASSERT(helper_ != nullptr);
   resolver_ = ResolverRegistry::CreateResolver(
       target_uri_.get(), args.args, interested_parties(), work_serializer(),
       absl::make_unique<ResolverResultHandler>(Ref()));
@@ -214,6 +212,7 @@ void ResolvingLoadBalancingPolicy::OnResolverError(grpc_error* error) {
   if (lb_policy_ == nullptr) {
     grpc_error* state_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "Resolver transient failure", &error, 1);
+    helper_->ResolverTransientFailure(GRPC_ERROR_REF(state_error));
     channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE,
         absl::make_unique<TransientFailurePicker>(state_error));
@@ -304,45 +303,51 @@ void ResolvingLoadBalancingPolicy::OnResolverResultChangedLocked(
   TraceStringVector trace_strings;
   const bool resolution_contains_addresses = result.addresses.size() > 0;
   // Process the resolver result.
-  RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config;
-  bool service_config_changed = false;
-  std::string service_config_error_string;
-  if (process_resolver_result_ != nullptr) {
-    grpc_error* service_config_error = GRPC_ERROR_NONE;
-    bool no_valid_service_config = false;
-    service_config_changed = process_resolver_result_(
-        process_resolver_result_user_data_, result, &lb_policy_config,
-        &service_config_error, &no_valid_service_config);
-    if (service_config_error != GRPC_ERROR_NONE) {
-      service_config_error_string = grpc_error_string(service_config_error);
-      if (no_valid_service_config) {
+  ChannelConfigHelper::ApplyServiceConfigResult service_config_result;
+  if (helper_ != nullptr) {
+    service_config_result = helper_->ApplyServiceConfig(result);
+    if (service_config_result.service_config_error != GRPC_ERROR_NONE) {
+      if (service_config_result.no_valid_service_config) {
         // We received an invalid service config and we don't have a
         // fallback service config.
-        OnResolverError(service_config_error);
-      } else {
-        GRPC_ERROR_UNREF(service_config_error);
+        OnResolverError(service_config_result.service_config_error);
+        service_config_result.service_config_error = GRPC_ERROR_NONE;
       }
     }
   } else {
-    lb_policy_config = child_lb_config_;
+    service_config_result.lb_policy_config = child_lb_config_;
   }
-  if (lb_policy_config != nullptr) {
-    // Create or update LB policy, as needed.
-    CreateOrUpdateLbPolicyLocked(std::move(lb_policy_config),
-                                 std::move(result));
+  // Before we send the args to the LB policy, grab the ConfigSelector for
+  // later use.
+  RefCountedPtr<ConfigSelector> config_selector =
+      ConfigSelector::GetFromChannelArgs(*result.args);
+  // Create or update LB policy, as needed.
+  if (service_config_result.lb_policy_config != nullptr) {
+    CreateOrUpdateLbPolicyLocked(
+        std::move(service_config_result.lb_policy_config), std::move(result));
+  }
+  // Apply ConfigSelector to channel.
+  // This needs to happen after the LB policy has been updated, since
+  // the ConfigSelector may need the LB policy to know about new
+  // destinations before it can send RPCs to those destinations.
+  if (helper_ != nullptr) {
+    helper_->ApplyConfigSelector(service_config_result.service_config_changed,
+                                 std::move(config_selector));
   }
   // Add channel trace event.
-  if (service_config_changed) {
+  if (service_config_result.service_config_changed) {
     // TODO(ncteisen): might be worth somehow including a snippet of the
     // config in the trace, at the risk of bloating the trace logs.
     trace_strings.push_back("Service config changed");
   }
-  if (!service_config_error_string.empty()) {
-    trace_strings.push_back(service_config_error_string.c_str());
+  if (service_config_result.service_config_error != GRPC_ERROR_NONE) {
+    trace_strings.push_back(
+        grpc_error_string(service_config_result.service_config_error));
   }
   MaybeAddTraceMessagesForAddressChangesLocked(resolution_contains_addresses,
                                                &trace_strings);
   ConcatenateAndAddChannelTraceLocked(trace_strings);
+  GRPC_ERROR_UNREF(service_config_result.service_config_error);
 }
 
 }  // namespace grpc_core

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

@@ -23,6 +23,7 @@
 
 #include "absl/container/inlined_vector.h"
 
+#include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/resolver.h"
@@ -52,22 +53,39 @@ namespace grpc_core {
 // child LB policy and config to use.
 class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
  public:
-  // Synchronous callback that takes the resolver result and sets
-  // lb_policy_config to point to the right data.
-  // Returns true if the service config has changed since the last result.
-  // If the returned no_valid_service_config is true, that means that we
-  // don't have a valid service config to use, and we should set the channel
-  // to be in TRANSIENT_FAILURE.
-  typedef bool (*ProcessResolverResultCallback)(
-      void* user_data, const Resolver::Result& result,
-      RefCountedPtr<LoadBalancingPolicy::Config>* lb_policy_config,
-      grpc_error** service_config_error, bool* no_valid_service_config);
-  // If error is set when this returns, then construction failed, and
-  // the caller may not use the new object.
-  ResolvingLoadBalancingPolicy(
-      Args args, TraceFlag* tracer, grpc_core::UniquePtr<char> target_uri,
-      ProcessResolverResultCallback process_resolver_result,
-      void* process_resolver_result_user_data);
+  class ChannelConfigHelper {
+   public:
+    struct ApplyServiceConfigResult {
+      // Set to true if the service config has changed since the last result.
+      bool service_config_changed = false;
+      // Set to true if we don't have a valid service config to use.
+      // This tells the ResolvingLoadBalancingPolicy to put the channel
+      // into TRANSIENT_FAILURE.
+      bool no_valid_service_config = false;
+      // A service config parsing error occurred.
+      grpc_error* service_config_error = GRPC_ERROR_NONE;
+      // The LB policy config to use.
+      RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config;
+    };
+
+    virtual ~ChannelConfigHelper() = default;
+
+    // Applies the service config to the channel.
+    virtual ApplyServiceConfigResult ApplyServiceConfig(
+        const Resolver::Result& result) = 0;
+
+    // Applies the ConfigSelector to the channel.
+    virtual void ApplyConfigSelector(
+        bool service_config_changed,
+        RefCountedPtr<ConfigSelector> config_selector) = 0;
+
+    // Indicates a resolver transient failure.
+    virtual void ResolverTransientFailure(grpc_error* error) = 0;
+  };
+
+  ResolvingLoadBalancingPolicy(Args args, TraceFlag* tracer,
+                               grpc_core::UniquePtr<char> target_uri,
+                               ChannelConfigHelper* helper);
 
   virtual const char* name() const override { return "resolving_lb"; }
 
@@ -105,15 +123,16 @@ class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
   // Passed in from caller at construction time.
   TraceFlag* tracer_;
   grpc_core::UniquePtr<char> target_uri_;
-  ProcessResolverResultCallback process_resolver_result_ = nullptr;
-  void* process_resolver_result_user_data_ = nullptr;
-  grpc_core::UniquePtr<char> child_policy_name_;
-  RefCountedPtr<LoadBalancingPolicy::Config> child_lb_config_;
+  ChannelConfigHelper* helper_;
 
   // Resolver and associated state.
   OrphanablePtr<Resolver> resolver_;
   bool previous_resolution_contained_addresses_ = false;
 
+  // Determined by resolver results.
+  grpc_core::UniquePtr<char> child_policy_name_;
+  RefCountedPtr<LoadBalancingPolicy::Config> child_lb_config_;
+
   // Child LB policy.
   OrphanablePtr<LoadBalancingPolicy> lb_policy_;
 };

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

@@ -0,0 +1,142 @@
+//
+// Copyright 2020 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.
+//
+
+// This filter reads GRPC_ARG_SERVICE_CONFIG and populates ServiceConfigCallData
+// in the call context per call for direct channels.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/service_config_call_data.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/surface/channel_init.h"
+
+namespace grpc_core {
+
+namespace {
+
+class ServiceConfigChannelArgChannelData {
+ public:
+  explicit ServiceConfigChannelArgChannelData(
+      const grpc_channel_element_args* args) {
+    const char* service_config_str = grpc_channel_args_find_string(
+        args->channel_args, GRPC_ARG_SERVICE_CONFIG);
+    if (service_config_str != nullptr) {
+      grpc_error* service_config_error = GRPC_ERROR_NONE;
+      auto service_config =
+          ServiceConfig::Create(service_config_str, &service_config_error);
+      if (service_config_error == GRPC_ERROR_NONE) {
+        service_config_ = std::move(service_config);
+      } else {
+        gpr_log(GPR_ERROR, "%s", grpc_error_string(service_config_error));
+      }
+      GRPC_ERROR_UNREF(service_config_error);
+    }
+  }
+
+  RefCountedPtr<ServiceConfig> service_config() const {
+    return service_config_;
+  }
+
+ private:
+  RefCountedPtr<ServiceConfig> service_config_;
+};
+
+class ServiceConfigChannelArgCallData {
+ public:
+  ServiceConfigChannelArgCallData(grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
+    ServiceConfigChannelArgChannelData* chand =
+        static_cast<ServiceConfigChannelArgChannelData*>(elem->channel_data);
+    RefCountedPtr<ServiceConfig> service_config = chand->service_config();
+    if (service_config != nullptr) {
+      GPR_DEBUG_ASSERT(args->context != nullptr);
+      const auto* method_params_vector =
+          service_config->GetMethodParsedConfigVector(args->path);
+      args->arena->New<ServiceConfigCallData>(
+          std::move(service_config), method_params_vector, args->context);
+    }
+  }
+};
+
+grpc_error* ServiceConfigChannelArgInitCallElem(
+    grpc_call_element* elem, const grpc_call_element_args* args) {
+  ServiceConfigChannelArgCallData* calld =
+      static_cast<ServiceConfigChannelArgCallData*>(elem->call_data);
+  new (calld) ServiceConfigChannelArgCallData(elem, args);
+  return GRPC_ERROR_NONE;
+}
+
+void ServiceConfigChannelArgDestroyCallElem(
+    grpc_call_element* elem, const grpc_call_final_info* /* final_info */,
+    grpc_closure* /* then_schedule_closure */) {
+  ServiceConfigChannelArgCallData* calld =
+      static_cast<ServiceConfigChannelArgCallData*>(elem->call_data);
+  calld->~ServiceConfigChannelArgCallData();
+}
+
+grpc_error* ServiceConfigChannelArgInitChannelElem(
+    grpc_channel_element* elem, grpc_channel_element_args* args) {
+  ServiceConfigChannelArgChannelData* chand =
+      static_cast<ServiceConfigChannelArgChannelData*>(elem->channel_data);
+  new (chand) ServiceConfigChannelArgChannelData(args);
+  return GRPC_ERROR_NONE;
+}
+
+void ServiceConfigChannelArgDestroyChannelElem(grpc_channel_element* elem) {
+  ServiceConfigChannelArgChannelData* chand =
+      static_cast<ServiceConfigChannelArgChannelData*>(elem->channel_data);
+  chand->~ServiceConfigChannelArgChannelData();
+}
+
+const grpc_channel_filter ServiceConfigChannelArgFilter = {
+    grpc_call_next_op,
+    grpc_channel_next_op,
+    sizeof(ServiceConfigChannelArgCallData),
+    ServiceConfigChannelArgInitCallElem,
+    grpc_call_stack_ignore_set_pollset_or_pollset_set,
+    ServiceConfigChannelArgDestroyCallElem,
+    sizeof(ServiceConfigChannelArgChannelData),
+    ServiceConfigChannelArgInitChannelElem,
+    ServiceConfigChannelArgDestroyChannelElem,
+    grpc_channel_next_get_info,
+    "service_config_channel_arg"};
+
+bool maybe_add_service_config_channel_arg_filter(
+    grpc_channel_stack_builder* builder, void* /* arg */) {
+  const grpc_channel_args* channel_args =
+      grpc_channel_stack_builder_get_channel_arguments(builder);
+  if (grpc_channel_args_want_minimal_stack(channel_args) ||
+      grpc_channel_args_find_string(channel_args, GRPC_ARG_SERVICE_CONFIG) ==
+          nullptr) {
+    return true;
+  }
+  return grpc_channel_stack_builder_prepend_filter(
+      builder, &ServiceConfigChannelArgFilter, nullptr, nullptr);
+}
+
+}  // namespace
+
+}  // namespace grpc_core
+
+void grpc_service_config_channel_arg_filter_init(void) {
+  grpc_channel_init_register_stage(
+      GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+      grpc_core::maybe_add_service_config_channel_arg_filter, nullptr);
+}
+
+void grpc_service_config_channel_arg_filter_shutdown(void) {}

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

@@ -872,7 +872,7 @@ grpc_arg Subchannel::CreateSubchannelAddressArg(
     const grpc_resolved_address* addr) {
   return grpc_channel_arg_string_create(
       (char*)GRPC_ARG_SUBCHANNEL_ADDRESS,
-      addr->len > 0 ? grpc_sockaddr_to_uri(addr) : gpr_strdup(""));
+      gpr_strdup(addr->len > 0 ? grpc_sockaddr_to_uri(addr).c_str() : ""));
 }
 
 const char* Subchannel::GetUriFromSubchannelAddressArg(