grpc 1.46.2-x86_64-linux → 1.48.0.pre1-x86_64-linux

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -20,22 +20,23 @@
 
 #include "src/core/ext/filters/http/client_authority_filter.h"
 
-#include <assert.h>
 #include <limits.h>
-#include <string.h>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
+#include <functional>
 
-#include "src/core/ext/filters/http/client_authority_filter.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.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/surface/call.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
@@ -70,17 +71,12 @@ const grpc_channel_filter ClientAuthorityFilter::kFilter =
 
 namespace {
 bool add_client_authority_filter(ChannelStackBuilder* builder) {
-  const grpc_channel_args* channel_args = builder->channel_args();
-  const grpc_arg* disable_client_authority_filter_arg = grpc_channel_args_find(
-      channel_args, GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER);
-  if (disable_client_authority_filter_arg != nullptr) {
-    const bool is_client_authority_filter_disabled =
-        grpc_channel_arg_get_bool(disable_client_authority_filter_arg, false);
-    if (is_client_authority_filter_disabled) {
-      return true;
-    }
+  if (builder->channel_args()
+          .GetBool(GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER)
+          .value_or(false)) {
+    return true;
   }
-  builder->PrependFilter(&ClientAuthorityFilter::kFilter, nullptr);
+  builder->PrependFilter(&ClientAuthorityFilter::kFilter);
   return true;
 }
 }  // namespace

data/src/core/ext/filters/http/client_authority_filter.h

@@ -21,13 +21,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/status/statusor.h"
+#include <utility>
 
-#include <grpc/impl/codegen/compression_types.h>
+#include "absl/status/statusor.h"
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 

data/src/core/ext/filters/http/http_filters_plugin.cc

@@ -20,13 +20,21 @@
 
 #include <string.h>
 
+#include "absl/types/optional.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/ext/filters/http/message_compress/message_compress_filter.h"
 #include "src/core/ext/filters/http/message_compress/message_decompress_filter.h"
 #include "src/core/ext/filters/http/server/http_server_filter.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/surface/call.h"
+#include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/transport_fwd.h"
 #include "src/core/lib/transport/transport_impl.h"
 
 static bool is_building_http_like_transport(
@@ -46,12 +54,11 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
         [enable_in_minimal_stack, control_channel_arg,
          filter](ChannelStackBuilder* builder) {
           if (!is_building_http_like_transport(builder)) return true;
-          const grpc_channel_args* channel_args = builder->channel_args();
-          bool enable = grpc_channel_arg_get_bool(
-              grpc_channel_args_find(channel_args, control_channel_arg),
-              enable_in_minimal_stack ||
-                  !grpc_channel_args_want_minimal_stack(channel_args));
-          if (enable) builder->PrependFilter(filter, nullptr);
+          auto args = builder->channel_args();
+          const bool enable = args.GetBool(control_channel_arg)
+                                  .value_or(enable_in_minimal_stack ||
+                                            !args.WantMinimalStack());
+          if (enable) builder->PrependFilter(filter);
           return true;
         });
   };
@@ -61,7 +68,7 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
         channel_type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
         [filter](ChannelStackBuilder* builder) {
           if (is_building_http_like_transport(builder)) {
-            builder->PrependFilter(filter, nullptr);
+            builder->PrependFilter(filter);
           }
           return true;
         });
@@ -85,6 +92,6 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
            GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
   required(GRPC_CLIENT_SUBCHANNEL, &HttpClientFilter::kFilter);
   required(GRPC_CLIENT_DIRECT_CHANNEL, &HttpClientFilter::kFilter);
-  required(GRPC_SERVER_CHANNEL, &grpc_http_server_filter);
+  required(GRPC_SERVER_CHANNEL, &HttpServerFilter::kFilter);
 }
 }  // namespace grpc_core

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

@@ -20,25 +20,31 @@
 
 #include "src/core/ext/filters/http/message_compress/message_compress_filter.h"
 
