grpc 1.18.0 → 1.22.0

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

@@ -40,12 +40,51 @@
 #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/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 namespace channelz {
 
+//
+// channel arg code
+//
+
+namespace {
+
+void* parent_uuid_copy(void* p) { return p; }
+void parent_uuid_destroy(void* p) {}
+int parent_uuid_cmp(void* p1, void* p2) { return GPR_ICMP(p1, p2); }
+const grpc_arg_pointer_vtable parent_uuid_vtable = {
+    parent_uuid_copy, parent_uuid_destroy, parent_uuid_cmp};
+
+}  // namespace
+
+grpc_arg MakeParentUuidArg(intptr_t parent_uuid) {
+  // We would ideally like to store the uuid in an integer argument.
+  // Unfortunately, that won't work, because intptr_t (the type used for
+  // uuids) doesn't fit in an int (the type used for integer args).
+  // So instead, we use a hack to store it as a pointer, because
+  // intptr_t should be the same size as void*.
+  static_assert(sizeof(intptr_t) <= sizeof(void*),
+                "can't fit intptr_t inside of void*");
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_CHANNELZ_PARENT_UUID),
+      reinterpret_cast<void*>(parent_uuid), &parent_uuid_vtable);
+}
+
+intptr_t GetParentUuidFromArgs(const grpc_channel_args& args) {
+  const grpc_arg* arg =
+      grpc_channel_args_find(&args, GRPC_ARG_CHANNELZ_PARENT_UUID);
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return 0;
+  return reinterpret_cast<intptr_t>(arg->value.pointer.p);
+}
+
+//
+// BaseNode
+//
+
 BaseNode::BaseNode(EntityType type) : type_(type), uuid_(-1) {
   // The registry will set uuid_ under its lock.
   ChannelzRegistry::Register(this);
@@ -61,6 +100,10 @@ char* BaseNode::RenderJsonString() {
   return json_str;
 }
 
+//
+// CallCountingHelper
+//
+
 CallCountingHelper::CallCountingHelper() {
   num_cores_ = GPR_MAX(1, gpr_cpu_num_cores());
   per_cpu_counter_data_storage_ = static_cast<AtomicCounterData*>(
@@ -137,15 +180,17 @@ void CallCountingHelper::PopulateCallCounts(grpc_json* json) {
   }
 }
 
-ChannelNode::ChannelNode(grpc_channel* channel, size_t channel_tracer_max_nodes,
-                         bool is_top_level_channel)
-    : BaseNode(is_top_level_channel ? EntityType::kTopLevelChannel
-                                    : EntityType::kInternalChannel),
-      channel_(channel),
-      target_(UniquePtr<char>(grpc_channel_get_target(channel_))),
-      trace_(channel_tracer_max_nodes) {}
+//
+// ChannelNode
+//
 
-ChannelNode::~ChannelNode() {}
+ChannelNode::ChannelNode(UniquePtr<char> target,
+                         size_t channel_tracer_max_nodes, intptr_t parent_uuid)
+    : BaseNode(parent_uuid == 0 ? EntityType::kTopLevelChannel
+                                : EntityType::kInternalChannel),
+      target_(std::move(target)),
+      trace_(channel_tracer_max_nodes),
+      parent_uuid_(parent_uuid) {}
 
 grpc_json* ChannelNode::RenderJson() {
   // We need to track these three json objects to build our object
@@ -167,9 +212,19 @@ grpc_json* ChannelNode::RenderJson() {
                                            GRPC_JSON_OBJECT, false);
   json = data;
   json_iterator = nullptr;
-  // template method. Child classes may override this to add their specific
-  // functionality.
-  PopulateConnectivityState(json);
+  // connectivity state
+  // If low-order bit is on, then the field is set.
+  int state_field = connectivity_state_.Load(MemoryOrder::RELAXED);
+  if ((state_field & 1) != 0) {
+    grpc_connectivity_state state =
+        static_cast<grpc_connectivity_state>(state_field >> 1);
+    json = grpc_json_create_child(nullptr, json, "state", nullptr,
+                                  GRPC_JSON_OBJECT, false);
+    grpc_json_create_child(nullptr, json, "state",
+                           grpc_connectivity_state_name(state),
+                           GRPC_JSON_STRING, false);
+    json = data;
+  }
   // populate the target.
   GPR_ASSERT(target_.get() != nullptr);
   grpc_json_create_child(nullptr, json, "target", target_.get(),
@@ -189,13 +244,64 @@ grpc_json* ChannelNode::RenderJson() {
   return top_level_json;
 }
 
-RefCountedPtr<ChannelNode> ChannelNode::MakeChannelNode(
-    grpc_channel* channel, size_t channel_tracer_max_nodes,
-    bool is_top_level_channel) {
-  return MakeRefCounted<grpc_core::channelz::ChannelNode>(
-      channel, channel_tracer_max_nodes, is_top_level_channel);
+void ChannelNode::PopulateChildRefs(grpc_json* json) {
+  MutexLock lock(&child_mu_);
+  grpc_json* json_iterator = nullptr;
+  if (!child_subchannels_.empty()) {
+    grpc_json* array_parent = grpc_json_create_child(
+        nullptr, json, "subchannelRef", nullptr, GRPC_JSON_ARRAY, false);
+    for (const auto& p : child_subchannels_) {
+      json_iterator =
+          grpc_json_create_child(json_iterator, array_parent, nullptr, nullptr,
+                                 GRPC_JSON_OBJECT, false);
+      grpc_json_add_number_string_child(json_iterator, nullptr, "subchannelId",
+                                        p.first);
+    }
+  }
+  if (!child_channels_.empty()) {
+    grpc_json* array_parent = grpc_json_create_child(
+        nullptr, json, "channelRef", nullptr, GRPC_JSON_ARRAY, false);
+    json_iterator = nullptr;
+    for (const auto& p : child_channels_) {
+      json_iterator =
+          grpc_json_create_child(json_iterator, array_parent, nullptr, nullptr,
+                                 GRPC_JSON_OBJECT, false);
+      grpc_json_add_number_string_child(json_iterator, nullptr, "channelId",
+                                        p.first);
+    }
+  }
+}
+
+void ChannelNode::SetConnectivityState(grpc_connectivity_state state) {
+  // Store with low-order bit set to indicate that the field is set.
+  int state_field = (state << 1) + 1;
+  connectivity_state_.Store(state_field, MemoryOrder::RELAXED);
+}
+
+void ChannelNode::AddChildChannel(intptr_t child_uuid) {
+  MutexLock lock(&child_mu_);
+  child_channels_.insert(MakePair(child_uuid, true));
+}
+
+void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
+  MutexLock lock(&child_mu_);
+  child_channels_.erase(child_uuid);
 }
 
+void ChannelNode::AddChildSubchannel(intptr_t child_uuid) {
+  MutexLock lock(&child_mu_);
+  child_subchannels_.insert(MakePair(child_uuid, true));
+}
+
+void ChannelNode::RemoveChildSubchannel(intptr_t child_uuid) {
+  MutexLock lock(&child_mu_);
+  child_subchannels_.erase(child_uuid);
+}
+
+//
+// ServerNode
+//
+
 ServerNode::ServerNode(grpc_server* server, size_t channel_tracer_max_nodes)
     : BaseNode(EntityType::kServer),
       server_(server),
@@ -281,8 +387,14 @@ grpc_json* ServerNode::RenderJson() {
   return top_level_json;
 }
 
-static void PopulateSocketAddressJson(grpc_json* json, const char* name,
-                                      const char* addr_str) {
+//
+// SocketNode
+//
+
+namespace {
+
+void PopulateSocketAddressJson(grpc_json* json, const char* name,
+                               const char* addr_str) {
   if (addr_str == nullptr) return;
   grpc_json* json_iterator = nullptr;
   json_iterator = grpc_json_create_child(json_iterator, json, name, nullptr,
@@ -312,7 +424,6 @@ static void PopulateSocketAddressJson(grpc_json* json, const char* name,
                                            b64_host, GRPC_JSON_STRING, true);
     gpr_free(host);
     gpr_free(port);
-
   } else if (uri != nullptr && strcmp(uri->scheme, "unix") == 0) {
     json_iterator = grpc_json_create_child(json_iterator, json, "uds_address",
                                            nullptr, GRPC_JSON_OBJECT, false);
@@ -332,6 +443,8 @@ static void PopulateSocketAddressJson(grpc_json* json, const char* name,
   grpc_uri_destroy(uri);
 }
 
+}  // namespace
+
 SocketNode::SocketNode(UniquePtr<char> local, UniquePtr<char> remote)
     : BaseNode(EntityType::kSocket),
       local_(std::move(local)),
@@ -385,56 +498,73 @@ grpc_json* SocketNode::RenderJson() {
   json = data;
   json_iterator = nullptr;
   gpr_timespec ts;
-  if (streams_started_ != 0) {
+  gpr_atm streams_started = gpr_atm_no_barrier_load(&streams_started_);
+  if (streams_started != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "streamsStarted", streams_started_);
-    if (last_local_stream_created_millis_ != 0) {
-      ts = grpc_millis_to_timespec(last_local_stream_created_millis_,
+        json, json_iterator, "streamsStarted", streams_started);
+    gpr_atm last_local_stream_created_millis =
+        gpr_atm_no_barrier_load(&last_local_stream_created_millis_);
+    if (last_local_stream_created_millis != 0) {
+      ts = grpc_millis_to_timespec(last_local_stream_created_millis,
                                    GPR_CLOCK_REALTIME);
       json_iterator = grpc_json_create_child(
           json_iterator, json, "lastLocalStreamCreatedTimestamp",
           gpr_format_timespec(ts), GRPC_JSON_STRING, true);
     }
-    if (last_remote_stream_created_millis_ != 0) {
-      ts = grpc_millis_to_timespec(last_remote_stream_created_millis_,
+    gpr_atm last_remote_stream_created_millis =
+        gpr_atm_no_barrier_load(&last_remote_stream_created_millis_);
+    if (last_remote_stream_created_millis != 0) {
+      ts = grpc_millis_to_timespec(last_remote_stream_created_millis,
                                    GPR_CLOCK_REALTIME);
       json_iterator = grpc_json_create_child(
           json_iterator, json, "lastRemoteStreamCreatedTimestamp",
           gpr_format_timespec(ts), GRPC_JSON_STRING, true);
     }
   }
-  if (streams_succeeded_ != 0) {
+  gpr_atm streams_succeeded = gpr_atm_no_barrier_load(&streams_succeeded_);
+  if (streams_succeeded != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "streamsSucceeded", streams_succeeded_);
+        json, json_iterator, "streamsSucceeded", streams_succeeded);
   }
-  if (streams_failed_) {
+  gpr_atm streams_failed = gpr_atm_no_barrier_load(&streams_failed_);
+  if (streams_failed) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "streamsFailed", streams_failed_);
+        json, json_iterator, "streamsFailed", streams_failed);
   }
-  if (messages_sent_ != 0) {
+  gpr_atm messages_sent = gpr_atm_no_barrier_load(&messages_sent_);
+  if (messages_sent != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "messagesSent", messages_sent_);
-    ts = grpc_millis_to_timespec(last_message_sent_millis_, GPR_CLOCK_REALTIME);
+        json, json_iterator, "messagesSent", messages_sent);
+    ts = grpc_millis_to_timespec(
+        gpr_atm_no_barrier_load(&last_message_sent_millis_),
+        GPR_CLOCK_REALTIME);
     json_iterator =
         grpc_json_create_child(json_iterator, json, "lastMessageSentTimestamp",
                                gpr_format_timespec(ts), GRPC_JSON_STRING, true);
   }
-  if (messages_received_ != 0) {
+  gpr_atm messages_received = gpr_atm_no_barrier_load(&messages_received_);
+  if (messages_received != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "messagesReceived", messages_received_);
-    ts = grpc_millis_to_timespec(last_message_received_millis_,
-                                 GPR_CLOCK_REALTIME);
+        json, json_iterator, "messagesReceived", messages_received);
+    ts = grpc_millis_to_timespec(
+        gpr_atm_no_barrier_load(&last_message_received_millis_),
+        GPR_CLOCK_REALTIME);
     json_iterator = grpc_json_create_child(
         json_iterator, json, "lastMessageReceivedTimestamp",
         gpr_format_timespec(ts), GRPC_JSON_STRING, true);
   }
-  if (keepalives_sent_ != 0) {
+  gpr_atm keepalives_sent = gpr_atm_no_barrier_load(&keepalives_sent_);
+  if (keepalives_sent != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "keepAlivesSent", keepalives_sent_);
+        json, json_iterator, "keepAlivesSent", keepalives_sent);
   }
   return top_level_json;
 }
 
+//
+// ListenSocketNode
+//
+
 ListenSocketNode::ListenSocketNode(UniquePtr<char> local_addr)
     : BaseNode(EntityType::kSocket), local_addr_(std::move(local_addr)) {}
 

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

@@ -26,19 +26,19 @@
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/gprpp/map.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 client channel factory.
-#define GRPC_ARG_CHANNELZ_CHANNEL_NODE_CREATION_FUNC \
-  "grpc.channelz_channel_node_creation_func"
+// Channel arg key for channelz node.
+#define GRPC_ARG_CHANNELZ_CHANNEL_NODE "grpc.channelz_channel_node"
 
-// Channel arg key to signal that the channel is an internal channel.
-#define GRPC_ARG_CHANNELZ_CHANNEL_IS_INTERNAL_CHANNEL \
-  "grpc.channelz_channel_is_internal_channel"
+// Channel arg key to encode the channelz uuid of the channel's parent.
+#define GRPC_ARG_CHANNELZ_PARENT_UUID "grpc.channelz_parent_uuid"
 
 /** This is the default value for whether or not to enable channelz. If
  * GRPC_ARG_ENABLE_CHANNELZ is set, it will override this default value. */
@@ -54,6 +54,10 @@ namespace grpc_core {
 
 namespace channelz {
 
+// Helpers for getting and setting GRPC_ARG_CHANNELZ_PARENT_UUID.
+grpc_arg MakeParentUuidArg(intptr_t parent_uuid);
+intptr_t GetParentUuidFromArgs(const grpc_channel_args& args);
+
 // TODO(ncteisen), this only contains the uuids of the children for now,
 // since that is all that is strictly needed. In a future enhancement we will
 // add human readable names as in the channelz.proto
@@ -147,44 +151,19 @@ class CallCountingHelper {
 // Handles channelz bookkeeping for channels
 class ChannelNode : public BaseNode {
  public:
-  static RefCountedPtr<ChannelNode> MakeChannelNode(
-      grpc_channel* channel, size_t channel_tracer_max_nodes,
-      bool is_top_level_channel);
+  ChannelNode(UniquePtr<char> target, size_t channel_tracer_max_nodes,
+              intptr_t parent_uuid);
 
-  ChannelNode(grpc_channel* channel, size_t channel_tracer_max_nodes,
-              bool is_top_level_channel);
-  ~ChannelNode() override;
+  intptr_t parent_uuid() const { return parent_uuid_; }
 
   grpc_json* RenderJson() override;
 
-  // template methods. RenderJSON uses these methods to render its JSON
-  // representation. These are virtual so that children classes may provide
-  // their specific mechanism for populating these parts of the channelz
-  // object.
-  //
-  // ChannelNode does not have a notion of connectivity state or child refs,
-  // so it leaves these implementations blank.
-  //
-  // This is utilizing the template method design pattern.
-  //
-  // TODO(ncteisen): remove these template methods in favor of manual traversal
-  // and mutation of the grpc_json object.
-  virtual void PopulateConnectivityState(grpc_json* json) {}
-  virtual void PopulateChildRefs(grpc_json* json) {}
-
-  void MarkChannelDestroyed() {
-    GPR_ASSERT(channel_ != nullptr);
-    channel_ = nullptr;
-  }
-
-  bool ChannelIsDestroyed() { return channel_ == nullptr; }
-
   // proxy methods to composed classes.
-  void AddTraceEvent(ChannelTrace::Severity severity, grpc_slice data) {
+  void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
     trace_.AddTraceEvent(severity, data);
   }
   void AddTraceEventWithReference(ChannelTrace::Severity severity,
-                                  grpc_slice data,
+                                  const grpc_slice& data,
                                   RefCountedPtr<BaseNode> referenced_channel) {
     trace_.AddTraceEventWithReference(severity, data,
                                       std::move(referenced_channel));
@@ -193,13 +172,35 @@ class ChannelNode : public BaseNode {
   void RecordCallFailed() { call_counter_.RecordCallFailed(); }
   void RecordCallSucceeded() { call_counter_.RecordCallSucceeded(); }
 
+  void SetConnectivityState(grpc_connectivity_state state);
+
+  void AddChildChannel(intptr_t child_uuid);
+  void RemoveChildChannel(intptr_t child_uuid);
+
+  void AddChildSubchannel(intptr_t child_uuid);
+  void RemoveChildSubchannel(intptr_t child_uuid);
+
  private:
+  void PopulateChildRefs(grpc_json* json);
+
   // to allow the channel trace test to access trace_.
   friend class testing::ChannelNodePeer;
-  grpc_channel* channel_ = nullptr;
+
   UniquePtr<char> target_;
   CallCountingHelper call_counter_;
   ChannelTrace trace_;
+  const intptr_t parent_uuid_;
+
+  // Least significant bit indicates whether the value is set.  Remaining
+  // bits are a grpc_connectivity_state value.
+  Atomic<int> connectivity_state_{0};
+
+  Mutex child_mu_;  // Guards child maps below.
+  // TODO(roth): We don't actually use the values here, only the keys, so
+  // these should be sets instead of maps, but we don't currently have a set
+  // implementation.  Change this if/when we have one.
+  Map<intptr_t, bool> child_channels_;
+  Map<intptr_t, bool> child_subchannels_;
 };
 
 // Handles channelz bookkeeping for servers
@@ -214,11 +215,11 @@ class ServerNode : public BaseNode {
                             intptr_t pagination_limit);
 
   // proxy methods to composed classes.
-  void AddTraceEvent(ChannelTrace::Severity severity, grpc_slice data) {
+  void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
     trace_.AddTraceEvent(severity, data);
   }
   void AddTraceEventWithReference(ChannelTrace::Severity severity,
-                                  grpc_slice data,
+                                  const grpc_slice& data,
                                   RefCountedPtr<BaseNode> referenced_channel) {
     trace_.AddTraceEventWithReference(severity, data,
                                       std::move(referenced_channel));
@@ -285,11 +286,6 @@ class ListenSocketNode : public BaseNode {
   UniquePtr<char> local_addr_;
 };
 
-// Creation functions
-
-typedef RefCountedPtr<ChannelNode> (*ChannelNodeCreationFunc)(grpc_channel*,
-                                                              size_t, bool);
-
 }  // namespace channelz
 }  // namespace grpc_core