grpc 1.27.0 → 1.28.0.pre2

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

@@ -91,11 +91,11 @@ class BaseNode : public RefCounted<BaseNode> {
   virtual ~BaseNode();
 
   // All children must implement this function.
-  virtual grpc_json* RenderJson() = 0;
+  virtual Json RenderJson() = 0;
 
   // Renders the json and returns allocated string that must be freed by the
   // caller.
-  char* RenderJsonString();
+  std::string RenderJsonString();
 
   EntityType type() const { return type_; }
   intptr_t uuid() const { return uuid_; }
@@ -124,7 +124,7 @@ class CallCountingHelper {
   void RecordCallSucceeded();
 
   // Common rendering of the call count data and last_call_started_timestamp.
-  void PopulateCallCounts(grpc_json* json);
+  void PopulateCallCounts(Json::Object* json);
 
  private:
   // testing peer friend.
@@ -148,17 +148,13 @@ class CallCountingHelper {
     // 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>)];
-  }
-#if GRPC_USE_ABSL
+  };
   // TODO(soheilhy,veblush): Revist this after abseil integration.
   // This has a problem when using abseil inlined_vector because it
   // carries an alignment attribute properly but our allocator doesn't
   // respect this. To avoid UBSAN errors, this should be removed with
   // abseil inlined_vector.
-  ;
-#else
-  GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
-#endif
+  // GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
 
   struct CounterData {
     int64_t calls_started = 0;
@@ -187,7 +183,7 @@ class ChannelNode : public BaseNode {
 
   intptr_t parent_uuid() const { return parent_uuid_; }
 
-  grpc_json* RenderJson() override;
+  Json RenderJson() override;
 
   // proxy methods to composed classes.
   void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
@@ -216,7 +212,7 @@ class ChannelNode : public BaseNode {
   void RemoveChildSubchannel(intptr_t child_uuid);
 
  private:
-  void PopulateChildRefs(grpc_json* json);
+  void PopulateChildRefs(Json::Object* json);
 
   // to allow the channel trace test to access trace_.
   friend class testing::ChannelNodePeer;
@@ -245,9 +241,10 @@ class ServerNode : public BaseNode {
 
   ~ServerNode() override;
 
-  grpc_json* RenderJson() override;
+  Json RenderJson() override;
 
-  char* RenderServerSockets(intptr_t start_socket_id, intptr_t max_results);
+  std::string RenderServerSockets(intptr_t start_socket_id,
+                                  intptr_t max_results);
 
   void AddChildSocket(RefCountedPtr<SocketNode> node);
 
@@ -285,7 +282,7 @@ class SocketNode : public BaseNode {
   SocketNode(std::string local, std::string remote, std::string name);
   ~SocketNode() override {}
 
-  grpc_json* RenderJson() override;
+  Json RenderJson() override;
 
   void RecordStreamStartedFromLocal();
   void RecordStreamStartedFromRemote();
@@ -324,7 +321,7 @@ class ListenSocketNode : public BaseNode {
   ListenSocketNode(std::string local_addr, std::string name);
   ~ListenSocketNode() override {}
 
-  grpc_json* RenderJson() override;
+  Json RenderJson() override;
 
  private:
   std::string local_addr_;

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

@@ -30,6 +30,7 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
 namespace grpc_core {
@@ -79,10 +80,8 @@ RefCountedPtr<BaseNode> ChannelzRegistry::InternalGet(intptr_t uuid) {
   return RefCountedPtr<BaseNode>(node);
 }
 
-char* ChannelzRegistry::InternalGetTopChannels(intptr_t start_channel_id) {
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* json_iterator = nullptr;
+std::string ChannelzRegistry::InternalGetTopChannels(
+    intptr_t start_channel_id) {
   InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
@@ -106,29 +105,21 @@ char* ChannelzRegistry::InternalGetTopChannels(intptr_t start_channel_id) {
       }
     }
   }
+  Json::Object object;
   if (!top_level_channels.empty()) {
-    // create list of channels
-    grpc_json* array_parent = grpc_json_create_child(
-        nullptr, json, "channel", nullptr, GRPC_JSON_ARRAY, false);
+    // Create list of channels.
+    Json::Array array;
     for (size_t i = 0; i < top_level_channels.size(); ++i) {
-      grpc_json* channel_json = top_level_channels[i]->RenderJson();
-      json_iterator =
-          grpc_json_link_child(array_parent, channel_json, json_iterator);
+      array.emplace_back(top_level_channels[i]->RenderJson());
     }
+    object["channel"] = std::move(array);
   }
-  if (node_after_pagination_limit == nullptr) {
-    grpc_json_create_child(nullptr, json, "end", nullptr, GRPC_JSON_TRUE,
-                           false);
-  }
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  if (node_after_pagination_limit == nullptr) object["end"] = true;
+  Json json(std::move(object));
+  return json.Dump();
 }
 
-char* ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* json_iterator = nullptr;
+std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
   InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
@@ -152,23 +143,18 @@ char* ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
       }
     }
   }
+  Json::Object object;
   if (!servers.empty()) {
-    // create list of servers
-    grpc_json* array_parent = grpc_json_create_child(
-        nullptr, json, "server", nullptr, GRPC_JSON_ARRAY, false);
+    // Create list of servers.
+    Json::Array array;
     for (size_t i = 0; i < servers.size(); ++i) {
-      grpc_json* server_json = servers[i]->RenderJson();
-      json_iterator =
-          grpc_json_link_child(array_parent, server_json, json_iterator);
+      array.emplace_back(servers[i]->RenderJson());
     }
+    object["server"] = std::move(array);
   }
-  if (node_after_pagination_limit == nullptr) {
-    grpc_json_create_child(nullptr, json, "end", nullptr, GRPC_JSON_TRUE,
-                           false);
-  }
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  if (node_after_pagination_limit == nullptr) object["end"] = true;
+  Json json(std::move(object));
+  return json.Dump();
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
@@ -183,9 +169,8 @@ void ChannelzRegistry::InternalLogAllEntities() {
     }
   }
   for (size_t i = 0; i < nodes.size(); ++i) {
-    char* json = nodes[i]->RenderJsonString();
-    gpr_log(GPR_INFO, "%s", json);
-    gpr_free(json);
+    std::string json = nodes[i]->RenderJsonString();
+    gpr_log(GPR_INFO, "%s", json.c_str());
   }
 }
 
@@ -193,12 +178,15 @@ void ChannelzRegistry::InternalLogAllEntities() {
 }  // namespace grpc_core
 
 char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
-  return grpc_core::channelz::ChannelzRegistry::GetTopChannels(
-      start_channel_id);
+  return gpr_strdup(
+      grpc_core::channelz::ChannelzRegistry::GetTopChannels(start_channel_id)
+          .c_str());
 }
 
 char* grpc_channelz_get_servers(intptr_t start_server_id) {
-  return grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id);
+  return gpr_strdup(
+      grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id)
+          .c_str());
 }
 
 char* grpc_channelz_get_server(intptr_t server_id) {
@@ -209,14 +197,10 @@ char* grpc_channelz_get_server(intptr_t server_id) {
           grpc_core::channelz::BaseNode::EntityType::kServer) {
     return nullptr;
   }
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* channel_json = server_node->RenderJson();
-  channel_json->key = "server";
-  grpc_json_link_child(json, channel_json, nullptr);
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  grpc_core::Json json = grpc_core::Json::Object{
+      {"server", server_node->RenderJson()},
+  };
+  return gpr_strdup(json.Dump().c_str());
 }
 
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
@@ -229,10 +213,11 @@ char* grpc_channelz_get_server_sockets(intptr_t server_id,
     return nullptr;
   }
   // This cast is ok since we have just checked to make sure base_node is
