grpc 1.55.0 → 1.56.0.pre3

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

@@ -27,6 +27,7 @@
 #include <vector>
 
 #include <grpc/grpc.h>
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
@@ -108,11 +109,12 @@ std::string ChannelzRegistry::InternalGetTopChannels(
     for (size_t i = 0; i < top_level_channels.size(); ++i) {
       array.emplace_back(top_level_channels[i]->RenderJson());
     }
-    object["channel"] = std::move(array);
+    object["channel"] = Json::FromArray(std::move(array));
   }
-  if (node_after_pagination_limit == nullptr) object["end"] = true;
-  Json json(std::move(object));
-  return JsonDump(json);
+  if (node_after_pagination_limit == nullptr) {
+    object["end"] = Json::FromBool(true);
+  }
+  return JsonDump(Json::FromObject(std::move(object)));
 }
 
 std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
@@ -147,11 +149,12 @@ std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
     for (size_t i = 0; i < servers.size(); ++i) {
       array.emplace_back(servers[i]->RenderJson());
     }
-    object["server"] = std::move(array);
+    object["server"] = Json::FromArray(std::move(array));
+  }
+  if (node_after_pagination_limit == nullptr) {
+    object["end"] = Json::FromBool(true);
   }
-  if (node_after_pagination_limit == nullptr) object["end"] = true;
-  Json json(std::move(object));
-  return JsonDump(json);
+  return JsonDump(Json::FromObject(std::move(object)));
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
@@ -200,10 +203,10 @@ char* grpc_channelz_get_server(intptr_t server_id) {
           grpc_core::channelz::BaseNode::EntityType::kServer) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
+  grpc_core::Json json = grpc_core::Json::FromObject({
       {"server", server_node->RenderJson()},
-  };
-  return gpr_strdup(JsonDump(json).c_str());
+  });
+  return gpr_strdup(grpc_core::JsonDump(json).c_str());
 }
 
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
@@ -239,10 +242,10 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
            grpc_core::channelz::BaseNode::EntityType::kInternalChannel)) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
+  grpc_core::Json json = grpc_core::Json::FromObject({
       {"channel", channel_node->RenderJson()},
-  };
-  return gpr_strdup(JsonDump(json).c_str());
+  });
+  return gpr_strdup(grpc_core::JsonDump(json).c_str());
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
@@ -255,10 +258,10 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
           grpc_core::channelz::BaseNode::EntityType::kSubchannel) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
+  grpc_core::Json json = grpc_core::Json::FromObject({
       {"subchannel", subchannel_node->RenderJson()},
-  };
-  return gpr_strdup(JsonDump(json).c_str());
+  });
+  return gpr_strdup(grpc_core::JsonDump(json).c_str());
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
@@ -271,8 +274,8 @@ char* grpc_channelz_get_socket(intptr_t socket_id) {
           grpc_core::channelz::BaseNode::EntityType::kSocket) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
+  grpc_core::Json json = grpc_core::Json::FromObject({
       {"socket", socket_node->RenderJson()},
-  };
-  return gpr_strdup(JsonDump(json).c_str());
+  });
+  return gpr_strdup(grpc_core::JsonDump(json).c_str());
 }

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

@@ -710,13 +710,16 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
 
   // Promise factory that accepts a ServerMetadataHandle, and sends it as the
   // trailing metadata for this call.
