grpc 1.32.0 → 1.52.0

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

@@ -1,68 +1,72 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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_CHANNELZ_H
 #define GRPC_CORE_LIB_CHANNEL_CHANNELZ_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
+#include <stddef.h>
 
+#include <atomic>
+#include <cstdint>
+#include <map>
+#include <set>
 #include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
-#include "absl/container/inlined_vector.h"
+#include <grpc/grpc.h>
+#include <grpc/impl/connectivity_state.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/atomic.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
-#include "src/core/lib/gprpp/map.h"
+#include "src/core/lib/gpr/useful.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.
-#define GRPC_ARG_CHANNELZ_CHANNEL_NODE "grpc.channelz_channel_node"
+#define GRPC_ARG_CHANNELZ_CHANNEL_NODE "grpc.internal.channelz_channel_node"
 
-// Channel arg key to encode the channelz uuid of the channel's parent.
-#define GRPC_ARG_CHANNELZ_PARENT_UUID "grpc.channelz_parent_uuid"
+// Channel arg key for indicating an internal channel.
+#define GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL \
+  "grpc.channelz_is_internal_channel"
 
-/** 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. */
+/// 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.
 #define GRPC_ENABLE_CHANNELZ_DEFAULT true
 
-/** This is the default value for the maximum amount of memory used by trace
- * events per channel trace node. If
- * GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE is set, it will override
- * this default value. */
-#define GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT 1024 * 4
+/// This is the default value for the maximum amount of memory used by trace
+/// events per channel trace node. If
+/// GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE is set, it will override
+/// this default value.
+#define GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT (1024 * 4)
 
 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);
-
 class SocketNode;
 class ListenSocketNode;
 
@@ -89,7 +93,7 @@ class BaseNode : public RefCounted<BaseNode> {
   BaseNode(EntityType type, std::string name);
 
  public:
-  virtual ~BaseNode();
+  ~BaseNode() override;
 
   // All children must implement this function.
   virtual Json RenderJson() = 0;
@@ -136,19 +140,19 @@ class CallCountingHelper {
     // Define the ctors so that we can use this structure in InlinedVector.
     AtomicCounterData() = default;
     AtomicCounterData(const AtomicCounterData& that)
-        : calls_started(that.calls_started.Load(MemoryOrder::RELAXED)),
-          calls_succeeded(that.calls_succeeded.Load(MemoryOrder::RELAXED)),
-          calls_failed(that.calls_failed.Load(MemoryOrder::RELAXED)),
+        : calls_started(that.calls_started.load(std::memory_order_relaxed)),
+          calls_succeeded(that.calls_succeeded.load(std::memory_order_relaxed)),
+          calls_failed(that.calls_failed.load(std::memory_order_relaxed)),
           last_call_started_cycle(
-              that.last_call_started_cycle.Load(MemoryOrder::RELAXED)) {}
+              that.last_call_started_cycle.load(std::memory_order_relaxed)) {}
 
-    Atomic<int64_t> calls_started{0};
-    Atomic<int64_t> calls_succeeded{0};
-    Atomic<int64_t> calls_failed{0};
-    Atomic<gpr_cycle_counter> last_call_started_cycle{0};
+    std::atomic<int64_t> calls_started{0};
+    std::atomic<int64_t> calls_succeeded{0};
+    std::atomic<int64_t> calls_failed{0};
+    std::atomic<gpr_cycle_counter> last_call_started_cycle{0};
     // Make sure the size is exactly one cache line.
-    uint8_t padding[GPR_CACHELINE_SIZE - 3 * sizeof(Atomic<intptr_t>) -
-                    sizeof(Atomic<gpr_cycle_counter>)];
+    uint8_t padding[GPR_CACHELINE_SIZE - 3 * sizeof(std::atomic<intptr_t>) -
+                    sizeof(std::atomic<gpr_cycle_counter>)];
   };
   // TODO(soheilhy,veblush): Revist this after abseil integration.
   // This has a problem when using abseil inlined_vector because it