-  // actually a server node
+  // actually a server node.
   grpc_core::channelz::ServerNode* server_node =
       static_cast<grpc_core::channelz::ServerNode*>(base_node.get());
-  return server_node->RenderServerSockets(start_socket_id, max_results);
+  return gpr_strdup(
+      server_node->RenderServerSockets(start_socket_id, max_results).c_str());
 }
 
 char* grpc_channelz_get_channel(intptr_t channel_id) {
@@ -245,14 +230,10 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
            grpc_core::channelz::BaseNode::EntityType::kInternalChannel)) {
     return nullptr;
   }
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* channel_json = channel_node->RenderJson();
-  channel_json->key = "channel";
-  grpc_json_link_child(json, channel_json, nullptr);
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  grpc_core::Json json = grpc_core::Json::Object{
+      {"channel", channel_node->RenderJson()},
+  };
+  return gpr_strdup(json.Dump().c_str());
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
@@ -263,14 +244,10 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
           grpc_core::channelz::BaseNode::EntityType::kSubchannel) {
     return nullptr;
   }
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* subchannel_json = subchannel_node->RenderJson();
-  subchannel_json->key = "subchannel";
-  grpc_json_link_child(json, subchannel_json, nullptr);
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  grpc_core::Json json = grpc_core::Json::Object{
+      {"subchannel", subchannel_node->RenderJson()},
+  };
+  return gpr_strdup(json.Dump().c_str());
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
@@ -281,12 +258,8 @@ char* grpc_channelz_get_socket(intptr_t socket_id) {
           grpc_core::channelz::BaseNode::EntityType::kSocket) {
     return nullptr;
   }
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* socket_json = socket_node->RenderJson();
-  socket_json->key = "socket";
-  grpc_json_link_child(json, socket_json, nullptr);
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  grpc_core::Json json = grpc_core::Json::Object{
+      {"socket", socket_node->RenderJson()},
+  };
+  return gpr_strdup(json.Dump().c_str());
 }

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

