grpc 1.73.0 → 1.75.0

data/src/core/lib/promise/arena_promise.h

@@ -48,6 +48,8 @@ template <typename T>
 struct Vtable {
   // Poll the promise, once.
   Poll<T> (*poll_once)(ArgType* arg);
+  // Move the promise to another memory location.
+  void (*move)(ArgType* dst, ArgType* src);
   // Destroy the underlying callable object if there is one.
   // Since we don't delete (the arena owns the memory) but we may need to call a
   // destructor, we expose this for when the ArenaPromise object is destroyed.
@@ -73,11 +75,12 @@ struct Null {
     GPR_UNREACHABLE_CODE(return Pending{});
   }
 
+  static void Move(ArgType*, ArgType*) {}
   static void Destroy(ArgType*) {}
 };
 
 template <typename T>
-const Vtable<T> Null<T>::vtable = {PollOnce, Destroy};
+const Vtable<T> Null<T>::vtable = {PollOnce, Move, Destroy};
 
 // Implementation of ImplInterface for a callable object.
 template <typename T, typename Callable>
@@ -88,11 +91,16 @@ struct AllocatedCallable {
     return poll_cast<T>((*ArgAsPtr<Callable>(arg))());
   }
 
+  static void Move(ArgType* dst, ArgType* src) {
+    ArgAsPtr<Callable>(dst) = ArgAsPtr<Callable>(src);
+  }
+
   static void Destroy(ArgType* arg) { Destruct(ArgAsPtr<Callable>(arg)); }
 };
 
 template <typename T, typename Callable>
-const Vtable<T> AllocatedCallable<T, Callable>::vtable = {PollOnce, Destroy};
+const Vtable<T> AllocatedCallable<T, Callable>::vtable = {PollOnce, Move,
+                                                          Destroy};
 
 // Implementation of ImplInterface for a small callable object (one that fits
 // within the ArgType arg)
@@ -104,13 +112,17 @@ struct Inlined {
     return poll_cast<T>((*reinterpret_cast<Callable*>(arg))());
   }
 
+  static void Move(ArgType* dst, ArgType* src) {
+    new (dst) Callable(reinterpret_cast<Callable&&>(*src));
+  }
+
   static void Destroy(ArgType* arg) {
     Destruct(reinterpret_cast<Callable*>(arg));
   }
 };
 
 template <typename T, typename Callable>
-const Vtable<T> Inlined<T, Callable>::vtable = {PollOnce, Destroy};
+const Vtable<T> Inlined<T, Callable>::vtable = {PollOnce, Move, Destroy};
 
 // If a callable object is empty we can substitute any instance of that callable
 // for the one we call (for how could we tell the difference)?
@@ -129,7 +141,7 @@ struct SharedCallable {
 };
 
 template <typename T, typename Callable>