@@ -167,8 +171,7 @@ class CallCountingHelper {
   // collects the sharded data into one CounterData struct.
   void CollectData(CounterData* out);
 
-  // Really zero-sized, but 0-sized arrays are illegal on MSVC.
-  absl::InlinedVector<AtomicCounterData, 1> per_cpu_counter_data_storage_;
+  std::vector<AtomicCounterData> per_cpu_counter_data_storage_;
   size_t num_cores_ = 0;
 };
 
@@ -176,14 +179,16 @@ class CallCountingHelper {
 class ChannelNode : public BaseNode {
  public:
   ChannelNode(std::string target, size_t channel_tracer_max_nodes,
-              intptr_t parent_uuid);
+              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);
 
-  intptr_t parent_uuid() const { return parent_uuid_; }
-
   Json RenderJson() override;
 
   // proxy methods to composed classes.
@@ -213,26 +218,22 @@ class ChannelNode : public BaseNode {
   void RemoveChildSubchannel(intptr_t child_uuid);
 
  private:
-  void PopulateChildRefs(Json::Object* json);
-
-  // to allow the channel trace test to access trace_.
+  // Allows the channel trace test to access trace_.
   friend class testing::ChannelNodePeer;
 
+  void PopulateChildRefs(Json::Object* json);
+
   std::string 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};
+  std::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.
-  std::map<intptr_t, bool> child_channels_;
-  std::map<intptr_t, bool> child_subchannels_;
+  Mutex child_mu_;  // Guards sets below.
+  std::set<intptr_t> child_channels_;
+  std::set<intptr_t> child_subchannels_;
 };
 
 // Handles channelz bookkeeping for servers
@@ -277,10 +278,48 @@ class ServerNode : public BaseNode {
   std::map<intptr_t, RefCountedPtr<ListenSocketNode>> child_listen_sockets_;
 };
 