-  auto send_trailing_metadata =
-      [call_data, stream = stream->InternalRef()](
-          ServerMetadataHandle server_trailing_metadata) {
-        return GetContext<BatchBuilder>()->SendServerTrailingMetadata(
-            stream->batch_target(), std::move(server_trailing_metadata),
+  auto send_trailing_metadata = [call_data, stream = stream->InternalRef()](
+                                    ServerMetadataHandle
+                                        server_trailing_metadata) {
+    bool is_cancellation =
+        server_trailing_metadata->get(GrpcCallWasCancelled()).value_or(false);
+    return GetContext<BatchBuilder>()->SendServerTrailingMetadata(
+        stream->batch_target(), std::move(server_trailing_metadata),
+        is_cancellation ||
             !std::exchange(call_data->sent_initial_metadata, true));
-      };
+  };
 
   // Runs the receive message loop, either until all the messages
   // are received or the server call is complete.
@@ -821,11 +824,19 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
   auto cleanup_polling_entity_latch =
       std::unique_ptr<Latch<grpc_polling_entity>, CleanupPollingEntityLatch>(
           &call_data->polling_entity_latch);
+  struct CleanupSendInitialMetadata {
+    void operator()(CallData* call_data) {
+      call_data->server_initial_metadata.receiver.CloseWithError();
+    }
+  };
+  auto cleanup_send_initial_metadata =
+      std::unique_ptr<CallData, CleanupSendInitialMetadata>(call_data);
 
   return Map(
       Seq(std::move(recv_initial_metadata_then_run_promise),
           std::move(send_trailing_metadata)),
       [cleanup_polling_entity_latch = std::move(cleanup_polling_entity_latch),
+       cleanup_send_initial_metadata = std::move(cleanup_send_initial_metadata),
        stream = std::move(stream)](ServerMetadataHandle md) {
         stream->set_finished();
         return md;

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

@@ -245,10 +245,6 @@ void BaseCallData::CapturedBatch::CancelWith(grpc_error_handle error,
   uintptr_t& refcnt = *RefCountField(batch);
   if (refcnt == 0) {
     // refcnt==0 ==> cancelled
-    if (grpc_trace_channel.enabled()) {
-      gpr_log(GPR_INFO, "%sCANCEL BATCH REQUEST ALREADY CANCELLED",
-              Activity::current()->DebugTag().c_str());
-    }
     return;
   }
   refcnt = 0;

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

@@ -48,6 +48,7 @@
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/event_engine/default_event_engine.h"  // IWYU pragma: keep
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/call_combiner.h"
@@ -546,6 +547,7 @@ class BaseCallData : public Activity, private Wakeable {
  private:
   // Wakeable implementation.
   void Wakeup(WakeupMask) final;
+  void WakeupAsync(WakeupMask) final { Crash("not implemented"); }
   void Drop(WakeupMask) final;
 
   virtual void OnWakeup() = 0;

data/src/core/lib/compression/compression_internal.cc

@@ -22,13 +22,10 @@
 
 #include <stdlib.h>
 
-#include <string>
-
 #include "absl/container/inlined_vector.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
-#include "absl/types/variant.h"
 
 #include <grpc/support/log.h>
 
@@ -230,10 +227,10 @@ absl::optional<grpc_compression_algorithm>
 DefaultCompressionAlgorithmFromChannelArgs(const ChannelArgs& args) {
   auto* value = args.Get(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);
   if (value == nullptr) return absl::nullopt;
-  if (auto* p = absl::get_if<int>(value)) {
+  if (auto* p = value->GetIfInt()) {
     return static_cast<grpc_compression_algorithm>(*p);
   }
-  if (auto* p = absl::get_if<std::string>(value)) {
+  if (auto* p = value->GetIfString()) {
     return ParseCompressionAlgorithm(*p);
   }
   return absl::nullopt;

data/src/core/lib/config/config_vars.cc

@@ -20,6 +20,9 @@
 
 #include "src/core/lib/config/config_vars.h"
 
+#include <algorithm>
+#include <vector>
+
 #include "absl/flags/flag.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
@@ -36,46 +39,45 @@
 #define GRPC_ENABLE_FORK_SUPPORT_DEFAULT false
 #endif  // GRPC_ENABLE_FORK_SUPPORT
 
-ABSL_FLAG(absl::optional<std::string>, grpc_experiments, absl::nullopt,
+ABSL_FLAG(std::vector<std::string>, grpc_experiments, {},
           "A comma separated list of currently active experiments. Experiments "
           "may be prefixed with a '-' to disable them.");
 ABSL_FLAG(absl::optional<int32_t>, grpc_client_channel_backup_poll_interval_ms,
-          absl::nullopt,
+          {},
           "Declares the interval in ms between two backup polls on client "
           "channels. These polls are run in the timer thread so that gRPC can "
           "process connection failures while there is no active polling "
           "thread. They help reconnect disconnected client channels (mostly "
           "due to idleness), so that the next RPC on this channel won't fail. "
           "Set to 0 to turn off the backup polls.");
-ABSL_FLAG(absl::optional<std::string>, grpc_dns_resolver, absl::nullopt,
+ABSL_FLAG(absl::optional<std::string>, grpc_dns_resolver, {},
           "Declares which DNS resolver to use. The default is ares if gRPC is "
           "built with c-ares support. Otherwise, the value of this environment "
           "variable is ignored.");
-ABSL_FLAG(absl::optional<std::string>, grpc_trace, absl::nullopt,
+ABSL_FLAG(std::vector<std::string>, grpc_trace, {},
           "A comma separated list of tracers that provide additional insight "
           "into how gRPC C core is processing requests via debug logs.");
-ABSL_FLAG(absl::optional<std::string>, grpc_verbosity, absl::nullopt,
+ABSL_FLAG(absl::optional<std::string>, grpc_verbosity, {},
           "Default gRPC logging verbosity");
-ABSL_FLAG(absl::optional<std::string>, grpc_stacktrace_minloglevel,
-          absl::nullopt,
+ABSL_FLAG(absl::optional<std::string>, grpc_stacktrace_minloglevel, {},
           "Messages logged at the same or higher level than this will print "
           "stacktrace");
-ABSL_FLAG(absl::optional<bool>, grpc_enable_fork_support, absl::nullopt,
+ABSL_FLAG(absl::optional<bool>, grpc_enable_fork_support, {},
           "Enable fork support");
-ABSL_FLAG(absl::optional<std::string>, grpc_poll_strategy, absl::nullopt,
+ABSL_FLAG(absl::optional<std::string>, grpc_poll_strategy, {},
           "Declares which polling engines to try when starting gRPC. This is a "
           "comma-separated list of engines, which are tried in priority order "
           "first -> last.");
-ABSL_FLAG(absl::optional<bool>, grpc_abort_on_leaks, absl::nullopt,
+ABSL_FLAG(absl::optional<bool>, grpc_abort_on_leaks, {},
           "A debugging aid to cause a call to abort() when gRPC objects are "
           "leaked past grpc_shutdown()");
-ABSL_FLAG(absl::optional<std::string>, grpc_system_ssl_roots_dir, absl::nullopt,
+ABSL_FLAG(absl::optional<std::string>, grpc_system_ssl_roots_dir, {},
           "Custom directory to SSL Roots");
-ABSL_FLAG(absl::optional<std::string>, grpc_default_ssl_roots_file_path,
-          absl::nullopt, "Path to the default SSL roots file.");
-ABSL_FLAG(absl::optional<bool>, grpc_not_use_system_ssl_roots, absl::nullopt,
+ABSL_FLAG(absl::optional<std::string>, grpc_default_ssl_roots_file_path, {},
+          "Path to the default SSL roots file.");
+ABSL_FLAG(absl::optional<bool>, grpc_not_use_system_ssl_roots, {},
           "Disable loading system root certificates.");
-ABSL_FLAG(absl::optional<std::string>, grpc_ssl_cipher_suites, absl::nullopt,
+ABSL_FLAG(absl::optional<std::string>, grpc_ssl_cipher_suites, {},
           "A colon separated list of cipher suites to use with OpenSSL");
 
 namespace grpc_core {
@@ -94,11 +96,8 @@ ConfigVars::ConfigVars(const Overrides& overrides)
       not_use_system_ssl_roots_(LoadConfig(
           FLAGS_grpc_not_use_system_ssl_roots, "GRPC_NOT_USE_SYSTEM_SSL_ROOTS",
           overrides.not_use_system_ssl_roots, false)),
-      experiments_(LoadConfig(FLAGS_grpc_experiments, "GRPC_EXPERIMENTS",
-                              overrides.experiments, "")),
       dns_resolver_(LoadConfig(FLAGS_grpc_dns_resolver, "GRPC_DNS_RESOLVER",
                                overrides.dns_resolver, "")),
-      trace_(LoadConfig(FLAGS_grpc_trace, "GRPC_TRACE", overrides.trace, "")),
       verbosity_(LoadConfig(FLAGS_grpc_verbosity, "GRPC_VERBOSITY",
                             overrides.verbosity,
                             GPR_DEFAULT_LOG_VERBOSITY_STRING)),
@@ -113,6 +112,9 @@ ConfigVars::ConfigVars(const Overrides& overrides)
           "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_"
           "SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:"
           "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384")),
+      experiments_(LoadConfig(FLAGS_grpc_experiments, "GRPC_EXPERIMENTS",
+                              overrides.experiments, "")),
+      trace_(LoadConfig(FLAGS_grpc_trace, "GRPC_TRACE", overrides.trace, "")),
       override_system_ssl_roots_dir_(overrides.system_ssl_roots_dir),
       override_default_ssl_roots_file_path_(
           overrides.default_ssl_roots_file_path) {}

data/src/core/lib/config/config_vars.h

@@ -38,15 +38,15 @@ class ConfigVars {
     absl::optional<bool> enable_fork_support;
     absl::optional<bool> abort_on_leaks;
     absl::optional<bool> not_use_system_ssl_roots;
-    absl::optional<std::string> experiments;
     absl::optional<std::string> dns_resolver;
-    absl::optional<std::string> trace;
     absl::optional<std::string> verbosity;
     absl::optional<std::string> stacktrace_minloglevel;
     absl::optional<std::string> poll_strategy;
     absl::optional<std::string> system_ssl_roots_dir;
     absl::optional<std::string> default_ssl_roots_file_path;
     absl::optional<std::string> ssl_cipher_suites;
+    absl::optional<std::string> experiments;
+    absl::optional<std::string> trace;
   };
   ConfigVars(const ConfigVars&) = delete;
   ConfigVars& operator=(const ConfigVars&) = delete;
@@ -111,13 +111,13 @@ class ConfigVars {
   bool enable_fork_support_;
   bool abort_on_leaks_;
   bool not_use_system_ssl_roots_;
-  std::string experiments_;
   std::string dns_resolver_;
-  std::string trace_;
   std::string verbosity_;
   std::string stacktrace_minloglevel_;
   std::string poll_strategy_;
   std::string ssl_cipher_suites_;
+  std::string experiments_;
+  std::string trace_;
   absl::optional<std::string> override_system_ssl_roots_dir_;
   absl::optional<std::string> override_default_ssl_roots_file_path_;
 };

data/src/core/lib/config/load_config.cc

@@ -20,8 +20,10 @@
 
 #include "absl/flags/marshalling.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/str_join.h"
 #include "absl/types/optional.h"
 
+#include "src/core/lib/gpr/log_internal.h"
 #include "src/core/lib/gprpp/env.h"
 
 namespace grpc_core {
@@ -34,6 +36,7 @@ absl::optional<std::string> LoadEnv(absl::string_view environment_variable) {
 
 std::string LoadConfigFromEnv(absl::string_view environment_variable,
                               const char* default_value) {
+  GPR_ASSERT_INTERNAL(!environment_variable.empty());
   return LoadEnv(environment_variable).value_or(default_value);
 }
 
@@ -63,4 +66,14 @@ bool LoadConfigFromEnv(absl::string_view environment_variable,
   return default_value;
 }
 
+std::string LoadConfig(const absl::Flag<std::vector<std::string>>& flag,
+                       absl::string_view environment_variable,
+                       const absl::optional<std::string>& override,
+                       const char* default_value) {
+  if (override.has_value()) return *override;
+  auto from_flag = absl::GetFlag(flag);
+  if (!from_flag.empty()) return absl::StrJoin(from_flag, ",");
+  return LoadConfigFromEnv(environment_variable, default_value);
+}
+
 }  // namespace grpc_core

data/src/core/lib/config/load_config.h

@@ -20,6 +20,7 @@
 #include <stdint.h>
 
 #include <string>
+#include <vector>
 
 #include "absl/flags/flag.h"
 #include "absl/strings/string_view.h"
@@ -44,6 +45,11 @@ T LoadConfig(const absl::Flag<absl::optional<T>>& flag,
   return LoadConfigFromEnv(environment_variable, default_value);
 }
 
+std::string LoadConfig(const absl::Flag<std::vector<std::string>>& flag,
+                       absl::string_view environment_variable,
+                       const absl::optional<std::string>& override,
+                       const char* default_value);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_CONFIG_LOAD_CONFIG_H

data/src/core/lib/debug/event_log.h

@@ -71,7 +71,7 @@ class EventLog {
   std::vector<Entry> EndCollection(
       absl::Span<const absl::string_view> wanted_events);
 
-  PerCpu<Fragment> fragments_;
+  PerCpu<Fragment> fragments_{PerCpuOptions().SetCpusPerShard(2)};
   gpr_cycle_counter collection_begin_;
   static std::atomic<EventLog*> g_instance_;
 };

data/src/core/lib/debug/stats_data.h

@@ -294,7 +294,7 @@ class GlobalStatsCollector {
     HistogramCollector_16777216_20 http2_send_message_size;
     HistogramCollector_65536_26 http2_metadata_size;
   };
-  PerCpu<Data> data_;
+  PerCpu<Data> data_{PerCpuOptions().SetCpusPerShard(4).SetMaxShards(32)};
 };
 }  // namespace grpc_core
 

data/src/core/lib/debug/trace.cc

@@ -20,16 +20,16 @@
 
 #include "src/core/lib/debug/trace.h"
 
-#include <string.h>
-
 #include <string>
 #include <type_traits>
 #include <utility>
 
+#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/config/config_vars.h"
@@ -40,31 +40,31 @@ namespace grpc_core {
 
 TraceFlag* TraceFlagList::root_tracer_ = nullptr;
 
-bool TraceFlagList::Set(const char* name, bool enabled) {
+bool TraceFlagList::Set(absl::string_view name, bool enabled) {
   TraceFlag* t;
-  if (0 == strcmp(name, "all")) {
+  if (name == "all") {
     for (t = root_tracer_; t; t = t->next_tracer_) {
       t->set_enabled(enabled);
     }
-  } else if (0 == strcmp(name, "list_tracers")) {
+  } else if (name == "list_tracers") {
     LogAllTracers();
-  } else if (0 == strcmp(name, "refcount")) {
+  } else if (name == "refcount") {
     for (t = root_tracer_; t; t = t->next_tracer_) {
-      if (strstr(t->name_, "refcount") != nullptr) {
+      if (absl::StrContains(t->name_, "refcount")) {
         t->set_enabled(enabled);
       }
     }
   } else {
     bool found = false;
     for (t = root_tracer_; t; t = t->next_tracer_) {
-      if (0 == strcmp(name, t->name_)) {
+      if (name == t->name_) {
         t->set_enabled(enabled);
         found = true;
       }
     }
     // check for unknowns, but ignore "", to allow to GRPC_TRACE=
-    if (!found && 0 != strcmp(name, "")) {
-      gpr_log(GPR_ERROR, "Unknown trace var: '%s'", name);
+    if (!found && !name.empty()) {
+      gpr_log(GPR_ERROR, "Unknown trace var: '%s'", std::string(name).c_str());
       return false;  // early return
     }
   }
@@ -101,59 +101,28 @@ SavedTraceFlags::SavedTraceFlags() { TraceFlagList::SaveTo(values_); }
 
 void SavedTraceFlags::Restore() {
   for (const auto& flag : values_) {
-    TraceFlagList::Set(flag.first.c_str(), flag.second);
-  }
-}
-
-}  // namespace grpc_core
-
-static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
-  size_t n = *ns;
-  size_t np = n + 1;
-  char* s;
-  size_t len;
-  GPR_ASSERT(end >= beg);
-  len = static_cast<size_t>(end - beg);
-  s = static_cast<char*>(gpr_malloc(len + 1));
-  memcpy(s, beg, len);
-  s[len] = 0;
-  *ss = static_cast<char**>(gpr_realloc(*ss, sizeof(char**) * np));
-  (*ss)[n] = s;
-  *ns = np;
-}
-
-static void split(const char* s, char*** ss, size_t* ns) {
-  const char* c = strchr(s, ',');
-  if (c == nullptr) {
-    add(s, s + strlen(s), ss, ns);
-  } else {
-    add(s, c, ss, ns);
-    split(c + 1, ss, ns);
+    TraceFlagList::Set(flag.first, flag.second);
   }
 }
 
-static void parse(const char* s) {
-  char** strings = nullptr;
-  size_t nstrings = 0;
-  size_t i;
-  split(s, &strings, &nstrings);
-
-  for (i = 0; i < nstrings; i++) {
-    if (strings[i][0] == '-') {
-      grpc_core::TraceFlagList::Set(strings[i] + 1, false);
+namespace {
+void ParseTracers(absl::string_view tracers) {
+  for (auto s : absl::StrSplit(tracers, ',')) {
+    s = absl::StripAsciiWhitespace(s);
+    if (s.empty()) continue;
+    if (s[0] == '-') {
+      TraceFlagList::Set(s.substr(1), false);
     } else {
-      grpc_core::TraceFlagList::Set(strings[i], true);
+      TraceFlagList::Set(s, true);
     }
   }
-
-  for (i = 0; i < nstrings; i++) {
-    gpr_free(strings[i]);
-  }
-  gpr_free(strings);
 }
+}  // namespace
+
+}  // namespace grpc_core
 
 void grpc_tracer_init() {
-  parse(std::string(grpc_core::ConfigVars::Get().Trace()).c_str());
+  grpc_core::ParseTracers(grpc_core::ConfigVars::Get().Trace());
 }
 
 int grpc_tracer_set_enabled(const char* name, int enabled) {

data/src/core/lib/debug/trace.h

@@ -25,6 +25,8 @@
 #include <map>
 #include <string>
 
+#include "absl/strings/string_view.h"
+
 void grpc_tracer_init();
 void grpc_tracer_shutdown(void);
 
@@ -33,7 +35,7 @@ namespace grpc_core {
 class TraceFlag;
 class TraceFlagList {
  public:
-  static bool Set(const char* name, bool enabled);
+  static bool Set(absl::string_view name, bool enabled);
   static void Add(TraceFlag* flag);
   static void SaveTo(std::map<std::string, bool>& values);