grpc 1.28.0 → 1.31.0.pre2

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

@@ -35,6 +35,7 @@
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/filters/client_channel/resolver_result_parsing.h"
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
+#include "src/core/ext/filters/client_channel/service_config_parser.h"
 #include "src/core/lib/surface/channel_init.h"
 
 static bool append_filter(grpc_channel_stack_builder* builder, void* arg) {
@@ -43,7 +44,7 @@ static bool append_filter(grpc_channel_stack_builder* builder, void* arg) {
 }
 
 void grpc_client_channel_init(void) {
-  grpc_core::ServiceConfig::Init();
+  grpc_core::ServiceConfigParser::Init();
   grpc_core::internal::ClientChannelServiceConfigParser::Register();
   grpc_core::LoadBalancingPolicyRegistry::Builder::InitRegistry();
   grpc_core::ResolverRegistry::Builder::InitRegistry();
@@ -65,5 +66,5 @@ void grpc_client_channel_shutdown(void) {
   grpc_core::internal::ServerRetryThrottleMap::Shutdown();
   grpc_core::ResolverRegistry::Builder::ShutdownRegistry();
   grpc_core::LoadBalancingPolicyRegistry::Builder::ShutdownRegistry();
-  grpc_core::ServiceConfig::Shutdown();
+  grpc_core::ServiceConfigParser::Shutdown();
 }

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

@@ -0,0 +1,62 @@
+//
+// 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/config_selector.h"
+
+#include "src/core/lib/channel/channel_args.h"
+
+// Channel arg key for ConfigSelector.
+#define GRPC_ARG_CONFIG_SELECTOR "grpc.internal.config_selector"
+
+namespace grpc_core {
+
+namespace {
+
+void* ConfigSelectorArgCopy(void* p) {
+  ConfigSelector* config_selector = static_cast<ConfigSelector*>(p);
+  config_selector->Ref().release();
+  return p;
+}
+
+void ConfigSelectorArgDestroy(void* p) {
+  ConfigSelector* config_selector = static_cast<ConfigSelector*>(p);
+  config_selector->Unref();
+}
+
+int ConfigSelectorArgCmp(void* p, void* q) { return GPR_ICMP(p, q); }
+
+const grpc_arg_pointer_vtable kChannelArgVtable = {
+    ConfigSelectorArgCopy, ConfigSelectorArgDestroy, ConfigSelectorArgCmp};
+
+}  // namespace
+
+grpc_arg ConfigSelector::MakeChannelArg() const {
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_CONFIG_SELECTOR),
+      const_cast<ConfigSelector*>(this), &kChannelArgVtable);
+}
+
+RefCountedPtr<ConfigSelector> ConfigSelector::GetFromChannelArgs(
+    const grpc_channel_args& args) {
+  ConfigSelector* config_selector =
+      grpc_channel_args_find_pointer<ConfigSelector>(&args,
+                                                     GRPC_ARG_CONFIG_SELECTOR);
+  return config_selector != nullptr ? config_selector->Ref() : nullptr;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,93 @@
+//
+// 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.
+//
+
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CONFIG_SELECTOR_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CONFIG_SELECTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <map>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/slice.h>
+
+#include "src/core/ext/filters/client_channel/service_config.h"
+#include "src/core/ext/filters/client_channel/service_config_parser.h"
+#include "src/core/lib/gprpp/arena.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/transport/metadata_batch.h"
+
+namespace grpc_core {
+
+// Internal API used to allow resolver implementations to override
+// MethodConfig and provide input to LB policies on a per-call basis.
+class ConfigSelector : public RefCounted<ConfigSelector> {
+ public:
+  struct GetCallConfigArgs {
+    grpc_slice* path;
+    grpc_metadata_batch* initial_metadata;
+    Arena* arena;
+  };
+
+  struct CallConfig {
+    // Can be set to indicate the call should be failed.
+    grpc_error* error = GRPC_ERROR_NONE;
+    // The per-method parsed configs that will be passed to
+    // ServiceConfigCallData.
+    const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
+    // Call attributes that will be accessible to LB policy implementations.
+    std::map<const char*, absl::string_view> call_attributes;
+    // A callback that, if set, will be invoked when the call is
+    // committed (i.e., when we know that we will never again need to
+    // ask the picker for a subchannel for this call).
+    std::function<void()> on_call_committed;
+  };
+
+  virtual ~ConfigSelector() = default;
+
+  virtual CallConfig GetCallConfig(GetCallConfigArgs args) = 0;
+
+  grpc_arg MakeChannelArg() const;
+  static RefCountedPtr<ConfigSelector> GetFromChannelArgs(
+      const grpc_channel_args& args);
+};
+
+// Default ConfigSelector that gets the MethodConfig from the service config.
+class DefaultConfigSelector : public ConfigSelector {
+ public:
+  explicit DefaultConfigSelector(RefCountedPtr<ServiceConfig> service_config)
+      : service_config_(std::move(service_config)) {}
+
+  CallConfig GetCallConfig(GetCallConfigArgs args) override {
+    CallConfig call_config;
+    if (service_config_ != nullptr) {
+      call_config.method_configs =
+          service_config_->GetMethodParsedConfigVector(*args.path);
+    }
+    return call_config;
+  }
+
+ private:
+  RefCountedPtr<ServiceConfig> service_config_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CONFIG_SELECTOR_H */

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

@@ -24,6 +24,9 @@
 
 namespace grpc_core {
 
+#define GRPC_REGISTER_SUBCHANNEL_CALM_DOWN_AFTER_ATTEMPTS 100
+#define GRPC_REGISTER_SUBCHANNEL_CALM_DOWN_MICROS 10
+
 GlobalSubchannelPool::GlobalSubchannelPool() {
   subchannel_map_ = grpc_avl_create(&subchannel_avl_vtable_);
   gpr_mu_init(&mu_);
@@ -58,7 +61,7 @@ Subchannel* GlobalSubchannelPool::RegisterSubchannel(SubchannelKey* key,
                                                      Subchannel* constructed) {
   Subchannel* c = nullptr;
   // Compare and swap (CAS) loop:
-  while (c == nullptr) {
+  for (int attempt_count = 0; c == nullptr; attempt_count++) {
     // Ref the shared map to have a local copy.
     gpr_mu_lock(&mu_);
     grpc_avl old_map = grpc_avl_ref(subchannel_map_, nullptr);
@@ -72,7 +75,26 @@ Subchannel* GlobalSubchannelPool::RegisterSubchannel(SubchannelKey* key,
         GRPC_SUBCHANNEL_UNREF(constructed,
                               "subchannel_register+found_existing");
         // Exit the CAS loop without modifying the shared map.
-      }  // Else, reuse failed, so retry CAS loop.
+      } else {
+        // Reuse of the subchannel failed, so retry CAS loop
+        if (attempt_count >=
+            GRPC_REGISTER_SUBCHANNEL_CALM_DOWN_AFTER_ATTEMPTS) {
+          // GRPC_SUBCHANNEL_REF_FROM_WEAK_REF returning nullptr means that the
+          // subchannel we got is no longer valid and it's going to be removed
+          // from the AVL tree soon. Spinning here excesively here can actually
+          // prevent another thread from removing the subchannel, basically
+          // resulting in a live lock. See b/157516542 for more details.
+          // TODO(jtattermusch): the entire ref-counting mechanism for
+          // subchannels should be overhaulded, but the current workaround
+          // is fine for short-term.
+          // TODO(jtattermusch): gpr does not support thread yield operation,
+          // so a very short wait is the best we can do.
+          gpr_sleep_until(gpr_time_add(
+              gpr_now(GPR_CLOCK_REALTIME),
+              gpr_time_from_micros(GRPC_REGISTER_SUBCHANNEL_CALM_DOWN_MICROS,
+                                   GPR_TIMESPAN)));
+        }
+      }
     } else {
       // There hasn't been such subchannel. Add one.
       // Note that we should ref the old map first because grpc_avl_add() will

data/src/core/ext/filters/client_channel/health/health_check_client.cc

@@ -23,6 +23,8 @@
 
 #include "src/core/ext/filters/client_channel/health/health_check_client.h"
 
+#include "upb/upb.hpp"
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -125,8 +127,7 @@ void HealthCheckClient::StartCallLocked() {
   call_state_->StartCall();
 }
 
-void HealthCheckClient::StartRetryTimer() {
-  MutexLock lock(&mu_);
+void HealthCheckClient::StartRetryTimerLocked() {
   SetHealthStatusLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
                         "health check call failed; will retry after backoff");
   grpc_millis next_try = retry_backoff_.NextAttemptTime();
@@ -297,14 +298,7 @@ void HealthCheckClient::CallState::StartCall() {
             "checking call on subchannel (%s); will retry",
             health_check_client_.get(), this, grpc_error_string(error));
     GRPC_ERROR_UNREF(error);
-    // Schedule instead of running directly, since we must not be
-    // holding health_check_client_->mu_ when CallEnded() is called.
-    call_->Ref(DEBUG_LOCATION, "call_end_closure").release();
-    ExecCtx::Run(
-        DEBUG_LOCATION,
-        GRPC_CLOSURE_INIT(&batch_.handler_private.closure, CallEndedRetry, this,
-                          grpc_schedule_on_exec_ctx),
-        GRPC_ERROR_NONE);
+    CallEndedLocked(/*retry=*/true);
     return;
   }
   // Initialize payload and batch.
@@ -582,18 +576,11 @@ void HealthCheckClient::CallState::RecvTrailingMetadataReady(
                                                 kErrorMessage);
     retry = false;
   }
-  self->CallEnded(retry);
-}
-
-void HealthCheckClient::CallState::CallEndedRetry(void* arg,
-                                                  grpc_error* /*error*/) {
-  HealthCheckClient::CallState* self =
-      static_cast<HealthCheckClient::CallState*>(arg);
-  self->CallEnded(true /* retry */);
-  self->call_->Unref(DEBUG_LOCATION, "call_end_closure");
+  MutexLock lock(&self->health_check_client_->mu_);
+  self->CallEndedLocked(retry);
 }
 
-void HealthCheckClient::CallState::CallEnded(bool retry) {
+void HealthCheckClient::CallState::CallEndedLocked(bool retry) {
   // If this CallState is still in use, this call ended because of a failure,
   // so we need to stop using it and optionally create a new one.
   // Otherwise, we have deliberately ended this call, and no further action
@@ -606,10 +593,10 @@ void HealthCheckClient::CallState::CallEnded(bool retry) {
         // If the call fails after we've gotten a successful response, reset
         // the backoff and restart the call immediately.
         health_check_client_->retry_backoff_.Reset();
-        health_check_client_->StartCall();
+        health_check_client_->StartCallLocked();
       } else {
         // If the call failed without receiving any messages, retry later.
-        health_check_client_->StartRetryTimer();
+        health_check_client_->StartRetryTimerLocked();
       }
     }
   }

data/src/core/ext/filters/client_channel/health/health_check_client.h

@@ -72,8 +72,8 @@ class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
     void StartBatch(grpc_transport_stream_op_batch* batch);
     static void StartBatchInCallCombiner(void* arg, grpc_error* error);
 
-    static void CallEndedRetry(void* arg, grpc_error* error);
-    void CallEnded(bool retry);
+    // Requires holding health_check_client_->mu_.
+    void CallEndedLocked(bool retry);
 
     static void OnComplete(void* arg, grpc_error* error);
     static void RecvInitialMetadataReady(void* arg, grpc_error* error);
@@ -143,7 +143,7 @@ class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
   void StartCall();
   void StartCallLocked();  // Requires holding mu_.
 
-  void StartRetryTimer();
+  void StartRetryTimerLocked();  // Requires holding mu_.
   static void OnRetryTimer(void* arg, grpc_error* error);
 
   void SetHealthStatus(grpc_connectivity_state state, const char* reason);

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

@@ -22,6 +22,8 @@
 
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -241,11 +243,10 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error* error) {
   // Make sure we got a 2xx response.
   if (handshaker->http_response_.status < 200 ||
       handshaker->http_response_.status >= 300) {
-    char* msg;
-    gpr_asprintf(&msg, "HTTP proxy returned response code %d",
-                 handshaker->http_response_.status);
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-    gpr_free(msg);
+    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("HTTP proxy returned response code ",
+                     handshaker->http_response_.status)
+            .c_str());
     handshaker->HandshakeFailedLocked(error);
     goto done;
   }

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

@@ -23,6 +23,8 @@
 #include <stdbool.h>
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -45,17 +47,23 @@ namespace {
  * credentials if present in the 'http_proxy' env var, otherwise leaves it
  * unchanged. It is caller's responsibility to gpr_free user_cred.
  */
-char* GetHttpProxyServer(char** user_cred) {
+char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
   GPR_ASSERT(user_cred != nullptr);
   grpc_uri* uri = nullptr;
   char* proxy_name = nullptr;
   char** authority_strs = nullptr;
   size_t authority_nstrs;
-  /* Prefer using 'grpc_proxy'. Fallback on 'http_proxy' if it is not set.
-   * Also prefer using 'https_proxy' with fallback on 'http_proxy'. The
-   * fallback behavior can be removed if there's a demand for it.
+  /* We check the following places to determine the HTTP proxy to use, stopping
+   * at the first one that is set:
+   * 1. GRPC_ARG_HTTP_PROXY channel arg
+   * 2. grpc_proxy environment variable
+   * 3. https_proxy environment variable
+   * 4. http_proxy environment variable
+   * If none of the above are set, then no HTTP proxy will be used.
    */
-  char* uri_str = gpr_getenv("grpc_proxy");
+  char* uri_str =
+      gpr_strdup(grpc_channel_args_find_string(args, GRPC_ARG_HTTP_PROXY));
+  if (uri_str == nullptr) uri_str = gpr_getenv("grpc_proxy");
   if (uri_str == nullptr) uri_str = gpr_getenv("https_proxy");
   if (uri_str == nullptr) uri_str = gpr_getenv("http_proxy");
   if (uri_str == nullptr) return nullptr;
@@ -103,7 +111,7 @@ class HttpProxyMapper : public ProxyMapperInterface {
       return false;
     }
     char* user_cred = nullptr;
-    *name_to_resolve = GetHttpProxyServer(&user_cred);
+    *name_to_resolve = GetHttpProxyServer(args, &user_cred);
     if (*name_to_resolve == nullptr) return false;
     char* no_proxy_str = nullptr;
     grpc_uri* uri = grpc_uri_parse(server_uri, false /* suppress_errors */);
@@ -125,8 +133,8 @@ class HttpProxyMapper : public ProxyMapperInterface {
     if (no_proxy_str != nullptr) {
       static const char* NO_PROXY_SEPARATOR = ",";
       bool use_proxy = true;
-      grpc_core::UniquePtr<char> server_host;
-      grpc_core::UniquePtr<char> server_port;
+      std::string server_host;
+      std::string server_port;
       if (!grpc_core::SplitHostPort(
               uri->path[0] == '/' ? uri->path + 1 : uri->path, &server_host,
               &server_port)) {
@@ -136,7 +144,7 @@ class HttpProxyMapper : public ProxyMapperInterface {
                 server_uri);
         gpr_free(no_proxy_str);
       } else {
-        size_t uri_len = strlen(server_host.get());
+        size_t uri_len = server_host.size();
         char** no_proxy_hosts;
         size_t num_no_proxy_hosts;
         gpr_string_split(no_proxy_str, NO_PROXY_SEPARATOR, &no_proxy_hosts,
@@ -146,7 +154,8 @@ class HttpProxyMapper : public ProxyMapperInterface {
           size_t no_proxy_len = strlen(no_proxy_entry);
           if (no_proxy_len <= uri_len &&
               gpr_stricmp(no_proxy_entry,
-                          &(server_host.get()[uri_len - no_proxy_len])) == 0) {
+                          &(server_host.c_str()[uri_len - no_proxy_len])) ==
+                  0) {
             gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
                     server_uri);
             use_proxy = false;
@@ -169,13 +178,13 @@ class HttpProxyMapper : public ProxyMapperInterface {
       /* Use base64 encoding for user credentials as stated in RFC 7617 */
       char* encoded_user_cred =
           grpc_base64_encode(user_cred, strlen(user_cred), 0, 0);
-      char* header;
-      gpr_asprintf(&header, "Proxy-Authorization:Basic %s", encoded_user_cred);
+      std::string header =
+          absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred);
       gpr_free(encoded_user_cred);
       args_to_add[1] = grpc_channel_arg_string_create(
-          (char*)GRPC_ARG_HTTP_CONNECT_HEADERS, header);
+          const_cast<char*>(GRPC_ARG_HTTP_CONNECT_HEADERS),
+          const_cast<char*>(header.c_str()));
       *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 2);
-      gpr_free(header);
     } else {
       *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 1);
     }

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

@@ -33,13 +33,12 @@ DebugOnlyTraceFlag grpc_trace_lb_policy_refcount(false, "lb_policy_refcount");
 
 LoadBalancingPolicy::LoadBalancingPolicy(Args args, intptr_t initial_refcount)
     : InternallyRefCounted(&grpc_trace_lb_policy_refcount, initial_refcount),
-      combiner_(GRPC_COMBINER_REF(args.combiner, "lb_policy")),
+      work_serializer_(std::move(args.work_serializer)),
       interested_parties_(grpc_pollset_set_create()),
       channel_control_helper_(std::move(args.channel_control_helper)) {}
 
 LoadBalancingPolicy::~LoadBalancingPolicy() {
   grpc_pollset_set_destroy(interested_parties_);
-  GRPC_COMBINER_UNREF(combiner_, "lb_policy");
 }
 
 void LoadBalancingPolicy::Orphan() {
@@ -57,7 +56,7 @@ LoadBalancingPolicy::UpdateArgs::UpdateArgs(const UpdateArgs& other) {
   args = grpc_channel_args_copy(other.args);
 }
 
-LoadBalancingPolicy::UpdateArgs::UpdateArgs(UpdateArgs&& other) {
+LoadBalancingPolicy::UpdateArgs::UpdateArgs(UpdateArgs&& other) noexcept {
   addresses = std::move(other.addresses);
   config = std::move(other.config);
   // TODO(roth): Use std::move() once channel args is converted to C++.
@@ -75,7 +74,7 @@ LoadBalancingPolicy::UpdateArgs& LoadBalancingPolicy::UpdateArgs::operator=(
 }
 
 LoadBalancingPolicy::UpdateArgs& LoadBalancingPolicy::UpdateArgs::operator=(
-    UpdateArgs&& other) {
+    UpdateArgs&& other) noexcept {
   addresses = std::move(other.addresses);
   config = std::move(other.config);
   // TODO(roth): Use std::move() once channel args is converted to C++.
@@ -99,29 +98,31 @@ LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
   //    the time this function returns, the pick will already have
   //    been processed, and we'll be trying to re-process the same
   //    pick again, leading to a crash.
-  // 2. We are currently running in the data plane combiner, but we
-  //    need to bounce into the control plane combiner to call
+  // 2. We are currently running in the data plane mutex, but we
+  //    need to bounce into the control plane work_serializer to call
   //    ExitIdleLocked().
   if (!exit_idle_called_) {
     exit_idle_called_ = true;
-    // Ref held by closure.
-    parent_->Ref(DEBUG_LOCATION, "QueuePicker::CallExitIdle").release();
-    parent_->combiner()->Run(
-        GRPC_CLOSURE_CREATE(&CallExitIdle, parent_.get(), nullptr),
-        GRPC_ERROR_NONE);
+    auto* parent = parent_->Ref().release();  // ref held by lambda.
+    ExecCtx::Run(DEBUG_LOCATION,
+                 GRPC_CLOSURE_CREATE(
+                     [](void* arg, grpc_error* /*error*/) {
+                       auto* parent = static_cast<LoadBalancingPolicy*>(arg);
+                       parent->work_serializer()->Run(
+                           [parent]() {
+                             parent->ExitIdleLocked();
+                             parent->Unref();
+                           },
+                           DEBUG_LOCATION);
+                     },
+                     parent, nullptr),
+                 GRPC_ERROR_NONE);
   }
   PickResult result;
   result.type = PickResult::PICK_QUEUE;
   return result;
 }
 
-void LoadBalancingPolicy::QueuePicker::CallExitIdle(void* arg,
-                                                    grpc_error* /*error*/) {
-  LoadBalancingPolicy* parent = static_cast<LoadBalancingPolicy*>(arg);
-  parent->ExitIdleLocked();
-  parent->Unref(DEBUG_LOCATION, "QueuePicker::CallExitIdle");
-}
-
 //
 // LoadBalancingPolicy::TransientFailurePicker
 //