grpc 1.55.0 → 1.58.0

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

@@ -27,6 +27,8 @@
 #include <algorithm>
 #include <initializer_list>
 #include <map>
+#include <memory>
+#include <string>
 #include <vector>
 
 #include "absl/strings/match.h"
@@ -34,15 +36,41 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/match.h"
 
 namespace grpc_core {
 
+const grpc_arg_pointer_vtable ChannelArgs::Value::int_vtable_{
+    // copy
+    [](void* p) { return p; },
+    // destroy
+    [](void*) {},
+    // cmp
+    [](void* p1, void* p2) -> int {
+      return QsortCompare(reinterpret_cast<intptr_t>(p1),
+                          reinterpret_cast<intptr_t>(p2));
+    },
+};
+
+const grpc_arg_pointer_vtable ChannelArgs::Value::string_vtable_{
+    // copy
+    [](void* p) -> void* {
+      return static_cast<RefCountedString*>(p)->Ref().release();
+    },
+    // destroy
+    [](void* p) { static_cast<RefCountedString*>(p)->Unref(); },
+    // cmp
+    [](void* p1, void* p2) -> int {
+      return QsortCompare(static_cast<RefCountedString*>(p1)->as_string_view(),
+                          static_cast<RefCountedString*>(p2)->as_string_view());
+    },
+};
+
 ChannelArgs::Pointer::Pointer(void* p, const grpc_arg_pointer_vtable* vtable)
     : p_(p), vtable_(vtable == nullptr ? EmptyVTable() : vtable) {}
 
@@ -98,7 +126,7 @@ bool ChannelArgs::WantMinimalStack() const {
   return GetBool(GRPC_ARG_MINIMAL_STACK).value_or(false);
 }
 
-ChannelArgs::ChannelArgs(AVL<std::string, Value> args)
+ChannelArgs::ChannelArgs(AVL<RefCountedStringValue, Value> args)
     : args_(std::move(args)) {}
 
 ChannelArgs ChannelArgs::Set(grpc_arg arg) const {
@@ -126,22 +154,27 @@ ChannelArgs ChannelArgs::FromC(const grpc_channel_args* args) {
   return result;
 }
 
+grpc_arg ChannelArgs::Value::MakeCArg(const char* name) const {
+  char* c_name = const_cast<char*>(name);
+  if (rep_.c_vtable() == &int_vtable_) {
+    return grpc_channel_arg_integer_create(
+        c_name, reinterpret_cast<intptr_t>(rep_.c_pointer()));
+  }
+  if (rep_.c_vtable() == &string_vtable_) {
+    return grpc_channel_arg_string_create(
+        c_name, const_cast<char*>(
+                    static_cast<RefCountedString*>(rep_.c_pointer())->c_str()));
+  }
+  return grpc_channel_arg_pointer_create(c_name, rep_.c_pointer(),
+                                         rep_.c_vtable());
+}
+
 ChannelArgs::CPtr ChannelArgs::ToC() const {
   std::vector<grpc_arg> c_args;
-  args_.ForEach([&c_args](const std::string& key, const Value& value) {
-    char* name = const_cast<char*>(key.c_str());
-    c_args.push_back(Match(
-        value,
-        [name](int i) { return grpc_channel_arg_integer_create(name, i); },
-        [name](const std::string& s) {
-          return grpc_channel_arg_string_create(name,
-                                                const_cast<char*>(s.c_str()));
-        },
-        [name](const Pointer& p) {
-          return grpc_channel_arg_pointer_create(name, p.c_pointer(),
-                                                 p.c_vtable());
-        }));
-  });
+  args_.ForEach(
+      [&c_args](const RefCountedStringValue& key, const Value& value) {
+        c_args.push_back(value.MakeCArg(key.c_str()));
+      });
   return CPtr(static_cast<const grpc_channel_args*>(
       grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size())));
 }
@@ -154,32 +187,44 @@ ChannelArgs ChannelArgs::Set(absl::string_view name, int value) const {
   return Set(name, Value(value));
 }
 
-ChannelArgs ChannelArgs::Set(absl::string_view key, Value value) const {
-  return ChannelArgs(args_.Add(std::string(key), std::move(value)));
+ChannelArgs ChannelArgs::Set(absl::string_view name, Value value) const {
+  if (const auto* p = args_.Lookup(name)) {
+    if (*p == value) return *this;  // already have this value for this key
+  }
+  return ChannelArgs(args_.Add(RefCountedStringValue(name), std::move(value)));
 }
 
-ChannelArgs ChannelArgs::Set(absl::string_view key,
+ChannelArgs ChannelArgs::Set(absl::string_view name,
                              absl::string_view value) const {
-  return Set(key, std::string(value));
+  return Set(name, std::string(value));
 }
 
-ChannelArgs ChannelArgs::Set(absl::string_view key, const char* value) const {
-  return Set(key, std::string(value));
+ChannelArgs ChannelArgs::Set(absl::string_view name, const char* value) const {
+  return Set(name, std::string(value));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view name, std::string value) const {
+  return Set(name, Value(std::move(value)));
 }
 
-ChannelArgs ChannelArgs::Set(absl::string_view key, std::string value) const {
-  return Set(key, Value(std::move(value)));
+ChannelArgs ChannelArgs::Remove(absl::string_view name) const {
+  if (args_.Lookup(name) == nullptr) return *this;
+  return ChannelArgs(args_.Remove(name));
 }
 
-ChannelArgs ChannelArgs::Remove(absl::string_view key) const {
-  return ChannelArgs(args_.Remove(key));
+ChannelArgs ChannelArgs::RemoveAllKeysWithPrefix(
+    absl::string_view prefix) const {
+  auto args = args_;
+  args_.ForEach([&](const RefCountedStringValue& key, const Value&) {
+    if (absl::StartsWith(key.as_string_view(), prefix)) args = args.Remove(key);
+  });
+  return ChannelArgs(std::move(args));
 }
 
 absl::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return absl::nullopt;
-  if (!absl::holds_alternative<int>(*v)) return absl::nullopt;
-  return absl::get<int>(*v);
+  return v->GetIfInt();
 }
 
 absl::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
@@ -195,8 +240,9 @@ absl::optional<absl::string_view> ChannelArgs::GetString(
     absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return absl::nullopt;
-  if (!absl::holds_alternative<std::string>(*v)) return absl::nullopt;
-  return absl::get<std::string>(*v);
+  const auto s = v->GetIfString();
+  if (s == nullptr) return absl::nullopt;
+  return s->as_string_view();
 }
 
 absl::optional<std::string> ChannelArgs::GetOwnedString(
@@ -209,15 +255,16 @@ absl::optional<std::string> ChannelArgs::GetOwnedString(
 void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return nullptr;
-  if (!absl::holds_alternative<Pointer>(*v)) return nullptr;
-  return absl::get<Pointer>(*v).c_pointer();
+  const auto* pp = v->GetIfPointer();
+  if (pp == nullptr) return nullptr;
+  return pp->c_pointer();
 }
 
 absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return absl::nullopt;
-  auto* i = absl::get_if<int>(v);
-  if (i == nullptr) {
+  auto i = v->GetIfInt();
+  if (!i.has_value()) {
     gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
             std::string(name).c_str());
     return absl::nullopt;
@@ -234,24 +281,51 @@ absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   }
 }
 
+std::string ChannelArgs::Value::ToString() const {
+  if (rep_.c_vtable() == &int_vtable_) {
+    return std::to_string(reinterpret_cast<intptr_t>(rep_.c_pointer()));
+  }
+  if (rep_.c_vtable() == &string_vtable_) {
+    return std::string(
+        static_cast<RefCountedString*>(rep_.c_pointer())->as_string_view());
+  }
+  return absl::StrFormat("%p", rep_.c_pointer());
+}
+
 std::string ChannelArgs::ToString() const {
   std::vector<std::string> arg_strings;
-  args_.ForEach([&arg_strings](const std::string& key, const Value& value) {
-    std::string value_str;
-    if (auto* i = absl::get_if<int>(&value)) {
-      value_str = std::to_string(*i);
-    } else if (auto* s = absl::get_if<std::string>(&value)) {
-      value_str = *s;
-    } else if (auto* p = absl::get_if<Pointer>(&value)) {
-      value_str = absl::StrFormat("%p", p->c_pointer());
-    }
-    arg_strings.push_back(absl::StrCat(key, "=", value_str));
-  });
+  args_.ForEach(
+      [&arg_strings](const RefCountedStringValue& key, const Value& value) {
+        arg_strings.push_back(
+            absl::StrCat(key.as_string_view(), "=", value.ToString()));
+      });
   return absl::StrCat("{", absl::StrJoin(arg_strings, ", "), "}");
 }
 
 ChannelArgs ChannelArgs::UnionWith(ChannelArgs other) const {
-  args_.ForEach([&other](const std::string& key, const Value& value) {
+  if (args_.Empty()) return other;
+  if (other.args_.Empty()) return *this;
+  if (args_.Height() <= other.args_.Height()) {
+    args_.ForEach(
+        [&other](const RefCountedStringValue& key, const Value& value) {
+          other.args_ = other.args_.Add(key, value);
+        });
+    return other;
+  } else {
+    auto result = *this;
+    other.args_.ForEach(
+        [&result](const RefCountedStringValue& key, const Value& value) {
+          if (result.args_.Lookup(key) == nullptr) {
+            result.args_ = result.args_.Add(key, value);
+          }
+        });
+    return result;
+  }
+}
+
+ChannelArgs ChannelArgs::FuzzingReferenceUnionWith(ChannelArgs other) const {
+  // DO NOT OPTIMIZE THIS!!
+  args_.ForEach([&other](const RefCountedStringValue& key, const Value& value) {
     other.args_ = other.args_.Add(key, value);
   });
   return other;

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

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include <algorithm>  // IWYU pragma: keep
 #include <iosfwd>
@@ -33,7 +34,6 @@
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "absl/types/variant.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
@@ -44,6 +44,7 @@
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/ref_counted_string.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
@@ -281,7 +282,46 @@ class ChannelArgs {
     const grpc_arg_pointer_vtable* vtable_;
   };
 
-  using Value = absl::variant<int, std::string, Pointer>;
+  class Value {
+   public:
+    explicit Value(int n) : rep_(reinterpret_cast<void*>(n), &int_vtable_) {}
+    explicit Value(std::string s)
+        : rep_(RefCountedString::Make(s).release(), &string_vtable_) {}
+    explicit Value(Pointer p) : rep_(std::move(p)) {}
+
+    absl::optional<int> GetIfInt() const {
+      if (rep_.c_vtable() != &int_vtable_) return absl::nullopt;
+      return reinterpret_cast<intptr_t>(rep_.c_pointer());
+    }
+    RefCountedPtr<RefCountedString> GetIfString() const {
+      if (rep_.c_vtable() != &string_vtable_) return nullptr;
+      return static_cast<RefCountedString*>(rep_.c_pointer())->Ref();
+    }
+    const Pointer* GetIfPointer() const {
+      if (rep_.c_vtable() == &int_vtable_) return nullptr;
+      if (rep_.c_vtable() == &string_vtable_) return nullptr;
+      return &rep_;
+    }
+
+    std::string ToString() const;
+
+    grpc_arg MakeCArg(const char* name) const;
+
+    bool operator<(const Value& rhs) const { return rep_ < rhs.rep_; }
+    bool operator==(const Value& rhs) const { return rep_ == rhs.rep_; }
+    bool operator!=(const Value& rhs) const { return !this->operator==(rhs); }
+    bool operator==(absl::string_view rhs) const {
+      auto str = GetIfString();
+      if (str == nullptr) return false;
+      return str->as_string_view() == rhs;
+    }
+
+   private:
+    static const grpc_arg_pointer_vtable int_vtable_;
+    static const grpc_arg_pointer_vtable string_vtable_;
+
+    Pointer rep_;
+  };
 
   struct ChannelArgsDeleter {
     void operator()(const grpc_channel_args* p) const;
@@ -307,6 +347,11 @@ class ChannelArgs {
   // If a key is present in both, the value from this is used.
   GRPC_MUST_USE_RESULT ChannelArgs UnionWith(ChannelArgs other) const;
 
+  // Only used in union_with_test.cc, reference version of UnionWith for
+  // differential fuzzing.
+  GRPC_MUST_USE_RESULT ChannelArgs
+  FuzzingReferenceUnionWith(ChannelArgs other) const;
+
   const Value* Get(absl::string_view name) const;
   GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
                                        Pointer value) const;
@@ -362,6 +407,9 @@ class ChannelArgs {
   GRPC_MUST_USE_RESULT ChannelArgs Remove(absl::string_view name) const;
   bool Contains(absl::string_view name) const;
 
+  GRPC_MUST_USE_RESULT ChannelArgs
+  RemoveAllKeysWithPrefix(absl::string_view prefix) const;
+
   template <typename T>
   bool ContainsObject() const {
     return Get(ChannelArgNameTraits<T>::ChannelArgName()) != nullptr;
@@ -426,12 +474,12 @@ class ChannelArgs {
   std::string ToString() const;
 
  private:
-  explicit ChannelArgs(AVL<std::string, Value> args);
+  explicit ChannelArgs(AVL<RefCountedStringValue, Value> args);
 
   GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
                                        Value value) const;
 
-  AVL<std::string, Value> args_;
+  AVL<RefCountedStringValue, Value> args_;
 };
 
 std::ostream& operator<<(std::ostream& out, const ChannelArgs& args);

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

@@ -21,10 +21,12 @@
 #include "src/core/lib/channel/channel_trace.h"
 
 #include <algorithm>
-#include <string>
 #include <utility>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
+#include <grpc/support/json.h>
 
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gpr/string.h"
@@ -140,21 +142,21 @@ const char* severity_string(ChannelTrace::Severity severity) {
 Json ChannelTrace::TraceEvent::RenderTraceEvent() const {
   char* description = grpc_slice_to_c_string(data_);
   Json::Object object = {
-      {"description", description},
-      {"severity", severity_string(severity_)},
-      {"timestamp", gpr_format_timespec(timestamp_)},
+      {"description", Json::FromString(description)},
+      {"severity", Json::FromString(severity_string(severity_))},
+      {"timestamp", Json::FromString(gpr_format_timespec(timestamp_))},
   };
   gpr_free(description);
   if (referenced_entity_ != nullptr) {
     const bool is_channel =
         (referenced_entity_->type() == BaseNode::EntityType::kTopLevelChannel ||
          referenced_entity_->type() == BaseNode::EntityType::kInternalChannel);
-    object[is_channel ? "channelRef" : "subchannelRef"] = Json::Object{
+    object[is_channel ? "channelRef" : "subchannelRef"] = Json::FromObject({
         {(is_channel ? "channelId" : "subchannelId"),
-         std::to_string(referenced_entity_->uuid())},
-    };
+         Json::FromString(absl::StrCat(referenced_entity_->uuid()))},
+    });
   }
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 Json ChannelTrace::RenderJson() const {
@@ -163,10 +165,12 @@ Json ChannelTrace::RenderJson() const {
     return Json();  // JSON null
   }
   Json::Object object = {
-      {"creationTimestamp", gpr_format_timespec(time_created_)},
+      {"creationTimestamp",
+       Json::FromString(gpr_format_timespec(time_created_))},
   };
   if (num_events_logged_ > 0) {
-    object["numEventsLogged"] = std::to_string(num_events_logged_);
+    object["numEventsLogged"] =
+        Json::FromString(absl::StrCat(num_events_logged_));
   }
   // Only add in the event list if it is non-empty.
   if (head_trace_ != nullptr) {
@@ -174,9 +178,9 @@ Json ChannelTrace::RenderJson() const {
     for (TraceEvent* it = head_trace_; it != nullptr; it = it->next()) {
       array.emplace_back(it->RenderTraceEvent());
     }
-    object["events"] = std::move(array);
+    object["events"] = Json::FromArray(std::move(array));
   }
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 }  // namespace channelz