-const Vtable<T> SharedCallable<T, Callable>::vtable = {PollOnce,
+const Vtable<T> SharedCallable<T, Callable>::vtable = {PollOnce, Null<T>::Move,
                                                        Null<T>::Destroy};
 
 // Redirector type: given a callable type, expose a Make() function that creates
@@ -199,13 +211,17 @@ class ArenaPromise {
   ArenaPromise(const ArenaPromise&) = delete;
   ArenaPromise& operator=(const ArenaPromise&) = delete;
   // ArenaPromise is movable.
-  ArenaPromise(ArenaPromise&& other) noexcept
-      : vtable_and_arg_(other.vtable_and_arg_) {
+  ArenaPromise(ArenaPromise&& other) noexcept {
+    vtable_and_arg_.vtable = other.vtable_and_arg_.vtable;
+    vtable_and_arg_.vtable->move(&vtable_and_arg_.arg,
+                                 &other.vtable_and_arg_.arg);
     other.vtable_and_arg_.vtable = &arena_promise_detail::Null<T>::vtable;
   }
   ArenaPromise& operator=(ArenaPromise&& other) noexcept {
     vtable_and_arg_.vtable->destroy(&vtable_and_arg_.arg);
-    vtable_and_arg_ = other.vtable_and_arg_;
+    vtable_and_arg_.vtable = other.vtable_and_arg_.vtable;
+    vtable_and_arg_.vtable->move(&vtable_and_arg_.arg,
+                                 &other.vtable_and_arg_.arg);
     other.vtable_and_arg_.vtable = &arena_promise_detail::Null<T>::vtable;
     return *this;
   }

data/src/core/lib/promise/detail/promise_factory.h

@@ -223,6 +223,7 @@ class OncePromiseFactory {
   using Arg = A;
   using Promise = decltype(PromiseFactoryImpl(OnceToken{}, std::move(f_),
                                               std::declval<A>()));
+  using UnderlyingFactory = F;
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit OncePromiseFactory(F f)
       : f_(std::move(f)) {}
@@ -240,6 +241,7 @@ class OncePromiseFactory<void, F> {
  public:
   using Arg = void;
   using Promise = decltype(PromiseFactoryImpl(OnceToken{}, std::move(f_)));
+  using UnderlyingFactory = F;
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit OncePromiseFactory(F f)
       : f_(std::move(f)) {}
@@ -272,6 +274,14 @@ class RepeatedPromiseFactory {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make(Arg&& a) {
     return PromiseFactoryImpl(RepeatableToken{}, f_, std::forward<Arg>(a));
   }
+  template <typename U>
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make(U&& u) const {
+    return PromiseFactoryImpl(RepeatableToken{}, f_, std::forward<U>(u));
+  }
+  template <typename U>
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Promise Make(U&& u) {
+    return PromiseFactoryImpl(RepeatableToken{}, f_, std::forward<U>(u));
+  }
 };
 
 template <typename F>

data/src/core/lib/promise/detail/promise_like.h

@@ -17,13 +17,17 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <cstddef>
 #include <utility>
 
-#include "absl/functional/any_invocable.h"
 #include "absl/meta/type_traits.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/function_signature.h"
-#include "src/core/util/json/json.h"
+#include "src/core/util/upb_utils.h"
+#include "src/proto/grpc/channelz/v2/promise.upb.h"
+#include "src/proto/grpc/channelz/v2/promise.upbdefs.h"
+#include "upb/reflection/def.hpp"
 
 // A Promise is a callable object that returns Poll<T> for some T.
 // Often when we're writing code that uses promises, we end up wanting to also
@@ -50,23 +54,120 @@
 namespace grpc_core {
 
 namespace promise_detail {
+
+template <typename Promise, typename = void>
+constexpr bool kHasToProtoMethod = false;
+
+template <typename Promise>
+constexpr bool kHasToProtoMethod<
+    Promise, std::void_t<decltype(std::declval<Promise>().ToProto(
+                 static_cast<grpc_channelz_v2_Promise*>(nullptr),
+                 static_cast<upb_Arena*>(nullptr)))>> = true;
+
 template <typename Promise, typename = void>
-constexpr bool kHasToJsonMethod = false;
+constexpr bool kHasChannelzPropertiesMethod = false;
 
 template <typename Promise>
-constexpr bool kHasToJsonMethod<
-    Promise, std::void_t<decltype(std::declval<Promise>().ToJson())>> = true;
+constexpr bool kHasChannelzPropertiesMethod<
+    Promise,
+    std::void_t<decltype(std::declval<Promise>().ChannelzProperties())>> = true;
+
 }  // namespace promise_detail
 
 template <typename Promise>
-Json PromiseAsJson(const Promise& promise) {
-  if constexpr (promise_detail::kHasToJsonMethod<Promise>) {
-    return promise.ToJson();
+void PromiseAsProto(const Promise& promise,
+                    grpc_channelz_v2_Promise* promise_proto, upb_Arena* arena) {
+  if constexpr (promise_detail::kHasToProtoMethod<Promise>) {
+    promise.ToProto(promise_proto, arena);
+  } else if constexpr (promise_detail::kHasChannelzPropertiesMethod<Promise>) {
+    auto* custom_promise =
+        grpc_channelz_v2_Promise_mutable_custom_promise(promise_proto, arena);
+    grpc_channelz_v2_Promise_Custom_set_type(
+        custom_promise, StdStringToUpbString(TypeName<Promise>()));
+    promise.ChannelzProperties().FillUpbProto(
+        grpc_channelz_v2_Promise_Custom_mutable_properties(custom_promise,
+                                                           arena),
+        arena);
   } else {
-    return Json::FromString(std::string(TypeName<Promise>()));
+    grpc_channelz_v2_Promise_set_unknown_promise(
+        promise_proto, StdStringToUpbString(TypeName<Promise>()));
   }
 }
 
+// Wrapper for Promises to convert them to PropertyValue types.
+// Allows the type resolution logic to properly handle arbitrary promises.
+template <typename T>
+class PromiseProperty {
+ public:
+  explicit PromiseProperty(T* value) : value_(value) {}
+
+  T* TakeValue() { return std::exchange(value_, nullptr); }
+
+ private:
+  T* value_;
+};
+
+template <typename T>
+PromiseProperty(T* value) -> PromiseProperty<T>;
+
+// TODO(ctiller): needed to avoid circular dependencies as we transition the
+// codebase, but we'll need a better long-term solution here.
+namespace channelz::property_list_detail {
+
+class PromisePropertyValue final : public OtherPropertyValue {
+ public:
+  template <typename T>
+  explicit PromisePropertyValue(T* value) {
+    PromiseAsProto(*value, promise_proto_, arena_);
+  }
+
+  PromisePropertyValue(PromisePropertyValue&&) = delete;
+  PromisePropertyValue& operator=(PromisePropertyValue&&) = delete;
+  PromisePropertyValue(const PromisePropertyValue&) = delete;
+  PromisePropertyValue& operator=(const PromisePropertyValue&) = delete;
+
+  ~PromisePropertyValue() override { upb_Arena_Free(arena_); }
+
+  void FillAny(google_protobuf_Any* any, upb_Arena* arena) override {
+    size_t length;
+    upb_Arena_Fuse(arena_, arena);
+    auto* bytes =
+        grpc_channelz_v2_Promise_serialize(promise_proto_, arena, &length);
+    google_protobuf_Any_set_value(
+        any, upb_StringView_FromDataAndSize(bytes, length));
+    google_protobuf_Any_set_type_url(
+        any,
+        StdStringToUpbString("type.googleapis.com/grpc.channelz.v2.Promise"));
+  }
+
+  Json::Object TakeJsonObject() override {
+    upb::DefPool def_pool;
+    auto* def = grpc_channelz_v2_Promise_getmsgdef(def_pool.ptr());
+    size_t length =
+        upb_TextEncode(reinterpret_cast<upb_Message*>(promise_proto_), def,
+                       def_pool.ptr(), 0, nullptr, 0);
+    auto str = std::make_unique<char[]>(length);
+    upb_TextEncode(reinterpret_cast<upb_Message*>(promise_proto_), def,
+                   def_pool.ptr(), 0, str.get(), length);
+    return {{"promise", Json::FromString(std::string(str.get()))}};
+  }
+
+ private:
+  upb_Arena* arena_ = upb_Arena_New();
+  grpc_channelz_v2_Promise* promise_proto_ =
+      grpc_channelz_v2_Promise_new(arena_);
+};
+
+template <typename T>
+struct Wrapper<PromiseProperty<T>> {
+  static std::optional<PropertyValue> Wrap(PromiseProperty<T> value) {
+    return PropertyValue(
+        std::make_shared<PromisePropertyValue>(value.TakeValue()));
+  }
+};
+
+}  // namespace channelz::property_list_detail
+
 namespace promise_detail {
 
 template <typename T>
@@ -114,7 +215,10 @@ class PromiseLike<
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION WrappedResult operator()() {
     return WrapInPoll(f_());
   }
-  Json ToJson() const { return PromiseAsJson(f_); }
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    PromiseAsProto(f_, promise_proto, arena);
+  }
   PromiseLike(const PromiseLike&) = default;
   PromiseLike& operator=(const PromiseLike&) = default;
   PromiseLike(PromiseLike&&) = default;
@@ -136,7 +240,10 @@ class PromiseLike<
     f_();
     return Empty{};
   }
-  Json ToJson() const { return PromiseAsJson(f_); }
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    PromiseAsProto(f_, promise_proto, arena);
+  }
   PromiseLike(const PromiseLike&) = default;
   PromiseLike& operator=(const PromiseLike&) = default;
   PromiseLike(PromiseLike&&) = default;

data/src/core/lib/promise/detail/promise_variant.h

@@ -0,0 +1,50 @@
+// Copyright 2024 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_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_VARIANT_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_VARIANT_H
+
+#include <variant>
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+// Visitor function for PromiseVariant - calls the poll operator on the inner
+// type
+class PollVisitor {
+ public:
+  template <typename T>
+  auto operator()(T& x) {
+    return x();
+  }
+};
+
+// Helper type - given a variant V, provides the poll operator (which simply
+// visits the inner type on the variant with PollVisitor)
+template <typename V>
+class PromiseVariant {
+ public:
+  explicit PromiseVariant(V variant) : variant_(std::move(variant)) {}
+  auto operator()() { return std::visit(PollVisitor(), variant_); }
+
+ private:
+  V variant_;
+};
+
+}  // namespace promise_detail
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_VARIANT_H