grpc 1.73.0 → 1.74.0

data/src/core/lib/iomgr/ev_poll_posix.cc

@@ -38,6 +38,7 @@
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
@@ -378,7 +379,9 @@ static void unref_by(grpc_fd* fd, int n) {
 }
 
 static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
-  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
+      !grpc_event_engine::experimental::
+          EventEngineExperimentDisabledForPython()) {
     GRPC_TRACE_LOG(event_engine, ERROR)
         << "Creating a wrapped EventEngine grpc_fd with fd:" << fd;
     grpc_fd* new_fd = static_cast<grpc_fd*>(gpr_malloc(sizeof(grpc_fd)));
@@ -477,7 +480,9 @@ static int fd_wrapped_fd(grpc_fd* fd) {
 
 static void fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
                       const char* reason) {
-  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
+      !grpc_event_engine::experimental::
+          EventEngineExperimentDisabledForPython()) {
     CHECK_NE(release_fd, nullptr);
     CHECK_EQ(on_done, nullptr);
     *release_fd = fd->fd;

data/src/core/lib/iomgr/event_engine_shims/endpoint.cc

@@ -312,8 +312,9 @@ void EndpointRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
 // Write the data from slices and invoke the provided closure asynchronously
 // after the write is complete.
-void EndpointWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                   grpc_closure* cb, void* arg, int max_frame_size) {
+void EndpointWrite(
+    grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
+    grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs args) {
   auto* eeep =
       reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
           ep);
@@ -323,10 +324,7 @@ void EndpointWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
     return;
   }
 
-  EventEngine::Endpoint::WriteArgs write_args;
-  write_args.SetDeprecatedAndDiscouragedGoogleSpecificPointer(arg);
-  write_args.set_max_frame_size(max_frame_size);
-  if (eeep->wrapper->Write(cb, slices, std::move(write_args))) {
+  if (eeep->wrapper->Write(cb, slices, std::move(args))) {
     // Write succeeded immediately. Run the callback inline.
     eeep->wrapper->FinishPendingWrite(absl::OkStatus());
   }

data/src/core/lib/iomgr/tcp_posix.cc

@@ -1795,8 +1795,9 @@ static void tcp_handle_write(void* arg /* grpc_tcp */,
   }
 }
 
-static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
-                      grpc_closure* cb, void* arg, int /*max_frame_size*/) {
+static void tcp_write(
+    grpc_endpoint* ep, grpc_slice_buffer* buf, grpc_closure* cb,
+    grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs args) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
   grpc_error_handle error;
   TcpZerocopySendRecord* zerocopy_send_record = nullptr;
@@ -1835,8 +1836,9 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
     tcp->outgoing_buffer = buf;
     tcp->outgoing_byte_idx = 0;
   }
-  tcp->outgoing_buffer_arg = arg;
-  if (arg) {
+  tcp->outgoing_buffer_arg =
+      args.TakeDeprecatedAndDiscouragedGoogleSpecificPointer();
+  if (tcp->outgoing_buffer_arg) {
     CHECK(grpc_event_engine_can_track_errors());
   }
 
@@ -1915,7 +1917,9 @@ static const grpc_endpoint_vtable vtable = {tcp_read,
 grpc_endpoint* grpc_tcp_create(
     grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
     absl::string_view peer_string) {
-  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
+      !grpc_event_engine::experimental::
+          EventEngineExperimentDisabledForPython()) {
     // Create an EventEngine endpoint when creating the transport.
     auto* engine =
         reinterpret_cast<grpc_event_engine::experimental::EventEngine*>(
@@ -1943,7 +1947,9 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   CHECK(!grpc_event_engine::experimental::UsePollsetAlternative())
       << "This function must not be called when the pollset_alternative "
          "experiment is enabled. This is a bug.";
-  CHECK(!grpc_core::IsEventEngineForAllOtherEndpointsEnabled())
+  CHECK(
+      !grpc_core::IsEventEngineForAllOtherEndpointsEnabled() ||
+      grpc_event_engine::experimental::EventEngineExperimentDisabledForPython())
       << "The event_engine_for_all_other_endpoints experiment should prevent "
          "this method from being called. This is a bug.";
   grpc_tcp* tcp = new grpc_tcp(options);

data/src/core/lib/iomgr/tcp_windows.cc

@@ -323,8 +323,9 @@ static void on_write(void* tcpp, grpc_error_handle error) {
 
 // Initiates a write.
 static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                      grpc_closure* cb, void* /* arg */,
-                      int /* max_frame_size */) {
+                      grpc_closure* cb,
+                      grpc_event_engine::experimental::EventEngine::Endpoint::
+                          WriteArgs /*args*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->write_info;

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

@@ -122,6 +122,7 @@ class Waker {
   }
 
   std::string DebugString() const {
+    if (is_unwakeable()) return "<unwakeable>";
     return absl::StrFormat("Waker{%p, %d}", wakeable_and_arg_.wakeable,
                            wakeable_and_arg_.wakeup_mask);
   }

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