grpc 1.73.0 → 1.74.0

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

@@ -26,8 +26,11 @@
 #include <utility>
 
 #include "absl/base/attributes.h"
+#include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/promise/activity.h"
@@ -38,6 +41,7 @@
 #include "src/core/util/check_class_size.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/json/json_writer.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 
@@ -167,6 +171,9 @@ class Party : public Activity, private Wakeable {
     // Destroy the participant before finishing.
     virtual void Destroy() = 0;
 
+    // Return a description of this participant.
+    virtual channelz::PropertyList ChannelzProperties() = 0;
+
     // Return a Handle instance for this participant.
     Wakeable* MakeNonOwningWakeable(Party* party);
 
@@ -281,6 +288,20 @@ class Party : public Activity, private Wakeable {
           party_->state_.load(std::memory_order_relaxed), wakeup_mask_);
     }
 
+    channelz::PropertyList ChannelzProperties() override {
+      channelz::PropertyList properties;
+      if (active_ != nullptr) {
+        properties.Set("active", active_->ChannelzProperties());
+      }
+      properties.Set("queued", [this]() {
+        channelz::PropertyTable queued;
+        next_.ForEach(
+            [&](Participant* p) { queued.AppendRow(p->ChannelzProperties()); });
+        return queued;
+      }());
+      return properties;
+    }
+
    private:
     friend class Party;
     friend class Arena;
@@ -367,6 +388,14 @@ class Party : public Activity, private Wakeable {
     return serializer;
   }
 
+  // Convert the party to a JSON object for visualization.
+  // This is an async operation because the party cannot be locked
+  // synchronously.
+  void ToJson(absl::AnyInvocable<void(Json::Object)>);
+
+  // Export the party to channelz.
+  void ExportToChannelz(std::string name, channelz::DataSink sink);
+
  protected:
   friend class Arena;
 
