grpc 1.46.3-x86_64-linux → 1.48.0-x86_64-linux

data/src/core/ext/filters/http/message_compress/message_decompress_filter.cc

@@ -20,24 +20,30 @@
 
 #include "src/core/ext/filters/http/message_compress/message_decompress_filter.h"
 
-#include <assert.h>
+#include <stdint.h>
 #include <string.h>
 
+#include <new>
+
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/types/optional.h"
 
-#include <grpc/compression.h>
-#include <grpc/slice_buffer.h>
-#include <grpc/support/alloc.h>
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/compression/message_compress.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 namespace {
@@ -45,7 +51,8 @@ namespace {
 class ChannelData {
  public:
   explicit ChannelData(const grpc_channel_element_args* args)
-      : max_recv_size_(GetMaxRecvSizeFromChannelArgs(args->channel_args)),
+      : max_recv_size_(GetMaxRecvSizeFromChannelArgs(
+            ChannelArgs::FromC(args->channel_args))),
         message_size_service_config_parser_index_(
             MessageSizeParser::ParserIndex()) {}
 
@@ -69,9 +76,6 @@ class CallData {
                       OnRecvInitialMetadataReady, this,
                       grpc_schedule_on_exec_ctx);
     // Initialize state for recv_message_ready callback
-    grpc_slice_buffer_init(&recv_slices_);
-    GRPC_CLOSURE_INIT(&on_recv_message_next_done_, OnRecvMessageNextDone, this,
-                      grpc_schedule_on_exec_ctx);
     GRPC_CLOSURE_INIT(&on_recv_message_ready_, OnRecvMessageReady, this,
                       grpc_schedule_on_exec_ctx);
     // Initialize state for recv_trailing_metadata_ready callback
@@ -88,8 +92,6 @@ class CallData {
     }
   }
 
-  ~CallData() { grpc_slice_buffer_destroy_internal(&recv_slices_); }
-
   void DecompressStartTransportStreamOpBatch(
       grpc_call_element* elem, grpc_transport_stream_op_batch* batch);
 
@@ -99,10 +101,6 @@ class CallData {
   // Methods for processing a receive message event
   void MaybeResumeOnRecvMessageReady();
   static void OnRecvMessageReady(void* arg, grpc_error_handle error);
-  static void OnRecvMessageNextDone(void* arg, grpc_error_handle error);
-  grpc_error_handle PullSliceFromRecvMessage();
-  void ContinueReadingRecvMessage();
-  void FinishRecvMessage();
   void ContinueRecvMessageReadyCallback(grpc_error_handle error);
 
   // Methods for processing a recv_trailing_metadata event
@@ -120,17 +118,10 @@ class CallData {
   bool seen_recv_message_ready_ = false;
   int max_recv_message_length_;
   grpc_compression_algorithm algorithm_ = GRPC_COMPRESS_NONE;
+  absl::optional<SliceBuffer>* recv_message_ = nullptr;
+  uint32_t* recv_message_flags_ = nullptr;
   grpc_closure on_recv_message_ready_;
   grpc_closure* original_recv_message_ready_ = nullptr;
-  grpc_closure on_recv_message_next_done_;
-  OrphanablePtr<ByteStream>* recv_message_ = nullptr;
-  // recv_slices_ holds the slices read from the original recv_message stream.
-  // It is initialized during construction and reset when a new stream is
-  // created using it.
-  grpc_slice_buffer recv_slices_;
-  std::aligned_storage<sizeof(SliceBufferByteStream),
-                       alignof(SliceBufferByteStream)>::type
-      recv_replacement_stream_;
   // Fields for handling recv_trailing_metadata_ready callback
   bool seen_recv_trailing_metadata_ready_ = false;
   grpc_closure on_recv_trailing_metadata_ready_;
@@ -140,7 +131,7 @@ class CallData {
 
 void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     calld->algorithm_ =
         calld->recv_initial_metadata_->get(GrpcEncodingMetadata())
             .value_or(GRPC_COMPRESS_NONE);
@@ -163,7 +154,7 @@ void CallData::MaybeResumeOnRecvMessageReady() {
 
 void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (calld->original_recv_initial_metadata_ready_ != nullptr) {
       calld->seen_recv_message_ready_ = true;
       GRPC_CALL_COMBINER_STOP(calld->call_combiner_,
@@ -174,101 +165,46 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
     if (calld->algorithm_ != GRPC_COMPRESS_NONE) {
       // recv_message can be NULL if trailing metadata is received instead of
       // message, or it's possible that the message was not compressed.
-      if (*calld->recv_message_ == nullptr ||
-          (*calld->recv_message_)->length() == 0 ||
-          ((*calld->recv_message_)->flags() & GRPC_WRITE_INTERNAL_COMPRESS) ==
-              0) {
+      if (!calld->recv_message_->has_value() ||
+          (*calld->recv_message_)->Length() == 0 ||
+          ((*calld->recv_message_flags_ & GRPC_WRITE_INTERNAL_COMPRESS) == 0)) {
         return calld->ContinueRecvMessageReadyCallback(GRPC_ERROR_NONE);
       }
       if (calld->max_recv_message_length_ >= 0 &&
-          (*calld->recv_message_)->length() >
+          (*calld->recv_message_)->Length() >
               static_cast<uint32_t>(calld->max_recv_message_length_)) {
-        GPR_DEBUG_ASSERT(calld->error_ == GRPC_ERROR_NONE);
+        GPR_DEBUG_ASSERT(GRPC_ERROR_IS_NONE(calld->error_));
         calld->error_ = grpc_error_set_int(
             GRPC_ERROR_CREATE_FROM_CPP_STRING(
                 absl::StrFormat("Received message larger than max (%u vs. %d)",
-                                (*calld->recv_message_)->length(),
+                                (*calld->recv_message_)->Length(),
                                 calld->max_recv_message_length_)),
             GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
         return calld->ContinueRecvMessageReadyCallback(
             GRPC_ERROR_REF(calld->error_));
       }
-      grpc_slice_buffer_destroy_internal(&calld->recv_slices_);
-      grpc_slice_buffer_init(&calld->recv_slices_);
-      return calld->ContinueReadingRecvMessage();
+      SliceBuffer decompressed_slices;
+      if (grpc_msg_decompress(calld->algorithm_,
+                              (*calld->recv_message_)->c_slice_buffer(),
+                              decompressed_slices.c_slice_buffer()) == 0) {
+        GPR_DEBUG_ASSERT(GRPC_ERROR_IS_NONE(calld->error_));
+        calld->error_ = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+            "Unexpected error decompressing data for algorithm with "
+            "enum value ",
+            calld->algorithm_));
+      } else {
+        *calld->recv_message_flags_ =
+            (*calld->recv_message_flags_ & (~GRPC_WRITE_INTERNAL_COMPRESS)) |
+            GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED;
+        (*calld->recv_message_)->Swap(&decompressed_slices);
+      }
+      return calld->ContinueRecvMessageReadyCallback(
+          GRPC_ERROR_REF(calld->error_));
     }
   }
   calld->ContinueRecvMessageReadyCallback(GRPC_ERROR_REF(error));
 }
 
-void CallData::ContinueReadingRecvMessage() {
-  while ((*recv_message_)
-             ->Next((*recv_message_)->length() - recv_slices_.length,
-                    &on_recv_message_next_done_)) {
-    grpc_error_handle error = PullSliceFromRecvMessage();
-    if (error != GRPC_ERROR_NONE) {
-      return ContinueRecvMessageReadyCallback(error);
-    }
-    // We have read the entire message.
-    if (recv_slices_.length == (*recv_message_)->length()) {
-      return FinishRecvMessage();
-    }
-  }
-}
-
-grpc_error_handle CallData::PullSliceFromRecvMessage() {
-  grpc_slice incoming_slice;
-  grpc_error_handle error = (*recv_message_)->Pull(&incoming_slice);
-  if (error == GRPC_ERROR_NONE) {
-    grpc_slice_buffer_add(&recv_slices_, incoming_slice);
-  }
-  return error;
-}
-
-void CallData::OnRecvMessageNextDone(void* arg, grpc_error_handle error) {
-  CallData* calld = static_cast<CallData*>(arg);
-  if (error != GRPC_ERROR_NONE) {
-    return calld->ContinueRecvMessageReadyCallback(GRPC_ERROR_REF(error));
-  }
-  error = calld->PullSliceFromRecvMessage();
-  if (error != GRPC_ERROR_NONE) {
-    return calld->ContinueRecvMessageReadyCallback(error);
-  }
-  if (calld->recv_slices_.length == (*calld->recv_message_)->length()) {
-    calld->FinishRecvMessage();
-  } else {
-    calld->ContinueReadingRecvMessage();
-  }
-}
-
-void CallData::FinishRecvMessage() {
-  grpc_slice_buffer decompressed_slices;
-  grpc_slice_buffer_init(&decompressed_slices);
-  if (grpc_msg_decompress(algorithm_, &recv_slices_, &decompressed_slices) ==
-      0) {
-    GPR_DEBUG_ASSERT(error_ == GRPC_ERROR_NONE);
-    error_ = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("Unexpected error decompressing data for algorithm with "
-                     "enum value ",
-                     algorithm_));
-    grpc_slice_buffer_destroy_internal(&decompressed_slices);
-  } else {
-    uint32_t recv_flags =
-        ((*recv_message_)->flags() & (~GRPC_WRITE_INTERNAL_COMPRESS)) |
-        GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED;
-    // Swap out the original receive byte stream with our new one and send the
-    // batch down.
-    // Initializing recv_replacement_stream_ with decompressed_slices removes
-    // all the slices from decompressed_slices leaving it empty.
-    new (&recv_replacement_stream_)
-        SliceBufferByteStream(&decompressed_slices, recv_flags);
-    recv_message_->reset(
-        reinterpret_cast<SliceBufferByteStream*>(&recv_replacement_stream_));
-    recv_message_ = nullptr;
-  }
-  ContinueRecvMessageReadyCallback(GRPC_ERROR_REF(error_));
-}
-
 void CallData::ContinueRecvMessageReadyCallback(grpc_error_handle error) {
   MaybeResumeOnRecvTrailingMetadataReady();
   // The surface will clean up the receiving stream if there is an error.
@@ -320,6 +256,7 @@ void CallData::DecompressStartTransportStreamOpBatch(
   // Handle recv_message
   if (batch->recv_message) {
     recv_message_ = batch->payload->recv_message.recv_message;
+    recv_message_flags_ = batch->payload->recv_message.flags;
     original_recv_message_ready_ =
         batch->payload->recv_message.recv_message_ready;
     batch->payload->recv_message.recv_message_ready = &on_recv_message_ready_;
@@ -380,6 +317,7 @@ const grpc_channel_filter MessageDecompressFilter = {
     DecompressDestroyCallElem,
     sizeof(ChannelData),
     DecompressInitChannelElem,
+    grpc_channel_stack_no_post_init,
     DecompressDestroyChannelElem,
     grpc_channel_next_get_info,
     "message_decompress"};

data/src/core/ext/filters/http/message_compress/message_decompress_filter.h

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 
 namespace grpc_core {

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -20,303 +20,143 @@
 
 #include "src/core/ext/filters/http/server/http_server_filter.h"
 
-#include <string.h>
+#include <functional>
+#include <utility>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
+#include "absl/base/attributes.h"
+#include "absl/status/status.h"
+#include "absl/types/optional.h"
+#include "absl/utility/utility.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
-#include "src/core/lib/profiling/timers.h"
-#include "src/core/lib/slice/b64.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/promise/call_push_pull.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/seq.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/percent_encoding.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
-
-static void hs_recv_initial_metadata_ready(void* user_data,
-                                           grpc_error_handle err);
-static void hs_recv_trailing_metadata_ready(void* user_data,
-                                            grpc_error_handle err);
-
-namespace {
-
-struct call_data {
-  call_data(grpc_call_element* elem, const grpc_call_element_args& args)
-      : call_combiner(args.call_combiner) {
-    GRPC_CLOSURE_INIT(&recv_initial_metadata_ready,
-                      hs_recv_initial_metadata_ready, elem,
-                      grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready,
-                      hs_recv_trailing_metadata_ready, elem,
-                      grpc_schedule_on_exec_ctx);
-  }
-
-  ~call_data() { GRPC_ERROR_UNREF(recv_initial_metadata_ready_error); }
-
-  grpc_core::CallCombiner* call_combiner;
-
-  // State for intercepting recv_initial_metadata.
-  grpc_closure recv_initial_metadata_ready;
-  grpc_error_handle recv_initial_metadata_ready_error = GRPC_ERROR_NONE;
-  grpc_closure* original_recv_initial_metadata_ready;
-  grpc_metadata_batch* recv_initial_metadata = nullptr;
-  uint32_t* recv_initial_metadata_flags;
-  bool seen_recv_initial_metadata_ready = false;
-
-  // State for intercepting recv_trailing_metadata
-  grpc_closure recv_trailing_metadata_ready;
-  grpc_closure* original_recv_trailing_metadata_ready;
-  grpc_error_handle recv_trailing_metadata_ready_error;
-  bool seen_recv_trailing_metadata_ready = false;
-};
-
-struct channel_data {
-  bool surface_user_agent;
-};
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/transport/metadata_batch.h"
 
-}  // namespace
+namespace grpc_core {
 
-static grpc_error_handle hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
-  if (grpc_core::Slice* grpc_message =
-          b->get_pointer(grpc_core::GrpcMessageMetadata())) {
-    *grpc_message = grpc_core::PercentEncodeSlice(
-        std::move(*grpc_message), grpc_core::PercentEncodingType::Compatible);
-  }
-  return GRPC_ERROR_NONE;
-}
+const grpc_channel_filter HttpServerFilter::kFilter =
+    MakePromiseBasedFilter<HttpServerFilter, FilterEndpoint::kServer,
+                           kFilterExaminesServerInitialMetadata>("http-server");
 
-static void hs_add_error(const char* error_name, grpc_error_handle* cumulative,
-                         grpc_error_handle new_err) {
-  if (new_err == GRPC_ERROR_NONE) return;
-  if (*cumulative == GRPC_ERROR_NONE) {
-    *cumulative = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_name);
+namespace {
+void FilterOutgoingMetadata(ServerMetadata* md) {
+  if (Slice* grpc_message = md->get_pointer(GrpcMessageMetadata())) {
+    *grpc_message = PercentEncodeSlice(std::move(*grpc_message),
+                                       PercentEncodingType::Compatible);
   }
-  *cumulative = grpc_error_add_child(*cumulative, new_err);
 }
+}  // namespace
 
-static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
-                                                     grpc_metadata_batch* b) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  static const char* error_name = "Failed processing incoming headers";
+ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  const auto& md = call_args.client_initial_metadata;
 
-  auto method = b->get(grpc_core::HttpMethodMetadata());
+  auto method = md->get(HttpMethodMetadata());
   if (method.has_value()) {
     switch (*method) {
-      case grpc_core::HttpMethodMetadata::kPost:
-        break;
-      case grpc_core::HttpMethodMetadata::kInvalid:
-      case grpc_core::HttpMethodMetadata::kGet:
-        hs_add_error(error_name, &error,
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad method header"));
+      case HttpMethodMetadata::kPost:
         break;
+      case HttpMethodMetadata::kPut:
+        if (allow_put_requests_) {
+          break;
+        }
+        ABSL_FALLTHROUGH_INTENDED;
+      case HttpMethodMetadata::kInvalid:
+      case HttpMethodMetadata::kGet:
+        return Immediate(
+            ServerMetadataHandle(absl::UnknownError("Bad method header")));
     }
   } else {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, ":method"));
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :method header")));
   }
 
-  auto te = b->Take(grpc_core::TeMetadata());
-  if (te == grpc_core::TeMetadata::kTrailers) {
+  auto te = md->Take(TeMetadata());
+  if (te == TeMetadata::kTrailers) {
     // Do nothing, ok.
   } else if (!te.has_value()) {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, "te"));
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :te header")));
   } else {
-    hs_add_error(error_name, &error,
-                 GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad te header"));
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Bad :te header")));
   }
 
-  auto scheme = b->Take(grpc_core::HttpSchemeMetadata());
+  auto scheme = md->Take(HttpSchemeMetadata());
   if (scheme.has_value()) {
-    if (*scheme == grpc_core::HttpSchemeMetadata::kInvalid) {
-      hs_add_error(error_name, &error,
-                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad :scheme header"));
+    if (*scheme == HttpSchemeMetadata::kInvalid) {
+      return Immediate(
+          ServerMetadataHandle(absl::UnknownError("Bad :scheme header")));
     }
   } else {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, ":scheme"));
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :scheme header")));
   }
 
-  b->Remove(grpc_core::ContentTypeMetadata());
+  md->Remove(ContentTypeMetadata());
 
-  grpc_core::Slice* path_slice = b->get_pointer(grpc_core::HttpPathMetadata());
+  Slice* path_slice = md->get_pointer(HttpPathMetadata());
   if (path_slice == nullptr) {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, ":path"));
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :path header")));
   }
 
-  if (b->get_pointer(grpc_core::HttpAuthorityMetadata()) == nullptr) {
-    absl::optional<grpc_core::Slice> host = b->Take(grpc_core::HostMetadata());
+  if (md->get_pointer(HttpAuthorityMetadata()) == nullptr) {
+    absl::optional<Slice> host = md->Take(HostMetadata());
     if (host.has_value()) {
-      b->Set(grpc_core::HttpAuthorityMetadata(), std::move(*host));
+      md->Set(HttpAuthorityMetadata(), std::move(*host));
     }
   }
 
-  if (b->get_pointer(grpc_core::HttpAuthorityMetadata()) == nullptr) {
-    hs_add_error(error_name, &error,
-                 grpc_error_set_str(
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, ":authority"));
-  }
-
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  if (!chand->surface_user_agent) {
-    b->Remove(grpc_core::UserAgentMetadata());
-  }
-
-  return error;
-}
-
-static void hs_recv_initial_metadata_ready(void* user_data,
-                                           grpc_error_handle err) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->seen_recv_initial_metadata_ready = true;
-  if (err == GRPC_ERROR_NONE) {
-    err = hs_filter_incoming_metadata(elem, calld->recv_initial_metadata);
-    calld->recv_initial_metadata_ready_error = GRPC_ERROR_REF(err);
-  } else {
-    (void)GRPC_ERROR_REF(err);
-  }
-  if (calld->seen_recv_trailing_metadata_ready) {
-    GRPC_CALL_COMBINER_START(calld->call_combiner,
-                             &calld->recv_trailing_metadata_ready,
-                             calld->recv_trailing_metadata_ready_error,
-                             "resuming hs_recv_trailing_metadata_ready from "
-                             "hs_recv_initial_metadata_ready");
-  }
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->original_recv_initial_metadata_ready, err);
-}
-
-static void hs_recv_trailing_metadata_ready(void* user_data,
-                                            grpc_error_handle err) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  if (!calld->seen_recv_initial_metadata_ready) {
-    calld->recv_trailing_metadata_ready_error = GRPC_ERROR_REF(err);
-    calld->seen_recv_trailing_metadata_ready = true;
-    GRPC_CALL_COMBINER_STOP(calld->call_combiner,
-                            "deferring hs_recv_trailing_metadata_ready until "
-                            "ater hs_recv_initial_metadata_ready");
-    return;
-  }
-  err = grpc_error_add_child(
-      GRPC_ERROR_REF(err),
-      GRPC_ERROR_REF(calld->recv_initial_metadata_ready_error));
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->original_recv_trailing_metadata_ready, err);
-}
-
-static grpc_error_handle hs_mutate_op(grpc_call_element* elem,
-                                      grpc_transport_stream_op_batch* op) {
-  /* grab pointers to our data from the call element */
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-
-  if (op->send_initial_metadata) {
-    grpc_error_handle error = GRPC_ERROR_NONE;
-    static const char* error_name = "Failed sending initial metadata";
-    op->payload->send_initial_metadata.send_initial_metadata->Set(
-        grpc_core::HttpStatusMetadata(), 200);
-    op->payload->send_initial_metadata.send_initial_metadata->Set(
-        grpc_core::ContentTypeMetadata(),
-        grpc_core::ContentTypeMetadata::kApplicationGrpc);
-    hs_add_error(error_name, &error,
-                 hs_filter_outgoing_metadata(
-                     op->payload->send_initial_metadata.send_initial_metadata));
-    if (error != GRPC_ERROR_NONE) return error;
-  }
-
-  if (op->recv_initial_metadata) {
-    /* substitute our callback for the higher callback */
-    GPR_ASSERT(op->payload->recv_initial_metadata.recv_flags != nullptr);
-    calld->recv_initial_metadata =
-        op->payload->recv_initial_metadata.recv_initial_metadata;
-    calld->recv_initial_metadata_flags =
-        op->payload->recv_initial_metadata.recv_flags;
-    calld->original_recv_initial_metadata_ready =
-        op->payload->recv_initial_metadata.recv_initial_metadata_ready;
-    op->payload->recv_initial_metadata.recv_initial_metadata_ready =
-        &calld->recv_initial_metadata_ready;
-  }
-
-  if (op->recv_trailing_metadata) {
-    calld->original_recv_trailing_metadata_ready =
-        op->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
-    op->payload->recv_trailing_metadata.recv_trailing_metadata_ready =
-        &calld->recv_trailing_metadata_ready;
+  if (md->get_pointer(HttpAuthorityMetadata()) == nullptr) {
+    return Immediate(
+        ServerMetadataHandle(absl::UnknownError("Missing :authority header")));
   }
 
-  if (op->send_trailing_metadata) {
-    grpc_error_handle error = hs_filter_outgoing_metadata(
-        op->payload->send_trailing_metadata.send_trailing_metadata);
-    if (error != GRPC_ERROR_NONE) return error;
+  if (!surface_user_agent_) {
+    md->Remove(UserAgentMetadata());
   }
 
-  return GRPC_ERROR_NONE;
-}
+  auto* read_latch = GetContext<Arena>()->New<Latch<ServerMetadata*>>();
+  auto* write_latch =
+      absl::exchange(call_args.server_initial_metadata, read_latch);
 
-static void hs_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  GPR_TIMER_SCOPE("hs_start_transport_stream_op_batch", 0);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_error_handle error = hs_mutate_op(elem, op);
-  if (error != GRPC_ERROR_NONE) {
-    grpc_transport_stream_op_batch_finish_with_failure(op, error,
-                                                       calld->call_combiner);
-  } else {
-    grpc_call_next_op(elem, op);
-  }
+  return CallPushPull(Seq(next_promise_factory(std::move(call_args)),
+                          [](ServerMetadataHandle md) -> ServerMetadataHandle {
+                            FilterOutgoingMetadata(md.get());
+                            return md;
+                          }),
+                      Seq(read_latch->Wait(),
+                          [write_latch](ServerMetadata** md) {
+                            FilterOutgoingMetadata(*md);
+                            (*md)->Set(HttpStatusMetadata(), 200);
+                            (*md)->Set(ContentTypeMetadata(),
+                                       ContentTypeMetadata::kApplicationGrpc);
+                            write_latch->Set(*md);
+                            return absl::OkStatus();
+                          }),
+                      []() { return absl::OkStatus(); });
 }
 
-/* Constructor for call_data */
-static grpc_error_handle hs_init_call_elem(grpc_call_element* elem,
-                                           const grpc_call_element_args* args) {
-  new (elem->call_data) call_data(elem, *args);
-  return GRPC_ERROR_NONE;
+absl::StatusOr<HttpServerFilter> HttpServerFilter::Create(ChannelArgs args,
+                                                          ChannelFilter::Args) {
+  return HttpServerFilter(
+      args.GetBool(GRPC_ARG_SURFACE_USER_AGENT).value_or(true),
+      args.GetBool(
+              GRPC_ARG_DO_NOT_USE_UNLESS_YOU_HAVE_PERMISSION_FROM_GRPC_TEAM_ALLOW_BROKEN_PUT_REQUESTS)
+          .value_or(false));
 }
 
-/* Destructor for call_data */
-static void hs_destroy_call_elem(grpc_call_element* elem,
-                                 const grpc_call_final_info* /*final_info*/,
-                                 grpc_closure* /*ignored*/) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->~call_data();
-}
-
-/* Constructor for channel_data */
-static grpc_error_handle hs_init_channel_elem(grpc_channel_element* elem,
-                                              grpc_channel_element_args* args) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  GPR_ASSERT(!args->is_last);
-  chand->surface_user_agent = grpc_channel_arg_get_bool(
-      grpc_channel_args_find(args->channel_args,
-                             const_cast<char*>(GRPC_ARG_SURFACE_USER_AGENT)),
-      true);
-  return GRPC_ERROR_NONE;
-}
-
-/* Destructor for channel data */
-static void hs_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
-
-const grpc_channel_filter grpc_http_server_filter = {
-    hs_start_transport_stream_op_batch,
-    nullptr,
-    grpc_channel_next_op,
-    sizeof(call_data),
-    hs_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    hs_destroy_call_elem,
-    sizeof(channel_data),
-    hs_init_channel_elem,
-    hs_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "http-server"};
+}  // namespace grpc_core