grpc 1.45.0 → 1.47.0

data/src/core/lib/channel/channel_stack_builder.h

@@ -17,10 +17,22 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
+#include <string>
+#include <vector>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+
+typedef struct grpc_channel_stack grpc_channel_stack;
+typedef struct grpc_channel_element grpc_channel_element;
+typedef struct grpc_channel_filter grpc_channel_filter;
+typedef struct grpc_transport grpc_transport;
 
 namespace grpc_core {
 
@@ -31,21 +43,11 @@ namespace grpc_core {
 // and a transport.
 class ChannelStackBuilder {
  public:
-  // A function that will be called after the channel stack is successfully
-  // built.
-  using PostInitFunc = std::function<void(grpc_channel_stack* channel_stack,
-                                          grpc_channel_element* elem)>;
-
-  // One filter in the currently building stack.
-  struct StackEntry {
-    const grpc_channel_filter* filter;
-    PostInitFunc post_init;
-  };
-
   // Initialize with a name.
-  explicit ChannelStackBuilder(const char* name) : name_(name) {}
+  ChannelStackBuilder(const char* name, grpc_channel_stack_type type)
+      : name_(name), type_(type) {}
 
-  ~ChannelStackBuilder();
+  const char* name() const { return name_; }
 
   // Set the target string.
   ChannelStackBuilder& SetTarget(const char* target);
@@ -64,43 +66,50 @@ class ChannelStackBuilder {
   grpc_transport* transport() const { return transport_; }
 
   // Set channel args (takes a copy of them).
-  ChannelStackBuilder& SetChannelArgs(const grpc_channel_args* args);
+  ChannelStackBuilder& SetChannelArgs(ChannelArgs args);
 
   // Query the channel args.
-  const grpc_channel_args* channel_args() const { return args_; }
+  const ChannelArgs& channel_args() const { return args_; }
 
   // Mutable vector of proposed stack entries.
-  std::vector<StackEntry>* mutable_stack() { return &stack_; }
+  std::vector<const grpc_channel_filter*>* mutable_stack() { return &stack_; }
+
+  // The type of channel stack being built.
+  grpc_channel_stack_type channel_stack_type() const { return type_; }
 
   // Helper to add a filter to the front of the stack.
-  void PrependFilter(const grpc_channel_filter* filter, PostInitFunc post_init);
+  void PrependFilter(const grpc_channel_filter* filter);
 
   // Helper to add a filter to the end of the stack.
-  void AppendFilter(const grpc_channel_filter* filter, PostInitFunc post_init);
+  void AppendFilter(const grpc_channel_filter* filter);
 
   // Build the channel stack.
   // After success, *result holds the new channel stack,
   // prefix_bytes are allocated before the channel stack,
-  // initial_refs, destroy, destroy_arg are as per grpc_channel_stack_init
+  // destroy is as per grpc_channel_stack_init
   // On failure, *result is nullptr.
-  grpc_error_handle Build(size_t prefix_bytes, int initial_refs,
-                          grpc_iomgr_cb_func destroy, void* destroy_arg,
-                          void** result);
+  virtual absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() = 0;
+
+ protected:
+  ~ChannelStackBuilder();
 
  private:
   static std::string unknown_target() { return "unknown"; }
 
   // The name of the stack
   const char* const name_;
+  // The type of stack being built
+  const grpc_channel_stack_type type_;
   // The target
   std::string target_{unknown_target()};
   // The transport
   grpc_transport* transport_ = nullptr;
   // Channel args
-  const grpc_channel_args* args_ = nullptr;
+  ChannelArgs args_;
   // The in-progress stack
-  std::vector<StackEntry> stack_;
+  std::vector<const grpc_channel_filter*> stack_;
 };
+
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H

data/src/core/lib/channel/channel_stack_builder_impl.cc

@@ -0,0 +1,97 @@
+/*
+ *
+ * Copyright 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.
+ *
+ */
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_stack_builder_impl.h"
+
+#include <string.h>
+
+#include <vector>
+
+#include "absl/status/status.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/support/alloc.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+absl::StatusOr<RefCountedPtr<grpc_channel_stack>>
+ChannelStackBuilderImpl::Build() {
+  auto* stack = mutable_stack();
+
+  // calculate the size of the channel stack
+  size_t channel_stack_size =
+      grpc_channel_stack_size(stack->data(), stack->size());
+
+  // allocate memory
+  auto* channel_stack =
+      static_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
+
+  ChannelArgs final_args = channel_args();
+  if (transport() != nullptr) {
+    static const grpc_arg_pointer_vtable vtable = {
+        // copy
+        [](void* p) { return p; },
+        // destroy
+        [](void*) {},
+        // cmp
+        [](void* a, void* b) { return QsortCompare(a, b); },
+    };
+    final_args = final_args.Set(GRPC_ARG_TRANSPORT,
+                                ChannelArgs::Pointer(transport(), &vtable));
+  }
+
+  // and initialize it
+  const grpc_channel_args* c_args = final_args.ToC();
+  grpc_error_handle error = grpc_channel_stack_init(
+      1,
+      [](void* p, grpc_error_handle) {
+        auto* stk = static_cast<grpc_channel_stack*>(p);
+        grpc_channel_stack_destroy(stk);
+        gpr_free(stk);
+      },
+      channel_stack, stack->data(), stack->size(), c_args, name(),
+      channel_stack);
+  grpc_channel_args_destroy(c_args);
+
+  if (error != GRPC_ERROR_NONE) {
+    grpc_channel_stack_destroy(channel_stack);
+    gpr_free(channel_stack);
+    auto status = grpc_error_to_absl_status(error);
+    GRPC_ERROR_UNREF(error);
+    return status;
+  }
+
+  // run post-initialization functions
+  for (size_t i = 0; i < stack->size(); i++) {
+    auto* elem = grpc_channel_stack_element(channel_stack, i);
+    elem->filter->post_init_channel_elem(channel_stack, elem);
+  }
+
+  return RefCountedPtr<grpc_channel_stack>(channel_stack);
+}
+
+}  // namespace grpc_core

data/src/core/lib/channel/channel_stack_builder_impl.h

@@ -0,0 +1,45 @@
+// Copyright 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.
+
+#ifndef GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_IMPL_H
+#define GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_IMPL_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+
+namespace grpc_core {
+
+// Build a channel stack.
+// Allows interested parties to add filters to the stack, and to query an
+// in-progress build.
+// Carries some useful context for the channel stack, such as a target string
+// and a transport.
+class ChannelStackBuilderImpl final : public ChannelStackBuilder {
+ public:
+  using ChannelStackBuilder::ChannelStackBuilder;
+
+  // Build the channel stack.
+  // After success, *result holds the new channel stack,
+  // prefix_bytes are allocated before the channel stack,
+  // initial_refs, destroy, destroy_arg are as per grpc_channel_stack_init
+  // On failure, *result is nullptr.
+  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() override;
+};
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_IMPL_H

data/src/core/lib/channel/channel_trace.cc

@@ -20,24 +20,19 @@
 
 #include "src/core/lib/channel/channel_trace.h"
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <algorithm>
+#include <map>
+#include <string>
+#include <utility>
 
-#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/channel.h"
-#include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 namespace grpc_core {
 namespace channelz {

data/src/core/lib/channel/channel_trace.h

@@ -21,11 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/slice.h>
+#include <grpc/support/sync.h>
 
-#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {

data/src/core/lib/channel/channelz.cc

@@ -20,37 +20,32 @@
 
 #include "src/core/lib/channel/channelz.h"
 
-#include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
+#include <algorithm>
 #include <atomic>
+#include <type_traits>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz_registry.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/slice/b64.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/channel.h"
-#include "src/core/lib/surface/server.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {

data/src/core/lib/channel/channelz.h

@@ -21,23 +21,28 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <atomic>
+#include <cstdint>
+#include <map>
 #include <set>
 #include <string>
+#include <utility>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/grpc.h>
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
 
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/gpr/time_precise.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/json/json.h"
 
 // Channel arg key for channelz node.
@@ -176,6 +181,10 @@ class ChannelNode : public BaseNode {
   ChannelNode(std::string target, size_t channel_tracer_max_nodes,
               bool is_internal_channel);
 
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_CHANNELZ_CHANNEL_NODE;
+  }
+
   // Returns the string description of the given connectivity state.
   static const char* GetChannelConnectivityStateChangeString(
       grpc_connectivity_state state);

data/src/core/lib/channel/channelz_registry.cc

@@ -21,39 +21,32 @@
 #include "src/core/lib/channel/channelz_registry.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <cstring>
+#include <utility>
 
 #include "absl/container/inlined_vector.h"
 
-#include <grpc/support/alloc.h>
+#include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/sync.h>
 
-#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/json/json.h"
 
 namespace grpc_core {
 namespace channelz {
 namespace {
 
-// singleton instance of the registry.
-ChannelzRegistry* g_channelz_registry = nullptr;
-
 const int kPaginationLimit = 100;
 
 }  // anonymous namespace
 
-void ChannelzRegistry::Init() { g_channelz_registry = new ChannelzRegistry(); }
-
-void ChannelzRegistry::Shutdown() { delete g_channelz_registry; }
-
 ChannelzRegistry* ChannelzRegistry::Default() {
-  GPR_DEBUG_ASSERT(g_channelz_registry != nullptr);
-  return g_channelz_registry;
+  static ChannelzRegistry* singleton = new ChannelzRegistry();
+  return singleton;
 }
 
 void ChannelzRegistry::InternalRegister(BaseNode* node) {

data/src/core/lib/channel/channelz_registry.h

@@ -21,13 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
-
+#include <cstdint>
 #include <map>
 #include <string>
 
-#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_core {
@@ -37,12 +36,6 @@ namespace channelz {
 // channelz bookkeeping. All objects share globally distributed uuids.
 class ChannelzRegistry {
  public:
-  // To be called in grpc_init()
-  static void Init();
-
-  // To be called in grpc_shutdown();
-  static void Shutdown();
-
   static void Register(BaseNode* node) {
     return Default()->InternalRegister(node);
   }
@@ -67,6 +60,14 @@ class ChannelzRegistry {
   // This can aid in debugging channelz code.
   static void LogAllEntities() { Default()->InternalLogAllEntities(); }
 
+  // Test only helper function to reset to initial state.
+  static void TestOnlyReset() {
+    auto* p = Default();
+    MutexLock lock(&p->mu_);
+    p->node_map_.clear();
+    p->uuid_generator_ = 0;
+  }
+
  private:
   // Returned the singleton instance of ChannelzRegistry;
   static ChannelzRegistry* Default();

data/src/core/lib/channel/connected_channel.cc

@@ -20,17 +20,17 @@
 
 #include "src/core/lib/channel/connected_channel.h"
 
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <grpc/byte_buffer.h>
-#include <grpc/slice_buffer.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/transport/transport.h"
 
 #define MAX_BUFFER_LENGTH 8192
@@ -184,7 +184,8 @@ static grpc_error_handle connected_channel_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_last);
-  cd->transport = nullptr;
+  cd->transport = grpc_channel_args_find_pointer<grpc_transport>(
+      args->channel_args, GRPC_ARG_TRANSPORT);
   return GRPC_ERROR_NONE;
 }
 
@@ -211,36 +212,25 @@ const grpc_channel_filter grpc_connected_filter = {
     connected_channel_destroy_call_elem,
     sizeof(channel_data),
     connected_channel_init_channel_elem,
+    [](grpc_channel_stack* channel_stack, grpc_channel_element* elem) {
+      /* HACK(ctiller): increase call stack size for the channel to make space
+         for channel data. We need a cleaner (but performant) way to do this,
+         and I'm not sure what that is yet.
+         This is only "safe" because call stacks place no additional data after
+         the last call element, and the last call element MUST be the connected
+         channel. */
+      channel_stack->call_stack_size += grpc_transport_stream_size(
+          static_cast<channel_data*>(elem->channel_data)->transport);
+    },
     connected_channel_destroy_channel_elem,
     connected_channel_get_channel_info,
     "connected",
 };
 
-static void bind_transport(grpc_channel_stack* channel_stack,
-                           grpc_channel_element* elem, void* t) {
-  channel_data* cd = static_cast<channel_data*>(elem->channel_data);
-  GPR_ASSERT(elem->filter == &grpc_connected_filter);
-  GPR_ASSERT(cd->transport == nullptr);
-  cd->transport = static_cast<grpc_transport*>(t);
-
-  /* HACK(ctiller): increase call stack size for the channel to make space
-     for channel data. We need a cleaner (but performant) way to do this,
-     and I'm not sure what that is yet.
-     This is only "safe" because call stacks place no additional data after
-     the last call element, and the last call element MUST be the connected
-     channel. */
-  channel_stack->call_stack_size +=
-      grpc_transport_stream_size(static_cast<grpc_transport*>(t));
-}
-
 bool grpc_add_connected_filter(grpc_core::ChannelStackBuilder* builder) {
   grpc_transport* t = builder->transport();
   GPR_ASSERT(t != nullptr);
-  builder->AppendFilter(
-      &grpc_connected_filter,
-      [t](grpc_channel_stack* stk, grpc_channel_element* elem) {
-        bind_transport(stk, elem, t);
-      });
+  builder->AppendFilter(&grpc_connected_filter);
   return true;
 }
 

data/src/core/lib/channel/connected_channel.h

@@ -21,7 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/transport/transport.h"
 
 extern const grpc_channel_filter grpc_connected_filter;