-#include <assert.h>
-#include <string.h>
+#include <inttypes.h>
+#include <stdlib.h>
 
+#include <new>
+
+#include "absl/meta/type_traits.h"
 #include "absl/types/optional.h"
+#include "absl/utility/utility.h"
 
 #include <grpc/compression.h>
-#include <grpc/slice_buffer.h>
-#include <grpc/support/alloc.h>
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.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/gprpp/manual_constructor.h"
+#include "src/core/lib/debug/trace.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_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/call.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace {
 
@@ -94,66 +100,40 @@ class CallData {
             channeld->default_compression_algorithm()))) {
       compression_algorithm_ = channeld->default_compression_algorithm();
     }
-    GRPC_CLOSURE_INIT(&start_send_message_batch_in_call_combiner_,
-                      StartSendMessageBatch, elem, grpc_schedule_on_exec_ctx);
+    GRPC_CLOSURE_INIT(&forward_send_message_batch_in_call_combiner_,
+                      ForwardSendMessageBatch, elem, grpc_schedule_on_exec_ctx);
   }
 
-  ~CallData() {
-    if (state_initialized_) {
-      grpc_slice_buffer_destroy_internal(&slices_);
-    }
-    GRPC_ERROR_UNREF(cancel_error_);
-  }
+  ~CallData() { GRPC_ERROR_UNREF(cancel_error_); }
 
   void CompressStartTransportStreamOpBatch(
       grpc_call_element* elem, grpc_transport_stream_op_batch* batch);
 
  private:
   bool SkipMessageCompression();
-  void InitializeState(grpc_call_element* elem);
+  void FinishSendMessage(grpc_call_element* elem);
 
   void ProcessSendInitialMetadata(grpc_call_element* elem,
                                   grpc_metadata_batch* initial_metadata);
 
   // Methods for processing a send_message batch
-  static void StartSendMessageBatch(void* elem_arg, grpc_error_handle unused);
-  static void OnSendMessageNextDone(void* elem_arg, grpc_error_handle error);
-  grpc_error_handle PullSliceFromSendMessage();
-  void ContinueReadingSendMessage(grpc_call_element* elem);
-  void FinishSendMessage(grpc_call_element* elem);
-  void SendMessageBatchContinue(grpc_call_element* elem);
   static void FailSendMessageBatchInCallCombiner(void* calld_arg,
                                                  grpc_error_handle error);
-
-  static void SendMessageOnComplete(void* calld_arg, grpc_error_handle error);
+  static void ForwardSendMessageBatch(void* elem_arg, grpc_error_handle unused);
 
   grpc_core::CallCombiner* call_combiner_;
   grpc_compression_algorithm compression_algorithm_ = GRPC_COMPRESS_NONE;
   grpc_error_handle cancel_error_ = GRPC_ERROR_NONE;
   grpc_transport_stream_op_batch* send_message_batch_ = nullptr;
   bool seen_initial_metadata_ = false;
