grpc 1.71.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"
@@ -35,8 +38,10 @@
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
+#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"
 
@@ -166,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);
 
@@ -280,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;
@@ -305,7 +327,8 @@ class Party : public Activity, private Wakeable {
   // The party can poll the promise until it is resolved, or until the party is
   // shut down.
   // The on_complete callback will be called with the result of the
-  // promise if it completes.
+  // promise if it completes. Even if the promise returns a failed status,
+  // on_complete will be called.
   // promise_factory called to create the promise with the party lock taken;
   // after the promise is created the factory is destroyed. This means that
   // pointers or references to factory members will be invalidated after the
@@ -365,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;
 
@@ -405,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_);
@@ -420,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:
@@ -461,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();
@@ -501,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 {
@@ -578,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);
@@ -624,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;
 
@@ -637,6 +704,8 @@ class Party : public Activity, private Wakeable {
   RefCountedPtr<Arena> arena_;
 };
 
+GRPC_CHECK_CLASS_SIZE(Party, 180);
+
 template <>
 struct ContextSubclass<Party> {
   using Base = Activity;

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

@@ -23,6 +23,7 @@
 
 #include "absl/log/check.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 #include "src/core/util/construct_destruct.h"
 
 namespace grpc_core {
@@ -281,39 +282,40 @@ std::string PollToString(
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<T>& poll) {
-  if (poll.pending()) {
-    absl::Format(&sink, "<<pending>>");
+void PollValueStringify(Sink& sink, const T& value) {
+  absl::Format(&sink, "%v", value);
+}
+
+template <typename Sink, typename... Ts>
+void PollValueStringify(Sink& sink, const std::tuple<Ts...>& values) {
+  absl::Format(&sink, "(%v)", absl::StrJoin(values, ", "));
+}
+
+template <typename Sink, typename T>
+void PollValueStringify(Sink& sink, const std::optional<T>& value) {
+  if (!value.has_value()) {
+    sink.Append("nullopt");
     return;
   }
-  absl::Format(&sink, "%v", poll.value());
+  PollValueStringify(sink, *value);
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<absl::StatusOr<T>>& poll) {
-  if (poll.pending()) {
-    absl::Format(&sink, "<<pending>>");
+void PollValueStringify(Sink& sink, const absl::StatusOr<T>& value) {
+  if (!value.ok()) {
+    PollValueStringify(sink, value.status());
     return;
   }
-  if (poll.value().ok()) {
-    absl::Format(&sink, "%v", *poll.value());
-  } else {
-    absl::Format(&sink, "%v", poll.value().status());
-  }
+  PollValueStringify(sink, *value);
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<std::optional<T>>& poll) {
+void AbslStringify(Sink& sink, const Poll<T>& poll) {
   if (poll.pending()) {
     absl::Format(&sink, "<<pending>>");
     return;
   }
-  const auto& value = poll.value();
-  if (value.has_value()) {
-    absl::Format(&sink, "%v", value);
-  } else {
-    sink.append("nullopt");
-  }
+  PollValueStringify(sink, poll.value());
 }
 
 // Hack to get metadata printing
@@ -326,7 +328,7 @@ void AbslStringify(
   }
   const auto& value = poll.value();
   if (value.has_value()) {
-    absl::Format(&sink, "%v", *value);
+    PollValueStringify(sink, *value);
   } else {
     sink.Append("nullopt");
   }

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

@@ -24,6 +24,8 @@
 #include "absl/status/status.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/util/function_signature.h"
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 
@@ -83,12 +85,12 @@ struct ImmediateOkStatus {
 };
 
 // Typecheck that a promise returns the expected return type.
-// usage: auto promise = WithResult<int>([]() { return 3; });
+// usage: auto promise = AssertResultType<int>([]() { return 3; });
 // NOTE: there are tests in promise_test.cc that are commented out because they
 // should fail to compile. When modifying this code these should be uncommented
 // and their miscompilation verified.
 template <typename T, typename F>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto WithResult(F f) ->
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto AssertResultType(F f) ->
     typename std::enable_if<std::is_same<decltype(f()), Poll<T>>::value,
                             F>::type {
   return f;

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,6 +108,11 @@ class Seq {
     return state_.PollOnce();
   }
 
+  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/sleep.cc

@@ -37,9 +37,12 @@ Sleep::~Sleep() {
 }
 
 Poll<absl::Status> Sleep::operator()() {
-  // Invalidate now so that we see a fresh version of the time.
-  // TODO(ctiller): the following can be safely removed when we remove ExecCtx.
-  ExecCtx::Get()->InvalidateNow();
+  if (!IsSleepPromiseExecCtxRemovalEnabled()) {
+    // Invalidate now so that we see a fresh version of the time.
+    // TODO(ctiller): the following can be safely removed when we remove
+    // ExecCtx.
+    ExecCtx::Get()->InvalidateNow();
+  }
   const auto now = Timestamp::Now();
   // If the deadline is earlier than now we can just return.
   if (deadline_ <= now) return absl::OkStatus();

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

@@ -24,6 +24,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 #include "src/core/lib/promise/detail/status.h"
 
 namespace grpc_core {
@@ -274,15 +275,11 @@ class ValueOrFailure {
     return value_ != other;
   }
 
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, const ValueOrFailure& value) {
-    if (value.ok()) {
-      sink.Append("Success(");
-      sink.Append(absl::StrCat(*value));
-      sink.Append(")");
-    } else {
-      sink.Append("Failure");
-    }
+  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:
@@ -299,6 +296,28 @@ inline std::ostream& operator<<(std::ostream& os,
   }
 }
 
+template <typename Sink, typename T>
+void AbslStringify(Sink& sink, const ValueOrFailure<T>& value) {
+  if (value.ok()) {
+    sink.Append("Success(");
+    sink.Append(absl::StrCat(*value));
+    sink.Append(")");
+  } else {
+    sink.Append("Failure");
+  }
+}
+
+template <typename Sink, typename... Ts>
+void AbslStringify(Sink& sink, const ValueOrFailure<std::tuple<Ts...>>& value) {
+  if (value.ok()) {
+    sink.Append("Success(");
+    sink.Append(absl::StrCat("(", absl::StrJoin(*value, ", "), ")"));
+    sink.Append(")");
+  } else {
+    sink.Append("Failure");
+  }
+}
+
 template <typename T>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool IsStatusOk(
     const ValueOrFailure<T>& value) {

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

@@ -263,6 +263,11 @@ class TrySeq {
     return state_.PollOnce();
   }
 
+  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/resource_quota/memory_quota.cc

@@ -152,6 +152,15 @@ ReclamationSweep::~ReclamationSweep() {
   }
 }
 
+void ReclamationSweep::Finish() {
+  auto memory_quota = std::move(memory_quota_);
+  if (memory_quota != nullptr) {
+    auto sweep_token = sweep_token_;
+    auto waker = std::move(waker_);
+    memory_quota->FinishReclamation(sweep_token, std::move(waker));
+  }
+}
+
 //
 // ReclaimerQueue
 //

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

@@ -112,9 +112,7 @@ class ReclamationSweep {
   // Explicit finish for users that wish to write it.
   // Just destroying the object is enough, but sometimes the additional
   // explicitness is warranted.
-  void Finish() {
-    [](ReclamationSweep) {}(std::move(*this));
-  }
+  void Finish();
 
  private:
   std::shared_ptr<BasicMemoryQuota> memory_quota_;

data/src/core/lib/security/authorization/evaluate_args.cc

@@ -23,9 +23,9 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
+#include "src/core/credentials/transport/tls/tls_utils.h"
 #include "src/core/handshaker/endpoint_info/endpoint_info_handshaker.h"
 #include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/security/credentials/tls/tls_utils.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/uri.h"

data/src/core/lib/security/authorization/evaluate_args.h

@@ -23,9 +23,9 @@
 #include <vector>
 
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -24,13 +24,13 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_join.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/latent_see.h"
 

data/src/core/lib/security/authorization/grpc_server_authz_filter.h

@@ -25,8 +25,8 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/authorization/authorization_policy_provider.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
-#include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/transport/auth_context.h"
 #include "src/core/util/ref_counted_ptr.h"
 
 namespace grpc_core {

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(); }
@@ -432,6 +437,12 @@ class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND Slice
   static Slice FromExternalString(absl::string_view str) {
     return FromStaticString(str);
   }
+
+  static Slice ZeroContentsWithLength(size_t length) {
+    grpc_slice backing = grpc_slice_malloc(length);
+    memset(GRPC_SLICE_START_PTR(backing), 0, length);
+    return Slice(backing);
+  }
 };
 
 }  // namespace grpc_core