+#define GRPC_ARG_CHANNELZ_SECURITY "grpc.internal.channelz_security"
+
 // Handles channelz bookkeeping for sockets
 class SocketNode : public BaseNode {
  public:
-  SocketNode(std::string local, std::string remote, std::string name);
+  struct Security : public RefCounted<Security> {
+    struct Tls {
+      // This is a workaround for https://bugs.llvm.org/show_bug.cgi?id=50346
+      Tls() {}
+
+      enum class NameType { kUnset = 0, kStandardName = 1, kOtherName = 2 };
+      NameType type = NameType::kUnset;
+      // Holds the value of standard_name or other_names if type is not kUnset.
+      std::string name;
+      std::string local_certificate;
+      std::string remote_certificate;
+
+      Json RenderJson();
+    };
+    enum class ModelType { kUnset = 0, kTls = 1, kOther = 2 };
+    ModelType type = ModelType::kUnset;
+    absl::optional<Tls> tls;
+    absl::optional<Json> other;
+
+    Json RenderJson();
+
+    static absl::string_view ChannelArgName() {
+      return GRPC_ARG_CHANNELZ_SECURITY;
+    }
+
+    static int ChannelArgsCompare(const Security* a, const Security* b) {
+      return QsortCompare(a, b);
+    }
+
+    grpc_arg MakeChannelArg() const;
+
+    static RefCountedPtr<Security> GetFromChannelArgs(
+        const grpc_channel_args* args);
+  };
+
+  SocketNode(std::string local, std::string remote, std::string name,
+             RefCountedPtr<Security> security);
   ~SocketNode() override {}
 
   Json RenderJson() override;
@@ -288,32 +327,33 @@ class SocketNode : public BaseNode {
   void RecordStreamStartedFromLocal();
   void RecordStreamStartedFromRemote();
   void RecordStreamSucceeded() {
-    streams_succeeded_.FetchAdd(1, MemoryOrder::RELAXED);
+    streams_succeeded_.fetch_add(1, std::memory_order_relaxed);
   }
   void RecordStreamFailed() {
-    streams_failed_.FetchAdd(1, MemoryOrder::RELAXED);
+    streams_failed_.fetch_add(1, std::memory_order_relaxed);
   }
   void RecordMessagesSent(uint32_t num_sent);
   void RecordMessageReceived();
   void RecordKeepaliveSent() {
-    keepalives_sent_.FetchAdd(1, MemoryOrder::RELAXED);
+    keepalives_sent_.fetch_add(1, std::memory_order_relaxed);
   }
 
   const std::string& remote() { return remote_; }
 
  private:
-  Atomic<int64_t> streams_started_{0};
-  Atomic<int64_t> streams_succeeded_{0};
-  Atomic<int64_t> streams_failed_{0};
-  Atomic<int64_t> messages_sent_{0};
-  Atomic<int64_t> messages_received_{0};
-  Atomic<int64_t> keepalives_sent_{0};
-  Atomic<gpr_cycle_counter> last_local_stream_created_cycle_{0};
-  Atomic<gpr_cycle_counter> last_remote_stream_created_cycle_{0};
-  Atomic<gpr_cycle_counter> last_message_sent_cycle_{0};
-  Atomic<gpr_cycle_counter> last_message_received_cycle_{0};
+  std::atomic<int64_t> streams_started_{0};
+  std::atomic<int64_t> streams_succeeded_{0};
+  std::atomic<int64_t> streams_failed_{0};
+  std::atomic<int64_t> messages_sent_{0};
+  std::atomic<int64_t> messages_received_{0};
+  std::atomic<int64_t> keepalives_sent_{0};
+  std::atomic<gpr_cycle_counter> last_local_stream_created_cycle_{0};
+  std::atomic<gpr_cycle_counter> last_remote_stream_created_cycle_{0};
+  std::atomic<gpr_cycle_counter> last_message_sent_cycle_{0};
+  std::atomic<gpr_cycle_counter> last_message_received_cycle_{0};
   std::string local_;
   std::string remote_;
+  RefCountedPtr<Security> const security_;
 };
 
 // Handles channelz bookkeeping for listen sockets
@@ -331,4 +371,4 @@ class ListenSocketNode : public BaseNode {
 }  // namespace channelz
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_CHANNEL_CHANNELZ_H */
+#endif  // GRPC_CORE_LIB_CHANNEL_CHANNELZ_H

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

@@ -1,58 +1,51 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
+//
+//
+// Copyright 2017 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/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channelz_registry.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <cstring>
+#include <utility>
+#include <vector>
 
-#include "absl/container/inlined_vector.h"
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/channel/channelz_registry.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/sync.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/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) {
@@ -78,21 +71,21 @@ RefCountedPtr<BaseNode> ChannelzRegistry::InternalGet(intptr_t uuid) {
   // Found node.  Return only if its refcount is not zero (i.e., when we
   // know that there is no other thread about to destroy it).
   BaseNode* node = it->second;
-  if (!node->RefIfNonZero()) return nullptr;
-  return RefCountedPtr<BaseNode>(node);
+  return node->RefIfNonZero();
 }
 
 std::string ChannelzRegistry::InternalGetTopChannels(
     intptr_t start_channel_id) {
-  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
+  std::vector<RefCountedPtr<BaseNode>> top_level_channels;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
     for (auto it = node_map_.lower_bound(start_channel_id);
          it != node_map_.end(); ++it) {
       BaseNode* node = it->second;
+      RefCountedPtr<BaseNode> node_ref;
       if (node->type() == BaseNode::EntityType::kTopLevelChannel &&
-          node->RefIfNonZero()) {
+          (node_ref = node->RefIfNonZero()) != nullptr) {
         // Check if we are over pagination limit to determine if we need to set
         // the "end" element. If we don't go through this block, we know that
         // when the loop terminates, we have <= to kPaginationLimit.
@@ -100,10 +93,10 @@ std::string ChannelzRegistry::InternalGetTopChannels(
         // refcount, we need to decrease it, but we can't unref while
         // holding the lock, because this may lead to a deadlock.
         if (top_level_channels.size() == kPaginationLimit) {
-          node_after_pagination_limit.reset(node);
+          node_after_pagination_limit = std::move(node_ref);
           break;
         }
-        top_level_channels.emplace_back(node);
+        top_level_channels.emplace_back(std::move(node_ref));
       }
     }
   }
@@ -122,15 +115,16 @@ std::string ChannelzRegistry::InternalGetTopChannels(
 }
 
 std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
-  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
+  std::vector<RefCountedPtr<BaseNode>> servers;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
     for (auto it = node_map_.lower_bound(start_server_id);
          it != node_map_.end(); ++it) {
       BaseNode* node = it->second;
+      RefCountedPtr<BaseNode> node_ref;
       if (node->type() == BaseNode::EntityType::kServer &&
-          node->RefIfNonZero()) {
+          (node_ref = node->RefIfNonZero()) != nullptr) {
         // Check if we are over pagination limit to determine if we need to set
         // the "end" element. If we don't go through this block, we know that
         // when the loop terminates, we have <= to kPaginationLimit.
@@ -138,10 +132,10 @@ std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
         // refcount, we need to decrease it, but we can't unref while
         // holding the lock, because this may lead to a deadlock.
         if (servers.size() == kPaginationLimit) {
-          node_after_pagination_limit.reset(node);
+          node_after_pagination_limit = std::move(node_ref);
           break;
         }
-        servers.emplace_back(node);
+        servers.emplace_back(std::move(node_ref));
       }
     }
   }
@@ -160,13 +154,13 @@ std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
-  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
+  std::vector<RefCountedPtr<BaseNode>> nodes;
   {
     MutexLock lock(&mu_);
     for (auto& p : node_map_) {
-      BaseNode* node = p.second;
-      if (node->RefIfNonZero()) {
-        nodes.emplace_back(node);
+      RefCountedPtr<BaseNode> node = p.second->RefIfNonZero();
+      if (node != nullptr) {
+        nodes.emplace_back(std::move(node));
       }
     }
   }
@@ -180,18 +174,24 @@ void ChannelzRegistry::InternalLogAllEntities() {
 }  // namespace grpc_core
 
 char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   return gpr_strdup(
       grpc_core::channelz::ChannelzRegistry::GetTopChannels(start_channel_id)
           .c_str());
 }
 
 char* grpc_channelz_get_servers(intptr_t start_server_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   return gpr_strdup(
       grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id)
           .c_str());
 }
 
 char* grpc_channelz_get_server(intptr_t server_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> server_node =
       grpc_core::channelz::ChannelzRegistry::Get(server_id);
   if (server_node == nullptr ||
@@ -208,6 +208,8 @@ char* grpc_channelz_get_server(intptr_t server_id) {
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
                                        intptr_t start_socket_id,
                                        intptr_t max_results) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   // Validate inputs before handing them of to the renderer.
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> base_node =
       grpc_core::channelz::ChannelzRegistry::Get(server_id);
@@ -225,6 +227,8 @@ char* grpc_channelz_get_server_sockets(intptr_t server_id,
 }
 
 char* grpc_channelz_get_channel(intptr_t channel_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> channel_node =
       grpc_core::channelz::ChannelzRegistry::Get(channel_id);
   if (channel_node == nullptr ||
@@ -241,6 +245,8 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> subchannel_node =
       grpc_core::channelz::ChannelzRegistry::Get(subchannel_id);
   if (subchannel_node == nullptr ||
@@ -255,6 +261,8 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> socket_node =
       grpc_core::channelz::ChannelzRegistry::Get(socket_id);
   if (socket_node == nullptr ||

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

@@ -1,31 +1,32 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
+//
+//
+// Copyright 2017 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_CHANNELZ_REGISTRY_H
 #define GRPC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#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/map.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_core {
@@ -35,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);
   }
@@ -65,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();
@@ -94,4 +97,4 @@ class ChannelzRegistry {
 }  // namespace channelz
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H */
+#endif  // GRPC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H