grpc 1.34.0 → 1.35.0.pre1

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

@@ -75,8 +75,4 @@ void grpc_client_channel_stop_connectivity_watch(
     grpc_channel_element* elem,
     grpc_core::AsyncConnectivityStateWatcherInterface* watcher);
 
-/* Debug helper: pull the subchannel call from a call stack element */
-grpc_core::RefCountedPtr<grpc_core::SubchannelCall>
-grpc_client_channel_get_subchannel_call(grpc_call_element* elem);
-
 #endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_H

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

@@ -54,7 +54,7 @@ void grpc_client_channel_init(void) {
   grpc_core::GlobalSubchannelPool::Init();
   grpc_channel_init_register_stage(
       GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, append_filter,
-      (void*)&grpc_client_channel_filter);
+      const_cast<grpc_channel_filter*>(&grpc_client_channel_filter));
   grpc_http_connect_register_handshaker_factory();
   grpc_client_channel_global_init_backup_polling();
 }

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

@@ -21,6 +21,7 @@
 
 #include <functional>
 #include <map>
+#include <vector>
 
 #include "absl/strings/string_view.h"
 
@@ -28,6 +29,7 @@
 
 #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/channel/channel_stack.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"
@@ -80,6 +82,8 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
     return cs1->Equals(cs2);
   }
 
+  virtual std::vector<const grpc_channel_filter*> GetFilters() { return {}; }
+
   virtual CallConfig GetCallConfig(GetCallConfigArgs args) = 0;
 
   grpc_arg MakeChannelArg() const;

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