-  /* Set to true, if the fields below are initialized. */
-  bool state_initialized_ = false;
-  grpc_closure start_send_message_batch_in_call_combiner_;
-  /* The fields below are only initialized when we compress the payload.
-   * Keep them at the bottom of the struct, so they don't pollute the
-   * cache-lines. */
-  grpc_slice_buffer slices_; /**< Buffers up input slices to be compressed */
-  // Allocate space for the replacement stream
-  std::aligned_storage<sizeof(grpc_core::SliceBufferByteStream),
-                       alignof(grpc_core::SliceBufferByteStream)>::type
-      replacement_stream_;
-  grpc_closure* original_send_message_on_complete_ = nullptr;
-  grpc_closure send_message_on_complete_;
-  grpc_closure on_send_message_next_done_;
+  grpc_closure forward_send_message_batch_in_call_combiner_;
 };
 
 // Returns true if we should skip message compression for the current message.
 bool CallData::SkipMessageCompression() {
   // If the flags of this message indicate that it shouldn't be compressed, we
   // skip message compression.
-  uint32_t flags =
-      send_message_batch_->payload->send_message.send_message->flags();
+  uint32_t flags = send_message_batch_->payload->send_message.flags;
   if (flags & (GRPC_WRITE_NO_COMPRESS | GRPC_WRITE_INTERNAL_COMPRESS)) {
     return true;
   }
@@ -162,16 +142,6 @@ bool CallData::SkipMessageCompression() {
   return compression_algorithm_ == GRPC_COMPRESS_NONE;
 }
 
-void CallData::InitializeState(grpc_call_element* elem) {
-  GPR_DEBUG_ASSERT(!state_initialized_);
-  state_initialized_ = true;
-  grpc_slice_buffer_init(&slices_);
-  GRPC_CLOSURE_INIT(&send_message_on_complete_, SendMessageOnComplete, this,
-                    grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&on_send_message_next_done_, OnSendMessageNextDone, elem,
-                    grpc_schedule_on_exec_ctx);
-}
-
 void CallData::ProcessSendInitialMetadata(
     grpc_call_element* elem, grpc_metadata_batch* initial_metadata) {
   ChannelData* channeld = static_cast<ChannelData*>(elem->channel_data);
@@ -184,7 +154,6 @@ void CallData::ProcessSendInitialMetadata(
       break;
     case GRPC_COMPRESS_DEFLATE:
     case GRPC_COMPRESS_GZIP:
-      InitializeState(elem);
       initial_metadata->Set(grpc_core::GrpcEncodingMetadata(),
                             compression_algorithm_);
       break;
@@ -196,68 +165,46 @@ void CallData::ProcessSendInitialMetadata(
                         channeld->enabled_compression_algorithms());
 }
 
-void CallData::SendMessageOnComplete(void* calld_arg, grpc_error_handle error) {
-  CallData* calld = static_cast<CallData*>(calld_arg);
-  grpc_slice_buffer_reset_and_unref_internal(&calld->slices_);
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->original_send_message_on_complete_,
-                          GRPC_ERROR_REF(error));
-}
-
-void CallData::SendMessageBatchContinue(grpc_call_element* elem) {
-  // Note: The call to grpc_call_next_op() results in yielding the
-  // call combiner, so we need to clear send_message_batch_ before we do that.
-  grpc_transport_stream_op_batch* send_message_batch = send_message_batch_;
-  send_message_batch_ = nullptr;
-  grpc_call_next_op(elem, send_message_batch);
-}
-
 void CallData::FinishSendMessage(grpc_call_element* elem) {
-  GPR_DEBUG_ASSERT(compression_algorithm_ != GRPC_COMPRESS_NONE);
   // Compress the data if appropriate.
-  grpc_slice_buffer tmp;
-  grpc_slice_buffer_init(&tmp);
-  uint32_t send_flags =
-      send_message_batch_->payload->send_message.send_message->flags();
-  bool did_compress = grpc_msg_compress(compression_algorithm_, &slices_, &tmp);
-  if (did_compress) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
-      const char* algo_name;
-      const size_t before_size = slices_.length;
-      const size_t after_size = tmp.length;
-      const float savings_ratio = 1.0f - static_cast<float>(after_size) /
-                                             static_cast<float>(before_size);
-      GPR_ASSERT(
-          grpc_compression_algorithm_name(compression_algorithm_, &algo_name));
-      gpr_log(GPR_INFO,
-              "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
-              " bytes (%.2f%% savings)",
-              algo_name, before_size, after_size, 100 * savings_ratio);
-    }
-    grpc_slice_buffer_swap(&slices_, &tmp);
-    send_flags |= GRPC_WRITE_INTERNAL_COMPRESS;
-  } else {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
-      const char* algo_name;
-      GPR_ASSERT(
-          grpc_compression_algorithm_name(compression_algorithm_, &algo_name));
-      gpr_log(GPR_INFO,
-              "Algorithm '%s' enabled but decided not to compress. Input size: "
-              "%" PRIuPTR,
-              algo_name, slices_.length);
+  if (!SkipMessageCompression()) {
+    grpc_core::SliceBuffer tmp;
+    uint32_t& send_flags = send_message_batch_->payload->send_message.flags;
+    grpc_core::SliceBuffer* payload =
+        send_message_batch_->payload->send_message.send_message;
+    bool did_compress =
+        grpc_msg_compress(compression_algorithm_, payload->c_slice_buffer(),
+                          tmp.c_slice_buffer());
+    if (did_compress) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+        const char* algo_name;
+        const size_t before_size = payload->Length();
+        const size_t after_size = tmp.Length();
+        const float savings_ratio = 1.0f - static_cast<float>(after_size) /
+                                               static_cast<float>(before_size);
+        GPR_ASSERT(grpc_compression_algorithm_name(compression_algorithm_,
+                                                   &algo_name));
+        gpr_log(GPR_INFO,
+                "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
+                " bytes (%.2f%% savings)",
+                algo_name, before_size, after_size, 100 * savings_ratio);
+      }
+      tmp.Swap(payload);
+      send_flags |= GRPC_WRITE_INTERNAL_COMPRESS;
+    } else {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+        const char* algo_name;
+        GPR_ASSERT(grpc_compression_algorithm_name(compression_algorithm_,
+                                                   &algo_name));
+        gpr_log(
+            GPR_INFO,
+            "Algorithm '%s' enabled but decided not to compress. Input size: "
+            "%" PRIuPTR,
+            algo_name, payload->Length());
+      }
     }
   }