@@ -407,6 +436,7 @@ class Party : public Activity, private Wakeable {
     }
 
     bool PollParticipantPromise() override {
+      GRPC_LATENT_SEE_INNER_SCOPE(TypeName<SuppliedFactory>());
       if (!started_) {
         auto p = factory_.Make();
         Destruct(&factory_);
@@ -422,6 +452,21 @@ class Party : public Activity, private Wakeable {
       return false;
     }
 
+    channelz::PropertyList ChannelzProperties() override {
+      return channelz::PropertyList()
+          .Set("on_complete", TypeName<OnComplete>())
+          .Set("factory", [this]() {
+            channelz::PropertyList factory;
+            if (started_) {
+              factory.Set("promise", PromiseProperty(&promise_));
+            } else {
+              factory.Set("factory",
+                          TypeName<typename Factory::UnderlyingFactory>());
+            }
+            return factory;
+          }());
+    }
+
     void Destroy() override { delete this; }
 
    private:
@@ -463,6 +508,7 @@ class Party : public Activity, private Wakeable {
 
     // Inside party poll: drive from factory -> promise -> result
     bool PollParticipantPromise() override {
+      GRPC_LATENT_SEE_INNER_SCOPE(TypeName<SuppliedFactory>());
       switch (state_.load(std::memory_order_relaxed)) {
         case State::kFactory: {
           auto p = factory_.Make();
@@ -503,6 +549,23 @@ class Party : public Activity, private Wakeable {
 
     void Destroy() override { this->Unref(); }
 
+    channelz::PropertyList ChannelzProperties() override {
+      channelz::PropertyList properties;
+      switch (state_.load(std::memory_order_relaxed)) {
+        case State::kFactory:
+          properties.Set("factory",
+                         TypeName<typename Factory::UnderlyingFactory>());
+          break;
+        case State::kPromise:
+          properties.Set("promise", PromiseProperty(&promise_));
+          break;
+        case State::kResult:
+          properties.Set("result", TypeName<typename Promise::Result>());
+          break;
+      }
+      return properties;
+    }
+
    private:
     enum class State : uint8_t { kFactory, kPromise, kResult };
     union {
@@ -580,7 +643,7 @@ class Party : public Activity, private Wakeable {
         // If the party is locked, we need to set the wakeup bits, and then
         // we'll immediately unref. Since something is running this should never
         // bring the refcount to zero.
-        if (kReffed) {
+        if constexpr (kReffed) {
           DCHECK_GT(cur_state & kRefMask, kOneRef);
         } else {
           DCHECK_GE(cur_state & kRefMask, kOneRef);
@@ -626,6 +689,8 @@ class Party : public Activity, private Wakeable {
                            new_state);
   }
 
+  channelz::PropertyList ChannelzPropertiesLocked();
+
   // Sentinel value for currently_polling_ when no participant is being polled.
   static constexpr uint8_t kNotPolling = 255;
 

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

@@ -19,6 +19,9 @@
 
 #include <utility>
 
+#include "src/core/util/json/json.h"
+#include "src/proto/grpc/channelz/v2/promise.upb.h"
+
 namespace grpc_core {
 
 /// Run all the promises, return the first result that's available.
@@ -47,6 +50,24 @@ class Race<Promise, Promises...> {
     return std::move(r.value());
   }
 
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    auto* race_promise =
+        grpc_channelz_v2_Promise_mutable_race_promise(promise_proto, arena);
+    auto** children = grpc_channelz_v2_Promise_Race_resize_children(
+        race_promise, 1 + sizeof...(Promises), arena);
+    for (size_t i = 0; i < 1 + sizeof...(Promises); ++i) {
+      children[i] = grpc_channelz_v2_Promise_new(arena);
+    }
+    SetChildrenProto(children, 0, arena);
+  }
+
+  void SetChildrenProto(grpc_channelz_v2_Promise** promise_protos, int index,
+                        upb_Arena* arena) const {
+    PromiseAsProto(promise_, promise_protos[index], arena);
+    next_.SetChildrenProto(promise_protos, index + 1, arena);
+  }
+
  private:
   // The Promise checked by this instance.
   Promise promise_;
@@ -64,6 +85,16 @@ class Race<Promise> {
     return promise_();
   }
 
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    PromiseAsProto(promise_, promise_proto, arena);
+  }
+
+  void SetChildrenProto(grpc_channelz_v2_Promise** promise_protos, int index,
+                        upb_Arena* arena) const {
+    PromiseAsProto(promise_, promise_protos[index], arena);
+  }
+
  private:
   Promise promise_;
 };

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

@@ -108,7 +108,10 @@ class Seq {
     return state_.PollOnce();
   }
 
-  Json ToJson() const { return state_.ToJson("Seq"); }
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    state_.ToProto(grpc_channelz_v2_Promise_NORMAL, promise_proto, arena);
+  }
 
  private:
   SeqState<SeqTraits, P, Fs...> state_;

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

@@ -275,6 +275,13 @@ class ValueOrFailure {
     return value_ != other;
   }
 
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator==(Failure) const {
+    return !value_.has_value();
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator!=(Failure) const {
+    return value_.has_value();
+  }
+
  private:
   std::optional<T> value_;
 };

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

@@ -263,7 +263,10 @@ class TrySeq {
     return state_.PollOnce();
   }
 
-  Json ToJson() const { return state_.ToJson("TrySeq"); }
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    state_.ToProto(grpc_channelz_v2_Promise_TRY, promise_proto, arena);
+  }
 
  private:
   SeqState<TrySeqTraits, P, Fs...> state_;

data/src/core/lib/promise/wait_set.cc

@@ -0,0 +1,28 @@
+// Copyright 2025 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 "src/core/lib/promise/wait_set.h"
+
+#include "absl/strings/str_join.h"
+
+namespace grpc_core {
+
+std::string WaitSet::ToString() {
+  return absl::StrJoin(pending_, ", ",
+                       [](std::string* out, const Waker& waker) {
+                         absl::StrAppend(out, waker.DebugString());
+                       });
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,86 @@
+// Copyright 2021 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_WAIT_SET_H
+#define GRPC_SRC_CORE_LIB_PROMISE_WAIT_SET_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/hash/hash.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// Helper type that can be used to enqueue many Activities waiting for some
+// external state.
+// Typically the external state should be guarded by mu_, and a call to
+// WakeAllAndUnlock should be made when the state changes.
+// Promises should bottom out polling inside pending(), which will register for
+// wakeup and return Pending().
+// Queues handles to Activities, and not Activities themselves, meaning that if
+// an Activity is destroyed prior to wakeup we end up holding only a small
+// amount of memory (around 16 bytes + malloc overhead) until the next wakeup
+// occurs.
+class WaitSet final {
+  using WakerSet = absl::flat_hash_set<Waker>;
+
+ public:
+  // Register for wakeup, return Pending(). If state is not ready to proceed,
+  // Promises should bottom out here.
+  Pending AddPending(Waker waker) {
+    pending_.emplace(std::move(waker));
+    return Pending();
+  }
+
+  class WakeupSet {
+   public:
+    void Wakeup() {
+      while (!wakeup_.empty()) {
+        wakeup_.extract(wakeup_.begin()).value().Wakeup();
+      }
+    }
+
+   private:
+    friend class WaitSet;
+    explicit WakeupSet(WakerSet&& wakeup)
+        : wakeup_(std::forward<WakerSet>(wakeup)) {}
+    WakerSet wakeup_;
+  };
+
+  GRPC_MUST_USE_RESULT WakeupSet TakeWakeupSet() {
+    auto ret = WakeupSet(std::move(pending_));
+    pending_.clear();  // reinitialize after move.
+    return ret;
+  }
+
+  void WakeupAsync() {
+    while (!pending_.empty()) {
+      pending_.extract(pending_.begin()).value().WakeupAsync();
+    }
+  }
+
+  std::string ToString();
+
+ private:
+  // Handles to activities that need to be awoken.
+  WakerSet pending_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_WAIT_SET_H

data/src/core/lib/resource_quota/arena.h

@@ -409,6 +409,25 @@ class ArenaSpsc {
     return result;
   }
 
+  T* Peek() {
+    Node* n = tail_.load(std::memory_order_relaxed);
+    Node* next = n->next.load(std::memory_order_acquire);
+    if (next == nullptr) return nullptr;
+    return &next->value;
+  }
+
+  // Iterate over queued nodes. At most one thread can be calling this at a
+  // time, and no other thread can be calling Pop().
+  template <typename F>
+  void ForEach(F f) {
+    Node* tail = tail_.load(std::memory_order_relaxed);
+    Node* n = tail->next.load(std::memory_order_acquire);
+    while (n != nullptr) {
+      f(n->value);
+      n = n->next.load(std::memory_order_acquire);
+    }
+  }
+
  private:
   struct Node {
     Node() {}

data/src/core/lib/slice/slice.h

@@ -294,6 +294,11 @@ class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND MutableSlice
     return MutableSlice(NoCheck{}, grpc_slice_split_head(c_slice_ptr(), n));
   }
 
+  MutableSlice TakeFirstNoInline(size_t n) {
+    return MutableSlice(NoCheck{},
+                        grpc_slice_split_head_no_inline(c_slice_ptr(), n));
+  }
+
   // Iterator access to the underlying bytes
   uint8_t* begin() { return mutable_data(); }
   uint8_t* end() { return mutable_data() + size(); }

data/src/core/lib/surface/channel_create.cc

@@ -16,6 +16,7 @@
 
 #include "src/core/lib/surface/channel_create.h"
 
+#include <grpc/create_channel_from_endpoint.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/port_platform.h>
@@ -30,12 +31,19 @@
 #include "src/core/credentials/transport/transport_credentials.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/event_engine/endpoint_channel_arg_wrapper.h"
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
+#include "src/core/lib/event_engine/query_extensions.h"
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
 #include "src/core/lib/surface/legacy_channel.h"
+#include "src/core/resolver/fake/fake_resolver.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/transport/endpoint_transport.h"
@@ -75,9 +83,7 @@ absl::StatusOr<RefCountedPtr<Channel>> ChannelCreate(
     std::string channelz_node_target{target.empty() ? "unknown" : target};
     auto channelz_node = MakeRefCounted<channelz::ChannelNode>(
         channelz_node_target, channel_tracer_max_memory, is_internal_channel);
-    channelz_node->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string("Channel created"));
+    GRPC_CHANNELZ_LOG(channelz_node) << "Channel created";
     channelz_node->SetChannelArgs(args);
     // Add channelz node to channel args.
     // We remove the is_internal_channel arg, since we no longer need it.
@@ -105,25 +111,24 @@ absl::StatusOr<RefCountedPtr<Channel>> ChannelCreate(
   }
 }
 
-namespace {
 absl::StatusOr<grpc_channel*> CreateClientEndpointChannel(
     const char* target, grpc_channel_credentials* creds,
-    const grpc_channel_args* c_args) {
+    const ChannelArgs& args) {
   const auto& c = CoreConfiguration::Get();
   if (target == nullptr) {
     return absl::InternalError("channel target is NULL");
   }
   if (creds == nullptr) return absl::InternalError("No credentials provided");
-  auto args = creds->update_arguments(c.channel_args_preconditioning()
-                                          .PreconditionChannelArgs(c_args)
-                                          .SetObject(creds->Ref()));
+  auto final_args = creds->update_arguments(args.SetObject(creds->Ref()));
   std::vector<absl::string_view> transport_preferences = absl::StrSplit(
-      args.GetString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS).value_or("h2"),
+      final_args.GetString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS)
+          .value_or("h2"),
       ',');
   if (transport_preferences.size() != 1) {
     return absl::InternalError(absl::StrCat(
         "Only one preferred transport name is currently supported: requested='",
-        *args.GetOwnedString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS), "'"));
+        *final_args.GetOwnedString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS),
+        "'"));
   }
   auto* transport =
       c.endpoint_transport_registry().GetTransport(transport_preferences[0]);
@@ -131,10 +136,77 @@ absl::StatusOr<grpc_channel*> CreateClientEndpointChannel(
     return absl::InternalError(
         absl::StrCat("Unknown transport '", transport_preferences[0], "'"));
   }
-  return transport->ChannelCreate(target, args);
+  return transport->ChannelCreate(target, final_args);
 }
 
-}  // namespace
+namespace experimental {
+
+using ::grpc_event_engine::experimental::ChannelArgsEndpointConfig;
+using ::grpc_event_engine::experimental::EndpointChannelArgWrapper;
+using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::EventEngineSupportsFdExtension;
+using ::grpc_event_engine::experimental::QueryExtension;
+
+grpc_channel* CreateChannelFromEndpoint(
+    std::unique_ptr<EventEngine::Endpoint> endpoint,
+    grpc_channel_credentials* creds, const grpc_channel_args* args) {
+  auto address_str = ResolvedAddressToString(endpoint->GetPeerAddress());
+  // TODO(rishesh@) once https://github.com/grpc/grpc/issues/34172 is
+  // resolved, we should use a different address that will be less confusing for
+  // debuggability.
+  grpc_resolved_address address =
+      CreateGRPCResolvedAddress(endpoint->GetPeerAddress());
+  auto response_generator = MakeRefCounted<FakeResolverResponseGenerator>();
+  ChannelArgs channel_args =
+      CoreConfiguration::Get()
+          .channel_args_preconditioning()
+          .PreconditionChannelArgs(args)
+          .SetObject(
+              MakeRefCounted<EndpointChannelArgWrapper>(std::move(endpoint)));
+  if (address_str.ok() && !address_str->empty()) {
+    channel_args = channel_args.SetIfUnset(
+        GRPC_ARG_DEFAULT_AUTHORITY, URI::PercentEncodeAuthority(*address_str));
+  }
+  Resolver::Result result;
+  result.args = channel_args;
+  result.addresses = EndpointAddressesList({EndpointAddresses{address, {}}});
+  response_generator->SetResponseAsync(std::move(result));
+  auto r = CreateClientEndpointChannel(
+      "fake:created-from-endpoint", creds,
+      channel_args.SetObject(std::move(response_generator)));
+  if (!r.ok()) {
+    return grpc_lame_client_channel_create(
+        "fake:created-from-endpoint",
+        static_cast<grpc_status_code>(r.status().code()),
+        absl::StrCat(
+            "Failed to create channel to 'fake:created-from-endpoint':",
+            r.status().message())
+            .c_str());
+  }
+  return *r;
+}
+
+grpc_channel* CreateChannelFromFd(int fd, grpc_channel_credentials* creds,
+                                  const grpc_channel_args* args) {
+  ChannelArgs channel_args = CoreConfiguration::Get()
+                                 .channel_args_preconditioning()
+                                 .PreconditionChannelArgs(args);
+  EventEngineSupportsFdExtension* supports_fd =
+      QueryExtension<EventEngineSupportsFdExtension>(
+          channel_args.GetObjectRef<EventEngine>().get());
+  if (supports_fd == nullptr) {
+    return grpc_lame_client_channel_create("fake:created-from-endpoint",
+                                           GRPC_STATUS_INTERNAL,
+                                           "Failed to create client channel");
+  }
+  std::unique_ptr<EventEngine::Endpoint> endpoint =
+      supports_fd->CreateEndpointFromFd(
+          fd, ChannelArgsEndpointConfig(channel_args));
+  return CreateChannelFromEndpoint(std::move(endpoint), creds,
+                                   channel_args.ToC().get());
+}
+}  // namespace experimental
+
 }  // namespace grpc_core
 
 grpc_channel* grpc_lame_client_channel_create(const char* target,
@@ -173,7 +245,10 @@ grpc_channel* grpc_channel_create(const char* target,
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_channel_create(target=" << target << ", creds=" << (void*)creds
       << ", args=" << (void*)c_args << ")";
-  auto r = grpc_core::CreateClientEndpointChannel(target, creds, c_args);
+  const auto& c = grpc_core::CoreConfiguration::Get();
+  grpc_core::ChannelArgs channel_args =
+      c.channel_args_preconditioning().PreconditionChannelArgs(c_args);
+  auto r = grpc_core::CreateClientEndpointChannel(target, creds, channel_args);
   if (!r.ok()) {
     return grpc_lame_client_channel_create(
         target, static_cast<grpc_status_code>(r.status().code()),

data/src/core/lib/surface/channel_create.h

@@ -37,6 +37,10 @@ absl::StatusOr<RefCountedPtr<Channel>> ChannelCreate(
     std::string target, ChannelArgs args,
     grpc_channel_stack_type channel_stack_type, Transport* optional_transport);
 
+absl::StatusOr<grpc_channel*> CreateClientEndpointChannel(
+    const char* target, grpc_channel_credentials* creds,
+    const ChannelArgs& args);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_CREATE_H