grpc 1.73.0 → 1.74.0

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

@@ -52,6 +52,23 @@ struct CompareChannelFiltersByName {
     return a.name() < b.name();
   }
 };
+
+struct CompareFusedChannelFiltersByName {
+  bool operator()(ChannelInit::FilterRegistration* a,
+                  ChannelInit::FilterRegistration* b) const {
+    // Sort by descending order based on number of filters contained in the
+    // FusedFilter.
+    int num_filters_a =
+        std::count(a->name().name().begin(), a->name().name().end(), '+') + 1;
+    int num_filters_b =
+        std::count(b->name().name().begin(), b->name().name().end(), '+') + 1;
+    if (num_filters_a == num_filters_b) {
+      return a->name().name() > b->name().name();
+    }
+    return num_filters_a > num_filters_b;
+  }
+};
+
 }  // namespace
 
 ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::After(
@@ -111,6 +128,14 @@ ChannelInit::FilterRegistration& ChannelInit::Builder::RegisterFilter(
   return *filters_[type].back();
 }
 
+void ChannelInit::Builder::RegisterFusedFilter(
+    grpc_channel_stack_type type, UniqueTypeName name,
+    const grpc_channel_filter* filter, FilterAdder filter_adder,
+    SourceLocation registration_source) {
+  fused_filters_[type].emplace_back(std::make_unique<FilterRegistration>(
+      name, filter, filter_adder, registration_source));
+}
+
 class ChannelInit::DependencyTracker {
  public:
   // Declare that a filter exists.
@@ -232,10 +257,61 @@ class ChannelInit::DependencyTracker {
   size_t nodes_taken_ = 0;
 };
 
-ChannelInit::StackConfig ChannelInit::BuildStackConfig(
+template <bool is_terminal>
+std::vector<ChannelInit::FilterNode> ChannelInit::SelectFiltersByPredicate(
+    const std::vector<Filter>& filters, ChannelStackBuilder* builder) {
+  std::vector<FilterNode> filter_list;
+  int i = 0;
+  // Create an in-place linked list of individual filters
+  for (const auto& filter : filters) {
+    if (!is_terminal && SkipV2(filter.version)) continue;
+    if (!filter.CheckPredicates(builder->channel_args())) continue;
+    filter_list.push_back(FilterNode{&filter, ++i});
+  }
+  if (!filter_list.empty()) {
+    filter_list.back().next = -1;
+  }
+  return filter_list;
+}
+
+void ChannelInit::MergeFilters(std::vector<FilterNode>& filter_list,
+                               const std::vector<Filter>& fused_filters) {
+  int i = 0;
+  int j = 0;
+  // Iterate through fused filters (by size) and check if a given fused filter
+  // can replace one of the existing sequence of filters.
+  for (auto& curr_fused_filter : fused_filters) {
+    i = 0;
+    while (i != -1 && filter_list[i].next != -1) {
+      std::string fused_prefix(filter_list[i].curr->name.name());
+      j = filter_list[i].next;
+      do {
+        absl::StrAppend(&fused_prefix, "+", filter_list[j].curr->name.name());
+        if (fused_prefix == curr_fused_filter.name.name()) {
+          filter_list[i].curr = &curr_fused_filter;
+          filter_list[i].next = filter_list[j].next;
+        }
+        j = filter_list[j].next;
+      } while (j != -1);
+      i = filter_list[i].next;
+    }
+  }
+}
+
+void ChannelInit::AppendFiltersToBuilder(
+    const std::vector<FilterNode>& filter_list, ChannelStackBuilder* builder) {
+  int i = 0;
+  while (i != -1 && !filter_list.empty()) {
+    builder->AppendFilter(filter_list[i].curr->filter);
+    i = filter_list[i].next;
+  };
+}
+
+std::tuple<std::vector<ChannelInit::Filter>, std::vector<ChannelInit::Filter>>
+ChannelInit::SortFilterRegistrationsByDependencies(
     const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
-        registrations,
-    PostProcessor* post_processors, grpc_channel_stack_type type) {
+        filter_registrations,
+    grpc_channel_stack_type type) {
   // Phase 1: Build a map from filter to the set of filters that must be
   // initialized before it.
   // We order this map (and the set of dependent filters) by filter name to
@@ -244,7 +320,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
   // this will help overall stability.
   DependencyTracker dependencies;
   std::vector<Filter> terminal_filters;
-  for (const auto& registration : registrations) {
+  for (const auto& registration : filter_registrations) {
     if (registration->terminal_) {
       CHECK(registration->after_.empty());
       CHECK(registration->before_.empty());
@@ -258,7 +334,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
       dependencies.Declare(registration.get());
     }
   }
-  for (const auto& registration : registrations) {
+  for (const auto& registration : filter_registrations) {
     if (registration->terminal_) continue;
     for (UniqueTypeName after : registration->after_) {
       dependencies.InsertEdge(after, registration->name_);
@@ -267,7 +343,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
       dependencies.InsertEdge(registration->name_, before);
     }
     if (registration->before_all_) {
-      for (const auto& other : registrations) {
+      for (const auto& other : filter_registrations) {
         if (other.get() == registration.get()) continue;
         if (other->terminal_) continue;
         dependencies.InsertEdge(registration->name_, other->name_);
@@ -286,6 +362,42 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
         std::move(registration->predicates_), registration->version_,
         registration->ordering_, registration->registration_source_);
   }
+  // Log out the graph we built if that's been requested.
+  if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
+    PrintChannelStackTrace(type, filter_registrations, dependencies, filters,
+                           terminal_filters);
+  }
+  return std::tuple(std::move(filters), std::move(terminal_filters));
+}
+
+std::vector<ChannelInit::Filter> ChannelInit::SortFusedFilterRegistrations(
+    const std::vector<std::unique_ptr<FilterRegistration>>&
+        filter_registrations) {
+  std::vector<FilterRegistration*> fused_filter_registrations;
+  std::vector<Filter> filters;
+  for (const auto& registration : filter_registrations) {
+    CHECK(!registration->terminal_);
+    fused_filter_registrations.push_back(registration.get());
+  }
+  std::sort(fused_filter_registrations.begin(),
+            fused_filter_registrations.end(),
+            CompareFusedChannelFiltersByName());
+
+  for (auto registration : fused_filter_registrations) {
+    filters.emplace_back(
+        registration->name_, registration->filter_, registration->filter_adder_,
+        std::move(registration->predicates_), registration->version_,
+        registration->ordering_, registration->registration_source_);
+  }
+  return filters;
+}
+
+ChannelInit::StackConfig ChannelInit::BuildStackConfig(
+    const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
+        filter_registrations,
+    const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
+        fused_filter_registrations,
+    PostProcessor* post_processors, grpc_channel_stack_type type) {
   // Collect post processors that need to be applied.
   // We've already ensured the one-per-slot constraint, so now we can just
   // collect everything up into a vector and run it in order.
@@ -294,27 +406,32 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
     if (post_processors[i] == nullptr) continue;
     post_processor_functions.emplace_back(std::move(post_processors[i]));
   }
-  // Log out the graph we built if that's been requested.
-  if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
-    PrintChannelStackTrace(type, registrations, dependencies, filters,
-                           terminal_filters);
-  }
+
+  auto sorted_filters =
+      SortFilterRegistrationsByDependencies(filter_registrations, type);
+  std::vector<Filter> filters = std::move(std::get<0>(sorted_filters));
+  std::vector<Filter> terminal_filters = std::move(std::get<1>(sorted_filters));
+
+  std::vector<Filter> fused_filters =
+      SortFusedFilterRegistrations(fused_filter_registrations);
+
   // Check if there are no terminal filters: this would be an error.
-  // GRPC_CLIENT_DYNAMIC stacks don't use this mechanism, so we don't check that
-  // condition here.
-  // Right now we only log: many tests end up with a core configuration that
-  // is invalid.
+  // GRPC_CLIENT_DYNAMIC stacks don't use this mechanism, so we don't check
+  // that condition here. Right now we only log: many tests end up with a
+  // core configuration that is invalid.
   // TODO(ctiller): evaluate if we can turn this into a crash one day.
-  // Right now it forces too many tests to know about channel initialization,
-  // either by supplying a valid configuration or by including an opt-out flag.
+  // Right now it forces too many tests to know about channel
+  // initialization, either by supplying a valid configuration or by
+  // including an opt-out flag.
   if (terminal_filters.empty() && type != GRPC_CLIENT_DYNAMIC) {
-    LOG(ERROR) << "No terminal filters registered for channel stack type "
-               << grpc_channel_stack_type_string(type)
-               << "; this is common for unit tests messing with "
-                  "CoreConfiguration, but will result in a "
-                  "ChannelInit::CreateStack that never completes successfully.";
+    VLOG(2) << "No terminal filters registered for channel stack type "
+            << grpc_channel_stack_type_string(type)
+            << "; this is common for unit tests messing with "
+               "CoreConfiguration, but will result in a "
+               "ChannelInit::CreateStack that never completes successfully.";
   }
-  return StackConfig{std::move(filters), std::move(terminal_filters),
+  return StackConfig{std::move(filters), std::move(fused_filters),
+                     std::move(terminal_filters),
                      std::move(post_processor_functions)};
 };
 
@@ -333,6 +450,7 @@ void ChannelInit::PrintChannelStackTrace(
   MutexLock lock(m);
   // List the channel stack type (since we'll be repeatedly printing graphs in
   // this loop).
+
   LOG(INFO) << "ORDERED CHANNEL STACK " << grpc_channel_stack_type_string(type)
             << ":";
   // First build up a map of filter -> file:line: strings, because it helps
@@ -411,7 +529,7 @@ ChannelInit ChannelInit::Builder::Build() {
   ChannelInit result;
   for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
     result.stack_configs_[i] =
-        BuildStackConfig(filters_[i], post_processors_[i],
+        BuildStackConfig(filters_[i], fused_filters_[i], post_processors_[i],
                          static_cast<grpc_channel_stack_type>(i));
   }
   return result;
@@ -426,41 +544,40 @@ bool ChannelInit::Filter::CheckPredicates(const ChannelArgs& args) const {
 
 bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
   const auto& stack_config = stack_configs_[builder->channel_stack_type()];
-  for (const auto& filter : stack_config.filters) {
-    if (SkipV2(filter.version)) continue;
-    if (!filter.CheckPredicates(builder->channel_args())) continue;
-    builder->AppendFilter(filter.filter);
-  }
-  int found_terminators = 0;
-  for (const auto& terminator : stack_config.terminators) {
-    if (!terminator.CheckPredicates(builder->channel_args())) continue;
-    builder->AppendFilter(terminator.filter);
-    ++found_terminators;
-  }
-  if (found_terminators != 1) {
+  auto filter_list =
+      SelectFiltersByPredicate<false>(stack_config.filters, builder);
+  auto terminal_filter_list =
+      SelectFiltersByPredicate<true>(stack_config.terminators, builder);
+
+  if (terminal_filter_list.size() != 1) {
+    int filter_count = terminal_filter_list.size();
     std::string error = absl::StrCat(
-        found_terminators,
-        " terminating filters found creating a channel of type ",
+        filter_count, " terminating filters found creating a channel of type ",
         grpc_channel_stack_type_string(builder->channel_stack_type()),
         " with arguments ", builder->channel_args().ToString(),
         " (we insist upon one and only one terminating "
         "filter)\n");
-    if (stack_config.terminators.empty()) {
+    if (terminal_filter_list.empty()) {
       absl::StrAppend(&error, "  No terminal filters were registered");
     } else {
-      for (const auto& terminator : stack_config.terminators) {
-        absl::StrAppend(&error, "  ", terminator.name, " registered @ ",
-                        terminator.registration_source.file(), ":",
-                        terminator.registration_source.line(), ": enabled = ",
-                        terminator.CheckPredicates(builder->channel_args())
-                            ? "true"
-                            : "false",
-                        "\n");
+      for (const auto& terminator : terminal_filter_list) {
+        absl::StrAppend(
+            &error, "  ", terminator.curr->name, " registered @ ",
+            terminator.curr->registration_source.file(), ":",
+            terminator.curr->registration_source.line(), ": enabled = ",
+            terminator.curr->CheckPredicates(builder->channel_args()) ? "true"
+                                                                      : "false",
+            "\n");
       }
     }
     LOG(ERROR) << error;
     return false;
   }
+
+  MergeFilters(filter_list, stack_config.fused_filters);
+  AppendFiltersToBuilder(filter_list, builder);
+  AppendFiltersToBuilder(terminal_filter_list, builder);
+
   for (const auto& post_processor : stack_config.post_processors) {
     post_processor(*builder);
   }

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

@@ -270,6 +270,8 @@ class ChannelInit {
       return *this;
     }
 
+    const UniqueTypeName& name() { return name_; }
+
    private:
     friend class ChannelInit;
     const UniqueTypeName name_;
@@ -322,6 +324,34 @@ class ChannelInit {
           .SkipV3();
     }
 
+    // Register a builder in the normal fused filter registration pass.
+    // This occurs first during channel build time.
+    // The FilterRegistration methods can be called to declaratively define
+    // properties of the filter being registered.
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
+    void RegisterFusedFilter(grpc_channel_stack_type type, UniqueTypeName name,
+                             const grpc_channel_filter* filter,
+                             FilterAdder filter_adder = nullptr,
+                             SourceLocation registration_source = {});
+
+    void RegisterFusedFilter(grpc_channel_stack_type type,
+                             const grpc_channel_filter* filter,
+                             SourceLocation registration_source = {}) {
+      CHECK(filter != nullptr);
+      RegisterFusedFilter(type, NameFromChannelFilter(filter), filter, nullptr,
+                          registration_source);
+    }
+
+    template <typename Filter>
+    void RegisterFusedFilter(grpc_channel_stack_type type,
+                             SourceLocation registration_source = {}) {
+      RegisterFusedFilter(
+          type, UniqueTypeNameFor<Filter>(), &Filter::kFilter,
+          [](InterceptionChainBuilder& builder) { builder.Add<Filter>(); },
+          registration_source);
+    }
+
     // Register a post processor for the builder.
     // These run after the main graph has been placed into the builder.
     // At most one filter per slot per channel stack type can be added.
@@ -341,6 +371,8 @@ class ChannelInit {
    private:
     std::vector<std::unique_ptr<FilterRegistration>>
         filters_[GRPC_NUM_CHANNEL_STACK_TYPES];
+    std::vector<std::unique_ptr<FilterRegistration>>
+        fused_filters_[GRPC_NUM_CHANNEL_STACK_TYPES];
     PostProcessor post_processors_[GRPC_NUM_CHANNEL_STACK_TYPES]
                                   [static_cast<int>(PostProcessorSlot::kCount)];
   };
@@ -382,17 +414,48 @@ class ChannelInit {
     Ordering ordering;
     bool CheckPredicates(const ChannelArgs& args) const;
   };
+
+  struct FilterNode {
+    const Filter* curr;
+    int next;
+  };
+
   struct StackConfig {
     std::vector<Filter> filters;
+    std::vector<Filter> fused_filters;
     std::vector<Filter> terminators;
     std::vector<PostProcessor> post_processors;
   };
 
   StackConfig stack_configs_[GRPC_NUM_CHANNEL_STACK_TYPES];
 
+  static std::tuple<std::vector<Filter>, std::vector<Filter>>
+  SortFilterRegistrationsByDependencies(
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          filter_registrations,
+      grpc_channel_stack_type type);
+
+  static std::vector<Filter> SortFusedFilterRegistrations(
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          filter_registrations);
+
+  template <bool is_terminal>
+  static std::vector<FilterNode> SelectFiltersByPredicate(
+      const std::vector<Filter>& filters, ChannelStackBuilder* builder);
+
+  static void MergeFilters(std::vector<FilterNode>& filter_list,
+                           const std::vector<Filter>& fused_filters);
+
+  static void AppendFiltersToBuilder(const std::vector<FilterNode>& filter_list,
+                                     ChannelStackBuilder* builder);
+
   static StackConfig BuildStackConfig(
-      const std::vector<std::unique_ptr<FilterRegistration>>& registrations,
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          filter_registrations,
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          fused_filter_registrations,
       PostProcessor* post_processors, grpc_channel_stack_type type);
+
   static void PrintChannelStackTrace(
       grpc_channel_stack_type type,
       const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&

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

@@ -40,6 +40,7 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
+#include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
@@ -398,18 +399,26 @@ bool FilterStackCall::PrepareApplicationMetadata(size_t count,
       is_trailing ? &send_trailing_metadata_ : &send_initial_metadata_;
   for (size_t i = 0; i < count; i++) {
     grpc_metadata* md = &metadata[i];
-    if (!GRPC_LOG_IF_ERROR("validate_metadata",
-                           grpc_validate_header_key_is_legal(md->key))) {
+    if (auto status = grpc_validate_header_key_is_legal(md->key);
+        !status.ok()) {
+      LOG(ERROR) << "Metadata key '"
+                 << absl::CEscape(StringViewFromSlice(md->key))
+                 << "' is invalid: " << status;
       return false;
-    } else if (!grpc_is_binary_header_internal(md->key) &&
-               !GRPC_LOG_IF_ERROR(
-                   "validate_metadata",
-                   grpc_validate_header_nonbin_value_is_legal(md->value))) {
-      return false;
-    } else if (GRPC_SLICE_LENGTH(md->value) >= UINT32_MAX) {
+    }
+    if (!grpc_is_binary_header_internal(md->key)) {
+      if (auto status = grpc_validate_header_nonbin_value_is_legal(md->value);
+          !status.ok()) {
+        LOG(ERROR) << "Metadata value for key " << StringViewFromSlice(md->key)
+                   << " is invalid: " << status;
+        return false;
+      }
+    }
+    if (GRPC_SLICE_LENGTH(md->value) >= UINT32_MAX) {
       // HTTP2 hpack encoding has a maximum limit.
       return false;
-    } else if (grpc_slice_str_cmp(md->key, "content-length") == 0) {
+    }
+    if (grpc_slice_str_cmp(md->key, "content-length") == 0) {
       // Filter "content-length metadata"
       continue;
     }

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

@@ -71,21 +71,12 @@ static bool g_shutting_down ABSL_GUARDED_BY(g_init_mu) = false;
 
 namespace grpc_core {
 void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
-  if (IsCallv3ClientAuthFilterEnabled()) {
-    builder->channel_init()
-        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-    builder->channel_init()
-        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-  } else {
-    builder->channel_init()
-        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-    builder->channel_init()
-        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-  }
+  builder->channel_init()
+      ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
+      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  builder->channel_init()
+      ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
   builder->channel_init()
       ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
       .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);

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

@@ -63,7 +63,7 @@ namespace grpc_core {
 
 absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
     std::string target, ChannelArgs args,
-    grpc_channel_stack_type channel_stack_type) {
+    grpc_channel_stack_type channel_stack_type, const Blackboard* blackboard) {
   if (grpc_channel_stack_type_is_client(channel_stack_type)) {
     auto channel_args_mutator =
         grpc_channel_args_get_client_channel_creation_mutator();
@@ -113,6 +113,7 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
       grpc_channel_stack_type_string(channel_stack_type), channel_stack_type,
       args);
   builder.SetTarget(target.c_str());
+  builder.SetBlackboard(blackboard);
   if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
     return nullptr;
   }
@@ -161,10 +162,7 @@ LegacyChannel::LegacyChannel(bool is_client, std::string target,
     node = channelz_node()->RefAsSubclass<channelz::ChannelNode>();
   }
   *channel_stack_->on_destroy = [node = std::move(node)]() {
-    if (node != nullptr) {
-      node->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
-                          grpc_slice_from_static_string("Channel destroyed"));
-    }
+    GRPC_CHANNELZ_LOG(node) << "Channel destroyed";
     ShutdownInternally();
   };
 }

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

@@ -29,6 +29,7 @@
 #include "absl/status/statusor.h"
 #include "src/core/call/call_arena_allocator.h"
 #include "src/core/client_channel/client_channel_filter.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"  // IWYU pragma: keep
@@ -47,7 +48,8 @@ class LegacyChannel final : public Channel {
  public:
   static absl::StatusOr<RefCountedPtr<Channel>> Create(
       std::string target, ChannelArgs args,
-      grpc_channel_stack_type channel_stack_type);
+      grpc_channel_stack_type channel_stack_type,
+      const Blackboard* blackboard = nullptr);
 
   // Do not instantiate directly -- use Create() instead.
   LegacyChannel(bool is_client, std::string target,

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

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "48.0.0"; }
+const char* grpc_version_string(void) { return "49.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gradient"; }
+const char* grpc_g_stands_for(void) { return "gee"; }

data/src/core/lib/transport/promise_endpoint.cc

@@ -0,0 +1,110 @@
+// Copyright 2023 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/transport/promise_endpoint.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/slice_buffer.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <utility>
+
+#include "absl/log/check.h"
+#include "absl/status/status.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/sync.h"
+
+namespace grpc_core {
+
+PromiseEndpoint::PromiseEndpoint(
+    std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        endpoint,
+    SliceBuffer already_received)
+    : endpoint_(std::move(endpoint)) {
+  CHECK_NE(endpoint_, nullptr);
+  read_state_->endpoint = endpoint_;
+  // TODO(ladynana): Replace this with `SliceBufferCast<>` when it is
+  // available.
+  grpc_slice_buffer_swap(read_state_->buffer.c_slice_buffer(),
+                         already_received.c_slice_buffer());
+}
+
+const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
+PromiseEndpoint::GetPeerAddress() const {
+  return endpoint_->GetPeerAddress();
+}
+
+const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
+PromiseEndpoint::GetLocalAddress() const {
+  return endpoint_->GetLocalAddress();
+}
+
+void PromiseEndpoint::ReadState::Complete(absl::Status status,
+                                          const size_t num_bytes_requested) {
+  GRPC_LATENT_SEE_INNER_SCOPE("PromiseEndpoint::ReadState::Complete");
+  while (true) {
+    if (!status.ok()) {
+      // Invalidates all previous reads.
+      pending_buffer.Clear();
+      buffer.Clear();
+      result = status;
+      auto w = std::move(waker);
+      complete.store(true, std::memory_order_release);
+      w.Wakeup();
+      return;
+    }
+    // Appends `pending_buffer` to `buffer`.
+    pending_buffer.MoveFirstNBytesIntoSliceBuffer(pending_buffer.Length(),
+                                                  buffer);
+    DCHECK(pending_buffer.Count() == 0u);
+    if (buffer.Length() < num_bytes_requested) {
+      GRPC_LATENT_SEE_INNER_SCOPE("PromiseEndpoint::ReadState::Continue");
+      // A further read is needed.
+      // Set read args with number of bytes needed as hint.
+      grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs
+          read_args;
+      read_args.set_read_hint_bytes(
+          static_cast<int64_t>(num_bytes_requested - buffer.Length()));
+      // If `Read()` returns true immediately, the callback will not be
+      // called. We still need to call our callback to pick up the result and
+      // maybe do further reads.
+      auto ep = endpoint.lock();
+      if (ep == nullptr) {
+        status = absl::UnavailableError("Endpoint closed during read.");
+        continue;
+      }
+      if (ep->Read(
+              [self = Ref(), num_bytes_requested](absl::Status status) {
+                ExecCtx exec_ctx;
+                self->Complete(std::move(status), num_bytes_requested);
+              },
+              &pending_buffer, std::move(read_args))) {
+        continue;
+      }
+      return;
+    }
+    result = status;
+    auto w = std::move(waker);
+    complete.store(true, std::memory_order_release);
+    w.Wakeup();
+    return;
+  }
+}
+
+}  // namespace grpc_core