-  grpc_slice_buffer_destroy_internal(&tmp);
-  // Swap out the original byte stream with our new one and send the
-  // batch down.
-  new (&replacement_stream_)
-      grpc_core::SliceBufferByteStream(&slices_, send_flags);
-  send_message_batch_->payload->send_message.send_message.reset(
-      reinterpret_cast<grpc_core::SliceBufferByteStream*>(
-          &replacement_stream_));
-  original_send_message_on_complete_ = send_message_batch_->on_complete;
-  send_message_batch_->on_complete = &send_message_on_complete_;
-  SendMessageBatchContinue(elem);
+  grpc_call_next_op(elem, absl::exchange(send_message_batch_, nullptr));
 }
 
 void CallData::FailSendMessageBatchInCallCombiner(void* calld_arg,
@@ -271,78 +218,11 @@ void CallData::FailSendMessageBatchInCallCombiner(void* calld_arg,
   }
 }
 
-// Pulls a slice from the send_message byte stream and adds it to slices_.
-grpc_error_handle CallData::PullSliceFromSendMessage() {
-  grpc_slice incoming_slice;
-  grpc_error_handle error =
-      send_message_batch_->payload->send_message.send_message->Pull(
-          &incoming_slice);
-  if (error == GRPC_ERROR_NONE) {
-    grpc_slice_buffer_add(&slices_, incoming_slice);
-  }
-  return error;
-}
-
-// Reads as many slices as possible from the send_message byte stream.
-// If all data has been read, invokes FinishSendMessage().  Otherwise,
-// an async call to ByteStream::Next() has been started, which will
-// eventually result in calling OnSendMessageNextDone().
-void CallData::ContinueReadingSendMessage(grpc_call_element* elem) {
-  if (slices_.length ==
-      send_message_batch_->payload->send_message.send_message->length()) {
-    FinishSendMessage(elem);
-    return;
-  }
-  while (send_message_batch_->payload->send_message.send_message->Next(
-      ~static_cast<size_t>(0), &on_send_message_next_done_)) {
-    grpc_error_handle error = PullSliceFromSendMessage();
-    if (error != GRPC_ERROR_NONE) {
-      // Closure callback; does not take ownership of error.
-      FailSendMessageBatchInCallCombiner(this, error);
-      GRPC_ERROR_UNREF(error);
-      return;
-    }
-    if (slices_.length ==
-        send_message_batch_->payload->send_message.send_message->length()) {
-      FinishSendMessage(elem);
-      break;
-    }
-  }
-}
-
-// Async callback for ByteStream::Next().
-void CallData::OnSendMessageNextDone(void* elem_arg, grpc_error_handle error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(elem_arg);
-  CallData* calld = static_cast<CallData*>(elem->call_data);
-  if (error != GRPC_ERROR_NONE) {
-    // Closure callback; does not take ownership of error.
-    FailSendMessageBatchInCallCombiner(calld, error);
-    return;
-  }
-  error = calld->PullSliceFromSendMessage();
-  if (error != GRPC_ERROR_NONE) {
-    // Closure callback; does not take ownership of error.
-    FailSendMessageBatchInCallCombiner(calld, error);
-    GRPC_ERROR_UNREF(error);
-    return;
-  }
-  if (calld->slices_.length == calld->send_message_batch_->payload->send_message
-                                   .send_message->length()) {
-    calld->FinishSendMessage(elem);
-  } else {
-    calld->ContinueReadingSendMessage(elem);
-  }
-}
-
-void CallData::StartSendMessageBatch(void* elem_arg,
-                                     grpc_error_handle /*unused*/) {
+void CallData::ForwardSendMessageBatch(void* elem_arg,
+                                       grpc_error_handle /*unused*/) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(elem_arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
-  if (calld->SkipMessageCompression()) {
-    calld->SendMessageBatchContinue(elem);
-  } else {
-    calld->ContinueReadingSendMessage(elem);
-  }
+  calld->FinishSendMessage(elem);
 }
 
 void CallData::CompressStartTransportStreamOpBatch(
@@ -359,12 +239,9 @@ void CallData::CompressStartTransportStreamOpBatch(
             GRPC_CLOSURE_CREATE(FailSendMessageBatchInCallCombiner, this,
                                 grpc_schedule_on_exec_ctx),
             GRPC_ERROR_REF(cancel_error_), "failing send_message op");
-      } else {
-        send_message_batch_->payload->send_message.send_message->Shutdown(
-            GRPC_ERROR_REF(cancel_error_));
       }
     }
