grpc 1.73.0 → 1.74.0

data/src/core/handshaker/security/secure_endpoint.cc

@@ -30,16 +30,19 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cstddef>
 #include <memory>
 #include <optional>
 #include <regex>
 #include <utility>
+#include <vector>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -183,6 +186,10 @@ class FrameProtector : public RefCounted<FrameProtector> {
 
   absl::Status Unprotect(absl::Status read_status)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(read_mu_) {
+    if (shutdown_) {
+      return absl::CancelledError("secure endpoint shutdown");
+    }
+
     GRPC_LATENT_SEE_INNER_SCOPE("unprotect");
     bool keep_looping = false;
     tsi_result result = TSI_OK;
@@ -312,6 +319,8 @@ class FrameProtector : public RefCounted<FrameProtector> {
 
   tsi_result Protect(grpc_slice_buffer* slices, int max_frame_size)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(write_mu_) {
+    if (shutdown_) return TSI_FAILED_PRECONDITION;
+
     GRPC_LATENT_SEE_INNER_SCOPE("protect");
     uint8_t* cur = GRPC_SLICE_START_PTR(write_staging_buffer_);
     uint8_t* end = GRPC_SLICE_END_PTR(write_staging_buffer_);
@@ -414,7 +423,10 @@ class FrameProtector : public RefCounted<FrameProtector> {
     return &output_buffer_;
   }
 
-  void Shutdown() { memory_owner_.Reset(); }
+  void Shutdown() {
+    shutdown_ = true;
+    memory_owner_.Reset();
+  }
 
  private:
   struct tsi_frame_protector* const protector_;
@@ -436,6 +448,7 @@ class FrameProtector : public RefCounted<FrameProtector> {
   std::atomic<bool> has_posted_reclaimer_{false};
   int min_progress_size_ = 1;
   SliceBuffer protector_staging_buffer_;
+  bool shutdown_ = false;
 };
 }  // namespace
 }  // namespace grpc_core
@@ -567,14 +580,15 @@ static void on_write(void* user_data, grpc_error_handle error) {
   });
 }
 