@@ -51,13 +51,13 @@ class ChannelzRegistry {
 
   // Returns the allocated JSON string that represents the proto
   // GetTopChannelsResponse as per channelz.proto.
-  static char* GetTopChannels(intptr_t start_channel_id) {
+  static std::string GetTopChannels(intptr_t start_channel_id) {
     return Default()->InternalGetTopChannels(start_channel_id);
   }
 
   // Returns the allocated JSON string that represents the proto
   // GetServersResponse as per channelz.proto.
-  static char* GetServers(intptr_t start_server_id) {
+  static std::string GetServers(intptr_t start_server_id) {
     return Default()->InternalGetServers(start_server_id);
   }
 
@@ -80,8 +80,8 @@ class ChannelzRegistry {
   // returns the void* associated with that uuid. Else returns nullptr.
   RefCountedPtr<BaseNode> InternalGet(intptr_t uuid);
 
-  char* InternalGetTopChannels(intptr_t start_channel_id);
-  char* InternalGetServers(intptr_t start_server_id);
+  std::string InternalGetTopChannels(intptr_t start_channel_id);
+  std::string InternalGetServers(intptr_t start_server_id);
 
   void InternalLogAllEntities();
 

data/src/core/lib/gpr/sync_abseil.cc

@@ -0,0 +1,114 @@
+/*
+ *
+ * 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>
+
+#if defined(GPR_ABSEIL_SYNC) && !defined(GPR_CUSTOM_SYNC)
+
+#include <grpc/support/alloc.h>
+
+#include <errno.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/time.h>
+#include <time.h>
+#include "src/core/lib/profiling/timers.h"
+
+#include "absl/base/call_once.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+#ifdef GPR_LOW_LEVEL_COUNTERS
+gpr_atm gpr_mu_locks = 0;
+gpr_atm gpr_counter_atm_cas = 0;
+gpr_atm gpr_counter_atm_add = 0;
+#endif
+
+void gpr_mu_init(gpr_mu* mu) {
+  static_assert(sizeof(gpr_mu) == sizeof(absl::Mutex),
+                "gpr_mu and Mutex must be the same size");
+  new (mu) absl::Mutex;
+}
+
+void gpr_mu_destroy(gpr_mu* mu) {
+  reinterpret_cast<absl::Mutex*>(mu)->~Mutex();
+}
+
+void gpr_mu_lock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  GPR_TIMER_SCOPE("gpr_mu_lock", 0);
+  reinterpret_cast<absl::Mutex*>(mu)->Lock();
+}
+
+void gpr_mu_unlock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  GPR_TIMER_SCOPE("gpr_mu_unlock", 0);
+  reinterpret_cast<absl::Mutex*>(mu)->Unlock();
+}
+
+int gpr_mu_trylock(gpr_mu* mu) {
+  GPR_TIMER_SCOPE("gpr_mu_trylock", 0);
+  int ret = reinterpret_cast<absl::Mutex*>(mu)->TryLock() == true;
+  return ret;
+}
+
+/*----------------------------------------*/
+
+void gpr_cv_init(gpr_cv* cv) {
+  static_assert(sizeof(gpr_cv) == sizeof(absl::CondVar),
+                "gpr_cv and CondVar must be the same size");
+  new (cv) absl::CondVar;
+}
+
+void gpr_cv_destroy(gpr_cv* cv) {
+  reinterpret_cast<absl::CondVar*>(cv)->~CondVar();
+}
+
+int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
+  GPR_TIMER_SCOPE("gpr_cv_wait", 0);
+  if (gpr_time_cmp(abs_deadline, gpr_inf_future(abs_deadline.clock_type)) ==
+      0) {
+    reinterpret_cast<absl::CondVar*>(cv)->Wait(
+        reinterpret_cast<absl::Mutex*>(mu));
+    return 0;
+  }
+  abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME);
+  timespec ts = {static_cast<decltype(ts.tv_sec)>(abs_deadline.tv_sec),
+                 static_cast<decltype(ts.tv_nsec)>(abs_deadline.tv_nsec)};
+  int ret = reinterpret_cast<absl::CondVar*>(cv)->WaitWithDeadline(
+                reinterpret_cast<absl::Mutex*>(mu),
+                absl::TimeFromTimespec(ts)) == true;
+  return ret;
+}
+
+void gpr_cv_signal(gpr_cv* cv) {
+  GPR_TIMER_MARK("gpr_cv_signal", 0);
+  reinterpret_cast<absl::CondVar*>(cv)->Signal();
+}
+
+void gpr_cv_broadcast(gpr_cv* cv) {
+  GPR_TIMER_MARK("gpr_cv_broadcast", 0);
+  reinterpret_cast<absl::CondVar*>(cv)->SignalAll();
+}
+
+/*----------------------------------------*/
+
+void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
+  absl::call_once(*reinterpret_cast<absl::once_flag*>(once), init_function);
+}
+
+#endif /* defined(GPR_ABSEIL_SYNC) && !defined(GPR_CUSTOM_SYNC) */

data/src/core/lib/gpr/sync_posix.cc

@@ -18,15 +18,17 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/alloc.h>
-
-#ifdef GPR_POSIX_SYNC
+#if defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) && \
+    !defined(GPR_CUSTOM_SYNC)
 
-#include <errno.h>
+#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
+
+#include <errno.h>
 #include <time.h>
+
 #include "src/core/lib/profiling/timers.h"
 
 #ifdef GPR_LOW_LEVEL_COUNTERS
@@ -170,4 +172,5 @@ void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
   GPR_ASSERT(pthread_once(once, init_function) == 0);
 }
 
-#endif /* GRP_POSIX_SYNC */
+#endif /* defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) && \
+          !defined(GPR_CUSTOM_SYNC) */