-  } else if (cancel_error_ != GRPC_ERROR_NONE) {
+  } else if (!GRPC_ERROR_IS_NONE(cancel_error_)) {
     grpc_transport_stream_op_batch_finish_with_failure(
         batch, GRPC_ERROR_REF(cancel_error_), call_combiner_);
     return;
@@ -382,7 +259,7 @@ void CallData::CompressStartTransportStreamOpBatch(
     // the call stack) will release the call combiner for each batch it sees.
     if (send_message_batch_ != nullptr) {
       GRPC_CALL_COMBINER_START(
-          call_combiner_, &start_send_message_batch_in_call_combiner_,
+          call_combiner_, &forward_send_message_batch_in_call_combiner_,
           GRPC_ERROR_NONE, "starting send_message after send_initial_metadata");
     }
   }
@@ -398,7 +275,7 @@ void CallData::CompressStartTransportStreamOpBatch(
           call_combiner_, "send_message batch pending send_initial_metadata");
       return;
     }
-    StartSendMessageBatch(elem, GRPC_ERROR_NONE);
+    FinishSendMessage(elem);
   } else {
     // Pass control down the stack.
     grpc_call_next_op(elem, batch);
@@ -451,6 +328,7 @@ const grpc_channel_filter grpc_message_compress_filter = {
     CompressDestroyCallElem,
     sizeof(ChannelData),
     CompressInitChannelElem,
+    grpc_channel_stack_no_post_init,
     CompressDestroyChannelElem,
     grpc_channel_next_get_info,
     "message_compress"};

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

@@ -21,8 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/compression_types.h>
-
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 
 /** Compression filter for outgoing data.