-static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
-                           grpc_closure* cb, void* arg, int max_frame_size) {
+static void endpoint_write(
+    grpc_endpoint* secure_ep, grpc_slice_buffer* slices, grpc_closure* cb,
+    grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs args) {
   GRPC_LATENT_SEE_INNER_SCOPE("secure_endpoint write");
   secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   tsi_result result;
   {
     grpc_core::MutexLock lock(ep->frame_protector.write_mu());
-    result = ep->frame_protector.Protect(slices, max_frame_size);
+    result = ep->frame_protector.Protect(slices, args.max_frame_size());
   }
 
   if (result != TSI_OK) {
@@ -591,7 +605,7 @@ static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
   ep->write_cb = cb;
   grpc_endpoint_write(ep->wrapped_ep.get(),
                       ep->frame_protector.output_buffer()->c_slice_buffer(),
-                      &ep->on_write, arg, max_frame_size);
+                      &ep->on_write, std::move(args));
 }
 
 static void endpoint_destroy(grpc_endpoint* secure_ep) {
@@ -692,21 +706,59 @@ class SecureEndpoint final : public EventEngine::Endpoint {
     return impl_->QueryExtension(id);
   }
 
-  std::vector<size_t> AllWriteMetrics() override {
-    return impl_->AllWriteMetrics();
-  }
-
-  std::optional<absl::string_view> GetMetricName(size_t key) override {
-    return impl_->GetMetricName(key);
-  }
-
-  std::optional<size_t> GetMetricKey(absl::string_view name) override {
-    return impl_->GetMetricKey(name);
+  std::shared_ptr<TelemetryInfo> GetTelemetryInfo() const override {
+    return std::make_shared<Impl::TelemetryInfo>(impl_->GetTelemetryInfo());
   }
 
  private:
   class Impl : public grpc_core::RefCounted<Impl> {
    public:
+    class TelemetryInfo : public EventEngine::Endpoint::TelemetryInfo {
+     public:
+      explicit TelemetryInfo(
+          std::shared_ptr<EventEngine::Endpoint::TelemetryInfo>
+              wrapped_telemetry_info)
+          : wrapped_telemetry_info_(std::move(wrapped_telemetry_info)) {}
+
+      std::vector<size_t> AllWriteMetrics() const override {
+        return wrapped_telemetry_info_
+                   ? wrapped_telemetry_info_->AllWriteMetrics()
+                   : std::vector<size_t>{};
+      }
+
+      std::optional<absl::string_view> GetMetricName(
+          size_t key) const override {
+        return wrapped_telemetry_info_
+                   ? wrapped_telemetry_info_->GetMetricName(key)
+                   : std::nullopt;
+      }
+
+      std::optional<size_t> GetMetricKey(
+          absl::string_view name) const override {
+        return wrapped_telemetry_info_
+                   ? wrapped_telemetry_info_->GetMetricKey(name)
+                   : std::nullopt;
+      }
+
+      std::shared_ptr<EventEngine::Endpoint::MetricsSet> GetMetricsSet(
+          absl::Span<const size_t> keys) const override {
+        return wrapped_telemetry_info_
+                   ? wrapped_telemetry_info_->GetMetricsSet(keys)
+                   : nullptr;
+      }
+
+      std::shared_ptr<EventEngine::Endpoint::MetricsSet> GetFullMetricsSet()
+          const override {
+        return wrapped_telemetry_info_
+                   ? wrapped_telemetry_info_->GetFullMetricsSet()
+                   : nullptr;
+      }
+
+     private:
+      std::shared_ptr<EventEngine::Endpoint::TelemetryInfo>
+          wrapped_telemetry_info_;
+    };
+
     Impl(std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
              wrapped_ep,
          struct tsi_frame_protector* protector,
@@ -837,16 +889,9 @@ class SecureEndpoint final : public EventEngine::Endpoint {
       frame_protector_.Shutdown();
     }
 
-    virtual std::vector<size_t> AllWriteMetrics() {
-      return wrapped_ep_->AllWriteMetrics();
-    }
-
-    virtual std::optional<absl::string_view> GetMetricName(size_t key) {
-      return wrapped_ep_->GetMetricName(key);
-    }
-
-    virtual std::optional<size_t> GetMetricKey(absl::string_view name) {
-      return wrapped_ep_->GetMetricKey(name);
+    std::shared_ptr<TelemetryInfo> GetTelemetryInfo() const {
+      return std::make_shared<Impl::TelemetryInfo>(
+          wrapped_ep_->GetTelemetryInfo());
     }
 
    private:

data/src/core/handshaker/security/security_handshaker.cc

@@ -373,13 +373,16 @@ grpc_error_handle SecurityHandshaker::OnHandshakeNextDoneLocked(
     outgoing_.Clear();
     outgoing_.Append(Slice::FromCopiedBuffer(
         reinterpret_cast<const char*>(bytes_to_send), bytes_to_send_size));
+    grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs
+        write_args;
+    write_args.set_max_frame_size(INT_MAX);
     grpc_endpoint_write(
         args_->endpoint.get(), outgoing_.c_slice_buffer(),
         NewClosure(
             [self = RefAsSubclass<SecurityHandshaker>()](absl::Status status) {
               self->OnHandshakeDataSentToPeerFnScheduler(std::move(status));
             }),
-        nullptr, /*max_frame_size=*/INT_MAX);
+        std::move(write_args));
   } else if (handshaker_result == nullptr) {
     // There is nothing to send, but need to read from peer.
     grpc_endpoint_read(

data/src/core/handshaker/tcp_connect/tcp_connect_handshaker.cc

@@ -119,11 +119,17 @@ void TCPConnectHandshaker::Shutdown(absl::Status /*error*/) {
 void TCPConnectHandshaker::DoHandshake(
     HandshakerArgs* args,
     absl::AnyInvocable<void(absl::Status)> on_handshake_done) {
+  // If the endpoint already exists, skip the TCP connection step.
+  // In this case, the handshaker becomes a no-op, it simply completes the
+  // handshake successfully without performing any action.
+  if (args->endpoint != nullptr) {
+    InvokeOnHandshakeDone(args, std::move(on_handshake_done), absl::OkStatus());
+    return;
+  }
   {
     MutexLock lock(&mu_);
     on_handshake_done_ = std::move(on_handshake_done);
   }
-  CHECK_EQ(args->endpoint.get(), nullptr);
   args_ = args;
   absl::string_view resolved_address_text =
       args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value();

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

@@ -291,6 +291,21 @@ absl::string_view ChannelArgs::Value::ToString(
   return backing_strings.back();
 }
 
+channelz::PropertyList ChannelArgs::ToPropertyList() const {
+  channelz::PropertyList result;
+  args_.ForEach(
+      [&result](const RefCountedStringValue& key, const Value& value) {
+        if (auto i = value.GetIfInt(); i.has_value()) {
+          result.Set(key.as_string_view(), *i);
+        } else if (auto s = value.GetIfString(); s != nullptr) {
+          result.Set(key.as_string_view(), s->as_string_view());
+        } else if (auto p = value.GetIfPointer(); p != nullptr) {
+          result.Set(key.as_string_view(), "POINTER");
+        }
+      });
+  return result;
+}
+
 std::string ChannelArgs::ToString() const {
   std::vector<absl::string_view> strings;
   std::list<std::string> backing_strings;

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

@@ -35,6 +35,7 @@
 
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/avl.h"
 #include "src/core/util/debug_location.h"
@@ -507,6 +508,8 @@ class ChannelArgs {
   GRPC_MUST_USE_RESULT ChannelArgs Remove(absl::string_view name) const;
   bool Contains(absl::string_view name) const;
 
+  channelz::PropertyList ToPropertyList() const;
+
   GRPC_MUST_USE_RESULT ChannelArgs
   RemoveAllKeysWithPrefix(absl::string_view prefix) const;
 

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

@@ -26,6 +26,7 @@
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/surface/channel_init.h"
@@ -114,8 +115,7 @@ grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
     const grpc_core::ChannelArgs& channel_args, const char* name,
-    grpc_channel_stack* stack, const grpc_core::Blackboard* old_blackboard,
-    grpc_core::Blackboard* new_blackboard) {
+    grpc_channel_stack* stack, const grpc_core::Blackboard* blackboard) {
   if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
     LOG(INFO) << "CHANNEL_STACK: init " << name;
     for (size_t i = 0; i < filter_count; i++) {
@@ -144,8 +144,7 @@ grpc_error_handle grpc_channel_stack_init(
                                              sizeof(grpc_channel_element));
 
   // init per-filter data
-  args.old_blackboard = old_blackboard;
-  args.new_blackboard = new_blackboard;
+  args.blackboard = blackboard;
   grpc_error_handle first_error;
   for (i = 0; i < filter_count; i++) {
     args.channel_stack = stack;
@@ -177,28 +176,28 @@ grpc_error_handle grpc_channel_stack_init(
 }
 
 void grpc_channel_stack::ChannelStackDataSource::AddData(
-    grpc_core::channelz::DataSink& sink) {
-  using grpc_core::Json;
-  Json::Object output;
-  output["type"] = Json::FromString("v1");
-  Json::Array elements;
+    grpc_core::channelz::DataSink sink) {
   grpc_channel_stack* channel_stack = reinterpret_cast<grpc_channel_stack*>(
       reinterpret_cast<char*>(this) -
       offsetof(grpc_channel_stack, channelz_data_source));
-  output["call_stack_size"] = Json::FromNumber(channel_stack->call_stack_size);
-  grpc_channel_element* elems = CHANNEL_ELEMS_FROM_STACK(channel_stack);
-  elements.reserve(channel_stack->count);
-  for (size_t i = 0; i < channel_stack->count; i++) {
-    grpc_channel_element& e = elems[i];
-    Json::Object element;
-    element["type"] = Json::FromString(std::string(e.filter->name.name()));
-    element["call_data_size"] = Json::FromNumber(e.filter->sizeof_call_data);
-    element["channel_data_size"] =
-        Json::FromNumber(e.filter->sizeof_channel_data);
-    elements.emplace_back(Json::FromObject(std::move(element)));
-  }
-  output["elements"] = Json::FromArray(std::move(elements));
-  sink.AddAdditionalInfo("channelStack", std::move(output));
+  sink.AddData(
+      "channel_stack",
+      grpc_core::channelz::PropertyList()
+          .Set("type", "v1")
+          .Set("elements", [channel_stack]() {
+            grpc_core::channelz::PropertyTable elements;
+            grpc_channel_element* elems =
+                CHANNEL_ELEMS_FROM_STACK(channel_stack);
+            for (size_t i = 0; i < channel_stack->count; i++) {
+              grpc_channel_element& e = elems[i];
+              elements.AppendRow(
+                  grpc_core::channelz::PropertyList()
+                      .Set("type", e.filter->name.name())
+                      .Set("call_data_size", e.filter->sizeof_call_data)
+                      .Set("channel_data_size", e.filter->sizeof_channel_data));
+            }
+            return elements;
+          }()));
 }
 
 void grpc_channel_stack_destroy(grpc_channel_stack* stack) {

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

@@ -75,8 +75,7 @@ struct grpc_channel_element_args {
   grpc_core::ChannelArgs channel_args;
   int is_first;
   int is_last;
-  const grpc_core::Blackboard* old_blackboard;
-  grpc_core::Blackboard* new_blackboard;
+  const grpc_core::Blackboard* blackboard;
 };
 struct grpc_call_element_args {
   grpc_call_stack* call_stack;
@@ -190,9 +189,13 @@ struct grpc_channel_stack {
 
   class ChannelStackDataSource final : public grpc_core::channelz::DataSource {
    public:
-    using grpc_core::channelz::DataSource::DataSource;
-    ~ChannelStackDataSource() { ResetDataSource(); }
-    void AddData(grpc_core::channelz::DataSink& sink) override;
+    explicit ChannelStackDataSource(
+        grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> node)
+        : DataSource(std::move(node)) {
+      SourceConstructed();
+    }
+    ~ChannelStackDataSource() { SourceDestructing(); }
+    void AddData(grpc_core::channelz::DataSink sink) override;
   };
 
   grpc_core::ManualConstructor<ChannelStackDataSource> channelz_data_source;
@@ -269,8 +272,7 @@ grpc_error_handle grpc_channel_stack_init(
     const grpc_channel_filter** filters, size_t filter_count,
     const grpc_core::ChannelArgs& args, const char* name,
     grpc_channel_stack* stack,
-    const grpc_core::Blackboard* old_blackboard = nullptr,
-    grpc_core::Blackboard* new_blackboard = nullptr);
+    const grpc_core::Blackboard* blackboard = nullptr);
 // Destroy a channel stack
 void grpc_channel_stack_destroy(grpc_channel_stack* stack);
 

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

@@ -75,7 +75,7 @@ ChannelStackBuilderImpl::Build() {
         gpr_free(stk);
       },
       channel_stack, stack.data(), stack.size(), channel_args(), name(),
-      channel_stack, old_blackboard_, new_blackboard_);
+      channel_stack, blackboard_);
 
   if (!error.ok()) {
     grpc_channel_stack_destroy(channel_stack);

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

@@ -35,11 +35,7 @@ class ChannelStackBuilderImpl final : public ChannelStackBuilder {
  public:
   using ChannelStackBuilder::ChannelStackBuilder;
 
-  void SetBlackboards(const Blackboard* old_blackboard,
-                      Blackboard* new_blackboard) {
-    old_blackboard_ = old_blackboard;
-    new_blackboard_ = new_blackboard;
-  }
+  void SetBlackboard(const Blackboard* blackboard) { blackboard_ = blackboard; }
 
   // Build the channel stack.
   // After success, *result holds the new channel stack,
@@ -49,8 +45,7 @@ class ChannelStackBuilderImpl final : public ChannelStackBuilder {
   absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() override;
 
  private:
-  const Blackboard* old_blackboard_ = nullptr;
-  Blackboard* new_blackboard_ = nullptr;
+  const Blackboard* blackboard_ = nullptr;
 };
 
 }  // namespace grpc_core

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

@@ -1979,11 +1979,11 @@ struct ChannelFilterWithFlagsMethods {
   static absl::Status InitChannelElem(grpc_channel_element* elem,
                                       grpc_channel_element_args* args) {
     CHECK(args->is_last == ((kFlags & kFilterIsLast) != 0));
-    auto status = F::Create(
-        args->channel_args,
-        ChannelFilter::Args(args->channel_stack, elem,
-                            grpc_channel_stack_filter_instance_number,
-                            args->old_blackboard, args->new_blackboard));
+    auto status =
+        F::Create(args->channel_args,
+                  ChannelFilter::Args(args->channel_stack, elem,
+                                      grpc_channel_stack_filter_instance_number,
+                                      args->blackboard));
     if (!status.ok()) {
       new (elem->channel_data) F*(nullptr);
       return absl_status_to_grpc_error(status.status());

data/src/core/lib/debug/trace_impl.h

@@ -75,7 +75,6 @@ class TraceFlag {
     value_.store(enabled, std::memory_order_relaxed);
   }
 
-  TraceFlag* next_tracer_;
   const char* const name_;
   std::atomic<bool> value_;
 };