@@ -0,0 +1,186 @@
+//
+// 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/dynamic_filters.h"
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/surface/lame_client.h"
+
+// Conversion between call and call stack.
+#define CALL_TO_CALL_STACK(call)                                     \
+  (grpc_call_stack*)((char*)(call) + GPR_ROUND_UP_TO_ALIGNMENT_SIZE( \
+                                         sizeof(DynamicFilters::Call)))
+#define CALL_STACK_TO_CALL(callstack)                     \
+  (DynamicFilters::Call*)(((char*)(call_stack)) -         \
+                          GPR_ROUND_UP_TO_ALIGNMENT_SIZE( \
+                              sizeof(DynamicFilters::Call)))
+
+namespace grpc_core {
+
+//
+// DynamicFilters::Call
+//
+
+DynamicFilters::Call::Call(Args args, grpc_error** error)
+    : channel_stack_(std::move(args.channel_stack)) {
+  grpc_call_stack* call_stack = CALL_TO_CALL_STACK(this);
+  const grpc_call_element_args call_args = {
+      call_stack,        /* call_stack */
+      nullptr,           /* server_transport_data */
+      args.context,      /* context */
+      args.path,         /* path */
+      args.start_time,   /* start_time */
+      args.deadline,     /* deadline */
+      args.arena,        /* arena */
+      args.call_combiner /* call_combiner */
+  };
+  *error = grpc_call_stack_init(channel_stack_->channel_stack_, 1, Destroy,
+                                this, &call_args);
+  if (GPR_UNLIKELY(*error != GRPC_ERROR_NONE)) {
+    const char* error_string = grpc_error_string(*error);
+    gpr_log(GPR_ERROR, "error: %s", error_string);
+    return;
+  }
+  grpc_call_stack_set_pollset_or_pollset_set(call_stack, args.pollent);
+}
+
+void DynamicFilters::Call::StartTransportStreamOpBatch(
+    grpc_transport_stream_op_batch* batch) {
+  grpc_call_stack* call_stack = CALL_TO_CALL_STACK(this);
+  grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
+  GRPC_CALL_LOG_OP(GPR_INFO, top_elem, batch);
+  top_elem->filter->start_transport_stream_op_batch(top_elem, batch);
+}
+
+void DynamicFilters::Call::SetAfterCallStackDestroy(grpc_closure* closure) {
+  GPR_ASSERT(after_call_stack_destroy_ == nullptr);
+  GPR_ASSERT(closure != nullptr);
+  after_call_stack_destroy_ = closure;
+}
+
+RefCountedPtr<DynamicFilters::Call> DynamicFilters::Call::Ref() {
+  IncrementRefCount();
+  return RefCountedPtr<DynamicFilters::Call>(this);
+}
+
+RefCountedPtr<DynamicFilters::Call> DynamicFilters::Call::Ref(
+    const grpc_core::DebugLocation& location, const char* reason) {
+  IncrementRefCount(location, reason);
+  return RefCountedPtr<DynamicFilters::Call>(this);
+}
+
+void DynamicFilters::Call::Unref() {
+  GRPC_CALL_STACK_UNREF(CALL_TO_CALL_STACK(this), "");
+}
+
+void DynamicFilters::Call::Unref(const DebugLocation& /*location*/,
+                                 const char* reason) {
+  GRPC_CALL_STACK_UNREF(CALL_TO_CALL_STACK(this), reason);
+}
+
+void DynamicFilters::Call::Destroy(void* arg, grpc_error* /*error*/) {
+  DynamicFilters::Call* self = static_cast<DynamicFilters::Call*>(arg);
+  // Keep some members before destroying the subchannel call.
+  grpc_closure* after_call_stack_destroy = self->after_call_stack_destroy_;
+  RefCountedPtr<DynamicFilters> channel_stack = std::move(self->channel_stack_);
+  // Destroy the subchannel call.
+  self->~Call();
+  // Destroy the call stack. This should be after destroying the call, because
+  // call->after_call_stack_destroy(), if not null, will free the call arena.
+  grpc_call_stack_destroy(CALL_TO_CALL_STACK(self), nullptr,
+                          after_call_stack_destroy);
+  // Automatically reset channel_stack. This should be after destroying the call
+  // stack, because destroying call stack needs access to the channel stack.
+}
+
+void DynamicFilters::Call::IncrementRefCount() {
+  GRPC_CALL_STACK_REF(CALL_TO_CALL_STACK(this), "");
+}
+
+void DynamicFilters::Call::IncrementRefCount(
+    const grpc_core::DebugLocation& /*location*/, const char* reason) {
+  GRPC_CALL_STACK_REF(CALL_TO_CALL_STACK(this), reason);
+}
+
+//
+// DynamicFilters
+//
+
+namespace {
+
+void DestroyChannelStack(void* arg, grpc_error* /*error*/) {
+  grpc_channel_stack* channel_stack = static_cast<grpc_channel_stack*>(arg);
+  grpc_channel_stack_destroy(channel_stack);
+  gpr_free(channel_stack);
+}
+
+std::pair<grpc_channel_stack*, grpc_error*> CreateChannelStack(
+    const grpc_channel_args* args,
+    std::vector<const grpc_channel_filter*> filters) {
+  // Allocate memory for channel stack.
+  const size_t channel_stack_size =
+      grpc_channel_stack_size(filters.data(), filters.size());
+  grpc_channel_stack* channel_stack =
+      reinterpret_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
+  // Initialize stack.
+  grpc_error* error = grpc_channel_stack_init(
+      /*initial_refs=*/1, DestroyChannelStack, channel_stack, filters.data(),
+      filters.size(), args, /*optional_transport=*/nullptr, "DynamicFilters",
+      channel_stack);
+  if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_ERROR, "error initializing client internal stack: %s",
+            grpc_error_string(error));
+    grpc_channel_stack_destroy(channel_stack);
+    gpr_free(channel_stack);
+    return {nullptr, error};
+  }
+  return {channel_stack, GRPC_ERROR_NONE};
+}
+
+}  // namespace
+
+RefCountedPtr<DynamicFilters> DynamicFilters::Create(
+    const grpc_channel_args* args,
+    std::vector<const grpc_channel_filter*> filters) {
+  // Attempt to create channel stack from requested filters.
+  auto p = CreateChannelStack(args, std::move(filters));
+  if (p.second != GRPC_ERROR_NONE) {
+    // Initial pass failed.  Create with lame filter.
+    grpc_error* error = p.second;
+    p = CreateChannelStack(args, {&grpc_lame_filter});
+    GPR_ASSERT(p.second == GRPC_ERROR_NONE);
+    grpc_channel_element* elem = grpc_channel_stack_element(p.first, 0);
+    SetLameFilterError(elem, error);
+  }
+  return MakeRefCounted<DynamicFilters>(p.first);
+}
+
+DynamicFilters::~DynamicFilters() {
+  GRPC_CHANNEL_STACK_UNREF(channel_stack_, "~DynamicFilters");
+}
+
+RefCountedPtr<DynamicFilters::Call> DynamicFilters::CreateCall(
+    DynamicFilters::Call::Args args, grpc_error** error) {
+  size_t allocation_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Call)) +
+                           channel_stack_->call_stack_size;
+  Call* call = static_cast<Call*>(args.arena->Alloc(allocation_size));
+  new (call) Call(std::move(args), error);
+  return call;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,99 @@
+//
+// 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_DYNAMIC_FILTERS_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_DYNAMIC_FILTERS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <vector>
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gprpp/arena.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+
+namespace grpc_core {
+
+class DynamicFilters : public RefCounted<DynamicFilters> {
+ public:
+  // Implements the interface of RefCounted<>.
+  class Call {
+   public:
+    struct Args {
+      RefCountedPtr<DynamicFilters> channel_stack;
+      grpc_polling_entity* pollent;
+      grpc_slice path;
+      gpr_cycle_counter start_time;
+      grpc_millis deadline;
+      Arena* arena;
+      grpc_call_context_element* context;
+      CallCombiner* call_combiner;
+    };
+
+    Call(Args args, grpc_error** error);
+
+    // Continues processing a transport stream op batch.
+    void StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch);
+
+    // Sets the 'then_schedule_closure' argument for call stack destruction.
+    // Must be called once per call.
+    void SetAfterCallStackDestroy(grpc_closure* closure);
+
+    // Interface of RefCounted<>.
+    RefCountedPtr<Call> Ref() GRPC_MUST_USE_RESULT;
+    RefCountedPtr<Call> Ref(const DebugLocation& location,
+                            const char* reason) GRPC_MUST_USE_RESULT;
+    // When refcount drops to 0, destroys itself and the associated call stack,
+    // but does NOT free the memory because it's in the call arena.
+    void Unref();
+    void Unref(const DebugLocation& location, const char* reason);
+
+   private:
+    // Allow RefCountedPtr<> to access IncrementRefCount().
+    template <typename T>
+    friend class RefCountedPtr;
+
+    // Interface of RefCounted<>.
+    void IncrementRefCount();
+    void IncrementRefCount(const DebugLocation& location, const char* reason);
+
+    static void Destroy(void* arg, grpc_error* error);
+
+    RefCountedPtr<DynamicFilters> channel_stack_;
+    grpc_closure* after_call_stack_destroy_ = nullptr;
+  };
+
+  static RefCountedPtr<DynamicFilters> Create(
+      const grpc_channel_args* args,
+      std::vector<const grpc_channel_filter*> filters);
+
+  explicit DynamicFilters(grpc_channel_stack* channel_stack)
+      : channel_stack_(channel_stack) {}
+
+  ~DynamicFilters() override;
+
+  RefCountedPtr<Call> CreateCall(Call::Args args, grpc_error** error);
+
+ private:
+  grpc_channel_stack* channel_stack_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_DYNAMIC_FILTERS_H

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

@@ -46,7 +46,7 @@ TraceFlag grpc_health_check_client_trace(false, "health_check_client");
 //
 
 HealthCheckClient::HealthCheckClient(
-    const char* service_name,
+    std::string service_name,
     RefCountedPtr<ConnectedSubchannel> connected_subchannel,
     grpc_pollset_set* interested_parties,
     RefCountedPtr<channelz::SubchannelNode> channelz_node,
@@ -55,7 +55,7 @@ HealthCheckClient::HealthCheckClient(
           GRPC_TRACE_FLAG_ENABLED(grpc_health_check_client_trace)
               ? "HealthCheckClient"
               : nullptr),
-      service_name_(service_name),
+      service_name_(std::move(service_name)),
       connected_subchannel_(std::move(connected_subchannel)),
       interested_parties_(interested_parties),
       channelz_node_(std::move(channelz_node)),
@@ -180,13 +180,14 @@ void HealthCheckClient::OnRetryTimer(void* arg, grpc_error* error) {
 
 namespace {
 
-void EncodeRequest(const char* service_name,
+void EncodeRequest(const std::string& service_name,
                    ManualConstructor<SliceBufferByteStream>* send_message) {
   upb::Arena arena;
   grpc_health_v1_HealthCheckRequest* request_struct =
       grpc_health_v1_HealthCheckRequest_new(arena.ptr());
   grpc_health_v1_HealthCheckRequest_set_service(
-      request_struct, upb_strview_makez(service_name));
+      request_struct,
+      upb_strview_make(service_name.data(), service_name.size()));
   size_t buf_length;
   char* buf = grpc_health_v1_HealthCheckRequest_serialize(
       request_struct, arena.ptr(), &buf_length);
@@ -252,7 +253,7 @@ HealthCheckClient::CallState::CallState(
     : health_check_client_(std::move(health_check_client)),
       pollent_(grpc_polling_entity_create_from_pollset_set(interested_parties)),
       arena_(Arena::Create(health_check_client_->connected_subchannel_
-                               ->GetInitialCallSizeEstimate(0))),
+                               ->GetInitialCallSizeEstimate())),
       payload_(context_) {}
 
 HealthCheckClient::CallState::~CallState() {
@@ -291,7 +292,6 @@ void HealthCheckClient::CallState::StartCall() {
       arena_,
       context_,
       &call_combiner_,
-      0,  // parent_data_size
   };
   grpc_error* error = GRPC_ERROR_NONE;
   call_ = SubchannelCall::Create(std::move(args), &error).release();

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

@@ -44,7 +44,7 @@ namespace grpc_core {
 
 class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
  public:
-  HealthCheckClient(const char* service_name,
+  HealthCheckClient(std::string service_name,
                     RefCountedPtr<ConnectedSubchannel> connected_subchannel,
                     grpc_pollset_set* interested_parties,
                     RefCountedPtr<channelz::SubchannelNode> channelz_node,
@@ -150,7 +150,7 @@ class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
   void SetHealthStatusLocked(grpc_connectivity_state state,
                              const char* reason);  // Requires holding mu_.
 
-  const char* service_name_;  // Do not own.
+  std::string service_name_;
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
   grpc_pollset_set* interested_parties_;  // Do not own.
   RefCountedPtr<channelz::SubchannelNode> channelz_node_;

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

@@ -332,7 +332,7 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   grpc_httpcli_request request;
   request.host = server_name;
   request.ssl_host_override = nullptr;
-  request.http.method = (char*)"CONNECT";
+  request.http.method = const_cast<char*>("CONNECT");
   request.http.path = server_name;
   request.http.version = GRPC_HTTP_HTTP10;  // Set by OnReadDone
   request.http.hdrs = headers;
@@ -382,8 +382,7 @@ class HttpConnectHandshakerFactory : public HandshakerFactory {
 }  // namespace grpc_core
 
 void grpc_http_connect_register_handshaker_factory() {
-  using namespace grpc_core;
-  HandshakerRegistry::RegisterHandshakerFactory(
-      true /* at_start */, HANDSHAKER_CLIENT,
-      absl::make_unique<HttpConnectHandshakerFactory>());
+  grpc_core::HandshakerRegistry::RegisterHandshakerFactory(
+      true /* at_start */, grpc_core::HANDSHAKER_CLIENT,
+      absl::make_unique<grpc_core::HttpConnectHandshakerFactory>());
 }

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

@@ -24,6 +24,7 @@
 #include <string.h>
 
 #include "absl/strings/str_cat.h"
+#include "absl/strings/strip.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -47,9 +48,10 @@ namespace {
  * credentials if present in the 'http_proxy' env var, otherwise leaves it
  * unchanged. It is caller's responsibility to gpr_free user_cred.
  */
+// TODO(hork): change this to return std::string
 char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
   GPR_ASSERT(user_cred != nullptr);
-  grpc_uri* uri = nullptr;
+  absl::StatusOr<URI> uri;
   char* proxy_name = nullptr;
   char** authority_strs = nullptr;
   size_t authority_nstrs;
@@ -69,17 +71,20 @@ char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
   if (uri_str == nullptr) return nullptr;
   // an emtpy value means "don't use proxy"
   if (uri_str[0] == '\0') goto done;
-  uri = grpc_uri_parse(uri_str, false /* suppress_errors */);
-  if (uri == nullptr || uri->authority == nullptr) {
-    gpr_log(GPR_ERROR, "cannot parse value of 'http_proxy' env var");
+  uri = URI::Parse(uri_str);
+  if (!uri.ok() || uri->authority().empty()) {
+    gpr_log(GPR_ERROR, "cannot parse value of 'http_proxy' env var. Error: %s",
+            uri.status().ToString().c_str());
     goto done;
   }
-  if (strcmp(uri->scheme, "http") != 0) {
-    gpr_log(GPR_ERROR, "'%s' scheme not supported in proxy URI", uri->scheme);
+  if (uri->scheme() != "http") {
+    gpr_log(GPR_ERROR, "'%s' scheme not supported in proxy URI",
+            uri->scheme().c_str());
     goto done;
   }
   /* Split on '@' to separate user credentials from host */
-  gpr_string_split(uri->authority, "@", &authority_strs, &authority_nstrs);
+  gpr_string_split(uri->authority().c_str(), "@", &authority_strs,
+                   &authority_nstrs);
   GPR_ASSERT(authority_nstrs != 0); /* should have at least 1 string */
   if (authority_nstrs == 1) {
     /* User cred not present in authority */
@@ -99,7 +104,6 @@ char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
   gpr_free(authority_strs);
 done:
   gpr_free(uri_str);
-  grpc_uri_destroy(uri);
   return proxy_name;
 }
 
@@ -114,15 +118,15 @@ class HttpProxyMapper : public ProxyMapperInterface {
     *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 */);
-    if (uri == nullptr || uri->path[0] == '\0') {
+    absl::StatusOr<URI> uri = URI::Parse(server_uri);
+    if (!uri.ok() || uri->path().empty()) {
       gpr_log(GPR_ERROR,
               "'http_proxy' environment variable set, but cannot "
-              "parse server URI '%s' -- not using proxy",
-              server_uri);
+              "parse server URI '%s' -- not using proxy. Error: %s",
+              server_uri, uri.status().ToString().c_str());
       goto no_use_proxy;
     }
-    if (strcmp(uri->scheme, "unix") == 0) {
+    if (uri->scheme() == "unix") {
       gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
               server_uri);
       goto no_use_proxy;
@@ -135,9 +139,8 @@ class HttpProxyMapper : public ProxyMapperInterface {
       bool use_proxy = true;
       std::string server_host;
       std::string server_port;
-      if (!grpc_core::SplitHostPort(
-              uri->path[0] == '/' ? uri->path + 1 : uri->path, &server_host,
-              &server_port)) {
+      if (!SplitHostPort(absl::StripPrefix(uri->path(), "/"), &server_host,
+                         &server_port)) {
         gpr_log(GPR_INFO,
                 "unable to split host and port, not checking no_proxy list for "
                 "host '%s'",
@@ -172,8 +175,8 @@ class HttpProxyMapper : public ProxyMapperInterface {
     }
     grpc_arg args_to_add[2];
     args_to_add[0] = grpc_channel_arg_string_create(
-        (char*)GRPC_ARG_HTTP_CONNECT_SERVER,
-        uri->path[0] == '/' ? uri->path + 1 : uri->path);
+        const_cast<char*>(GRPC_ARG_HTTP_CONNECT_SERVER),
+        const_cast<char*>(absl::StripPrefix(uri->path(), "/").data()));
     if (user_cred != nullptr) {
       /* Use base64 encoding for user credentials as stated in RFC 7617 */
       char* encoded_user_cred =
@@ -188,11 +191,9 @@ class HttpProxyMapper : public ProxyMapperInterface {
     } else {
       *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 1);
     }
-    grpc_uri_destroy(uri);
     gpr_free(user_cred);
     return true;
   no_use_proxy:
-    if (uri != nullptr) grpc_uri_destroy(uri);
     gpr_free(*name_to_resolve);
     *name_to_resolve = nullptr;
     gpr_free(user_cred);