grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -21,6 +21,7 @@
 
 #include <algorithm>
 #include <functional>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ -38,11 +39,11 @@
 
 #include "src/core/lib/channel/channel_args.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/seq.h"
+#include "src/core/lib/promise/try_concurrently.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/transport/status_conversion.h"
@@ -121,21 +122,20 @@ ArenaPromise<ServerMetadataHandle> HttpClientFilter::MakeCallPromise(
   auto* write_latch =
       std::exchange(call_args.server_initial_metadata, read_latch);
 
-  return CallPushPull(
-      Seq(next_promise_factory(std::move(call_args)),
-          [](ServerMetadataHandle md) -> ServerMetadataHandle {
-            auto r = CheckServerMetadata(md.get());
-            if (!r.ok()) return ServerMetadataHandle(r);
-            return md;
-          }),
-      []() { return absl::OkStatus(); },
-      Seq(read_latch->Wait(),
-          [write_latch](ServerMetadata** md) -> absl::Status {
-            auto r =
-                *md == nullptr ? absl::OkStatus() : CheckServerMetadata(*md);
-            write_latch->Set(*md);
-            return r;
-          }));
+  return TryConcurrently(
+             Seq(next_promise_factory(std::move(call_args)),
+                 [](ServerMetadataHandle md) -> ServerMetadataHandle {
+                   auto r = CheckServerMetadata(md.get());
+                   if (!r.ok()) return ServerMetadataFromStatus(r);
+                   return md;
+                 }))
+      .NecessaryPull(Seq(read_latch->Wait(),
+                         [write_latch](ServerMetadata** md) -> absl::Status {
+                           auto r = *md == nullptr ? absl::OkStatus()
+                                                   : CheckServerMetadata(*md);
+                           write_latch->Set(*md);
+                           return r;
+                         }));
 }
 
 HttpClientFilter::HttpClientFilter(HttpSchemeMetadata::ValueType scheme,

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

@@ -23,6 +23,7 @@
 #include <limits.h>
 
 #include <functional>
+#include <memory>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
@@ -33,7 +34,6 @@
 #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/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/metadata_batch.h"
 

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

@@ -27,6 +27,7 @@
 #include <utility>
 
 #include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
 #include "absl/types/optional.h"
 
 #include <grpc/compression.h>
@@ -103,7 +104,7 @@ class CallData {
                       ForwardSendMessageBatch, elem, grpc_schedule_on_exec_ctx);
   }
 
-  ~CallData() { GRPC_ERROR_UNREF(cancel_error_); }
+  ~CallData() {}
 
   void CompressStartTransportStreamOpBatch(
       grpc_call_element* elem, grpc_transport_stream_op_batch* batch);
@@ -122,7 +123,7 @@ class CallData {
 
   grpc_core::CallCombiner* call_combiner_;
   grpc_compression_algorithm compression_algorithm_ = GRPC_COMPRESS_NONE;
-  grpc_error_handle cancel_error_ = GRPC_ERROR_NONE;
+  grpc_error_handle cancel_error_;
   grpc_transport_stream_op_batch* send_message_batch_ = nullptr;
   bool seen_initial_metadata_ = false;
   grpc_closure forward_send_message_batch_in_call_combiner_;
@@ -211,8 +212,7 @@ void CallData::FailSendMessageBatchInCallCombiner(void* calld_arg,
   CallData* calld = static_cast<CallData*>(calld_arg);
   if (calld->send_message_batch_ != nullptr) {
     grpc_transport_stream_op_batch_finish_with_failure(
-        calld->send_message_batch_, GRPC_ERROR_REF(error),
-        calld->call_combiner_);
+        calld->send_message_batch_, error, calld->call_combiner_);
     calld->send_message_batch_ = nullptr;
   }
 }
@@ -228,20 +228,19 @@ void CallData::CompressStartTransportStreamOpBatch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   // Handle cancel_stream.
   if (batch->cancel_stream) {
-    GRPC_ERROR_UNREF(cancel_error_);
-    cancel_error_ = GRPC_ERROR_REF(batch->payload->cancel_stream.cancel_error);
+    cancel_error_ = batch->payload->cancel_stream.cancel_error;
     if (send_message_batch_ != nullptr) {
       if (!seen_initial_metadata_) {
         GRPC_CALL_COMBINER_START(
             call_combiner_,
             GRPC_CLOSURE_CREATE(FailSendMessageBatchInCallCombiner, this,
                                 grpc_schedule_on_exec_ctx),
-            GRPC_ERROR_REF(cancel_error_), "failing send_message op");
+            cancel_error_, "failing send_message op");
       }
     }
-  } else if (!GRPC_ERROR_IS_NONE(cancel_error_)) {
-    grpc_transport_stream_op_batch_finish_with_failure(
-        batch, GRPC_ERROR_REF(cancel_error_), call_combiner_);
+  } else if (!cancel_error_.ok()) {
+    grpc_transport_stream_op_batch_finish_with_failure(batch, cancel_error_,
+                                                       call_combiner_);
     return;
   }
   // Handle send_initial_metadata.
@@ -258,7 +257,8 @@ void CallData::CompressStartTransportStreamOpBatch(
     if (send_message_batch_ != nullptr) {
       GRPC_CALL_COMBINER_START(
           call_combiner_, &forward_send_message_batch_in_call_combiner_,
-          GRPC_ERROR_NONE, "starting send_message after send_initial_metadata");
+          absl::OkStatus(),
+          "starting send_message after send_initial_metadata");
     }
   }
   // Handle send_message.
@@ -290,7 +290,7 @@ void CompressStartTransportStreamOpBatch(
 grpc_error_handle CompressInitCallElem(grpc_call_element* elem,
                                        const grpc_call_element_args* args) {
   new (elem->call_data) CallData(elem, *args);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 /* Destructor for call_data */
@@ -305,7 +305,7 @@ void CompressDestroyCallElem(grpc_call_element* elem,
 grpc_error_handle CompressInitChannelElem(grpc_channel_element* elem,
                                           grpc_channel_element_args* args) {
   new (elem->channel_data) ChannelData(args);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 /* Destructor for channel data */

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

@@ -20,11 +20,12 @@
 
 #include "src/core/ext/filters/http/message_compress/message_decompress_filter.h"
 
-#include <stdint.h>
 #include <string.h>
 
+#include <cstdint>
 #include <new>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/types/optional.h"
@@ -37,6 +38,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/compression/message_compress.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
@@ -55,13 +57,13 @@ class ChannelData {
         message_size_service_config_parser_index_(
             MessageSizeParser::ParserIndex()) {}
 
-  int max_recv_size() const { return max_recv_size_; }
+  absl::optional<uint32_t> max_recv_size() const { return max_recv_size_; }
   size_t message_size_service_config_parser_index() const {
     return message_size_service_config_parser_index_;
   }
 
  private:
-  int max_recv_size_;
+  absl::optional<uint32_t> max_recv_size_;
   const size_t message_size_service_config_parser_index_;
 };
 
@@ -84,10 +86,10 @@ class CallData {
     const MessageSizeParsedConfig* limits =
         MessageSizeParsedConfig::GetFromCallContext(
             args.context, chand->message_size_service_config_parser_index());
-    if (limits != nullptr && limits->limits().max_recv_size >= 0 &&
-        (limits->limits().max_recv_size < max_recv_message_length_ ||
-         max_recv_message_length_ < 0)) {
-      max_recv_message_length_ = limits->limits().max_recv_size;
+    if (limits != nullptr && limits->max_recv_size().has_value() &&
+        (!max_recv_message_length_.has_value() ||
+         *limits->max_recv_size() < *max_recv_message_length_)) {
+      max_recv_message_length_ = *limits->max_recv_size();
     }
   }
 
@@ -108,14 +110,14 @@ class CallData {
 
   CallCombiner* call_combiner_;
   // Overall error for the call
-  grpc_error_handle error_ = GRPC_ERROR_NONE;
+  grpc_error_handle error_;
   // Fields for handling recv_initial_metadata_ready callback
   grpc_closure on_recv_initial_metadata_ready_;
   grpc_closure* original_recv_initial_metadata_ready_ = nullptr;
   grpc_metadata_batch* recv_initial_metadata_ = nullptr;
   // Fields for handling recv_message_ready callback
   bool seen_recv_message_ready_ = false;
-  int max_recv_message_length_;
+  absl::optional<uint32_t> max_recv_message_length_;
   grpc_compression_algorithm algorithm_ = GRPC_COMPRESS_NONE;
   absl::optional<SliceBuffer>* recv_message_ = nullptr;
   uint32_t* recv_message_flags_ = nullptr;
@@ -125,12 +127,12 @@ class CallData {
   bool seen_recv_trailing_metadata_ready_ = false;
   grpc_closure on_recv_trailing_metadata_ready_;
   grpc_closure* original_recv_trailing_metadata_ready_ = nullptr;
-  grpc_error_handle on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
+  grpc_error_handle on_recv_trailing_metadata_ready_error_;
 };
 
 void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
-  if (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok()) {
     calld->algorithm_ =
         calld->recv_initial_metadata_->get(GrpcEncodingMetadata())
             .value_or(GRPC_COMPRESS_NONE);
@@ -139,21 +141,21 @@ void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error_handle error) {
   calld->MaybeResumeOnRecvTrailingMetadataReady();
   grpc_closure* closure = calld->original_recv_initial_metadata_ready_;
   calld->original_recv_initial_metadata_ready_ = nullptr;
-  Closure::Run(DEBUG_LOCATION, closure, GRPC_ERROR_REF(error));
+  Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
 void CallData::MaybeResumeOnRecvMessageReady() {
   if (seen_recv_message_ready_) {
     seen_recv_message_ready_ = false;
     GRPC_CALL_COMBINER_START(call_combiner_, &on_recv_message_ready_,
-                             GRPC_ERROR_NONE,
+                             absl::OkStatus(),
                              "continue recv_message_ready callback");
   }
 }
 
 void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
-  if (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok()) {
     if (calld->original_recv_initial_metadata_ready_ != nullptr) {
       calld->seen_recv_message_ready_ = true;
       GRPC_CALL_COMBINER_STOP(calld->call_combiner_,
@@ -167,27 +169,26 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
       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);
+        return calld->ContinueRecvMessageReadyCallback(absl::OkStatus());
       }
-      if (calld->max_recv_message_length_ >= 0 &&
+      if (calld->max_recv_message_length_.has_value() &&
           (*calld->recv_message_)->Length() >
-              static_cast<uint32_t>(calld->max_recv_message_length_)) {
-        GPR_DEBUG_ASSERT(GRPC_ERROR_IS_NONE(calld->error_));
+              static_cast<uint32_t>(*calld->max_recv_message_length_)) {
+        GPR_DEBUG_ASSERT(calld->error_.ok());
         calld->error_ = grpc_error_set_int(
-            GRPC_ERROR_CREATE_FROM_CPP_STRING(
+            GRPC_ERROR_CREATE(
                 absl::StrFormat("Received message larger than max (%u vs. %d)",
                                 (*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_));
+                                *calld->max_recv_message_length_)),
+            StatusIntProperty::kRpcStatus, GRPC_STATUS_RESOURCE_EXHAUSTED);
+        return calld->ContinueRecvMessageReadyCallback(calld->error_);
       }
       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(
+        GPR_DEBUG_ASSERT(calld->error_.ok());
+        calld->error_ = GRPC_ERROR_CREATE(absl::StrCat(
             "Unexpected error decompressing data for algorithm with "
             "enum value ",
             calld->algorithm_));
@@ -197,11 +198,10 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
             GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED;
         (*calld->recv_message_)->Swap(&decompressed_slices);
       }
-      return calld->ContinueRecvMessageReadyCallback(
-          GRPC_ERROR_REF(calld->error_));
+      return calld->ContinueRecvMessageReadyCallback(calld->error_);
     }
   }
-  calld->ContinueRecvMessageReadyCallback(GRPC_ERROR_REF(error));
+  calld->ContinueRecvMessageReadyCallback(error);
 }
 
 void CallData::ContinueRecvMessageReadyCallback(grpc_error_handle error) {
@@ -216,7 +216,7 @@ void CallData::MaybeResumeOnRecvTrailingMetadataReady() {
   if (seen_recv_trailing_metadata_ready_) {
     seen_recv_trailing_metadata_ready_ = false;
     grpc_error_handle error = on_recv_trailing_metadata_ready_error_;
-    on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
+    on_recv_trailing_metadata_ready_error_ = absl::OkStatus();
     GRPC_CALL_COMBINER_START(call_combiner_, &on_recv_trailing_metadata_ready_,
                              error, "Continuing OnRecvTrailingMetadataReady");
   }
@@ -227,15 +227,15 @@ void CallData::OnRecvTrailingMetadataReady(void* arg, grpc_error_handle error) {
   if (calld->original_recv_initial_metadata_ready_ != nullptr ||
       calld->original_recv_message_ready_ != nullptr) {
     calld->seen_recv_trailing_metadata_ready_ = true;
-    calld->on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_REF(error);
+    calld->on_recv_trailing_metadata_ready_error_ = error;
     GRPC_CALL_COMBINER_STOP(
         calld->call_combiner_,
         "Deferring OnRecvTrailingMetadataReady until after "
         "OnRecvInitialMetadataReady and OnRecvMessageReady");
     return;
   }
-  error = grpc_error_add_child(GRPC_ERROR_REF(error), calld->error_);
-  calld->error_ = GRPC_ERROR_NONE;
+  error = grpc_error_add_child(error, calld->error_);
+  calld->error_ = absl::OkStatus();
   grpc_closure* closure = calld->original_recv_trailing_metadata_ready_;
   calld->original_recv_trailing_metadata_ready_ = nullptr;
   Closure::Run(DEBUG_LOCATION, closure, error);
@@ -281,7 +281,7 @@ grpc_error_handle DecompressInitCallElem(grpc_call_element* elem,
                                          const grpc_call_element_args* args) {
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   new (elem->call_data) CallData(*args, chand);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void DecompressDestroyCallElem(grpc_call_element* elem,
@@ -295,7 +295,7 @@ grpc_error_handle DecompressInitChannelElem(grpc_channel_element* elem,
                                             grpc_channel_element_args* args) {
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   new (chand) ChannelData(args);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void DecompressDestroyChannelElem(grpc_channel_element* elem) {

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

@@ -21,9 +21,11 @@
 #include "src/core/ext/filters/http/server/http_server_filter.h"
 
 #include <functional>
+#include <memory>
 #include <utility>
 
 #include "absl/base/attributes.h"
+#include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
@@ -31,12 +33,12 @@
 
 #include "src/core/lib/channel/channel_args.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/promise.h"
 #include "src/core/lib/promise/seq.h"
+#include "src/core/lib/promise/try_concurrently.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/slice/slice.h"
@@ -74,11 +76,11 @@ ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
       case HttpMethodMetadata::kInvalid:
       case HttpMethodMetadata::kGet:
         return Immediate(
-            ServerMetadataHandle(absl::UnknownError("Bad method header")));
+            ServerMetadataFromStatus(absl::UnknownError("Bad method header")));
     }
   } else {
     return Immediate(
-        ServerMetadataHandle(absl::UnknownError("Missing :method header")));
+        ServerMetadataFromStatus(absl::UnknownError("Missing :method header")));
   }
 
   auto te = md->Take(TeMetadata());
@@ -86,21 +88,21 @@ ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
     // Do nothing, ok.
   } else if (!te.has_value()) {
     return Immediate(
-        ServerMetadataHandle(absl::UnknownError("Missing :te header")));
+        ServerMetadataFromStatus(absl::UnknownError("Missing :te header")));
   } else {
     return Immediate(
-        ServerMetadataHandle(absl::UnknownError("Bad :te header")));
+        ServerMetadataFromStatus(absl::UnknownError("Bad :te header")));
   }
 
   auto scheme = md->Take(HttpSchemeMetadata());
   if (scheme.has_value()) {
     if (*scheme == HttpSchemeMetadata::kInvalid) {
       return Immediate(
-          ServerMetadataHandle(absl::UnknownError("Bad :scheme header")));
+          ServerMetadataFromStatus(absl::UnknownError("Bad :scheme header")));
     }
   } else {
     return Immediate(
-        ServerMetadataHandle(absl::UnknownError("Missing :scheme header")));
+        ServerMetadataFromStatus(absl::UnknownError("Missing :scheme header")));
   }
 
   md->Remove(ContentTypeMetadata());
@@ -108,7 +110,7 @@ ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
   Slice* path_slice = md->get_pointer(HttpPathMetadata());
   if (path_slice == nullptr) {
     return Immediate(
-        ServerMetadataHandle(absl::UnknownError("Missing :path header")));
+        ServerMetadataFromStatus(absl::UnknownError("Missing :path header")));
   }
 
   if (md->get_pointer(HttpAuthorityMetadata()) == nullptr) {
@@ -119,8 +121,8 @@ ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
   }
 
   if (md->get_pointer(HttpAuthorityMetadata()) == nullptr) {
-    return Immediate(
-        ServerMetadataHandle(absl::UnknownError("Missing :authority header")));
+    return Immediate(ServerMetadataFromStatus(
+        absl::UnknownError("Missing :authority header")));
   }
 
   if (!surface_user_agent_) {
@@ -131,21 +133,20 @@ ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
   auto* write_latch =
       std::exchange(call_args.server_initial_metadata, read_latch);
 
-  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(); });
+  return TryConcurrently(
+             Seq(next_promise_factory(std::move(call_args)),
+                 [](ServerMetadataHandle md) -> ServerMetadataHandle {
+                   FilterOutgoingMetadata(md.get());
+                   return md;
+                 }))
+      .Push(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();
+      }));
 }
 
 absl::StatusOr<HttpServerFilter> HttpServerFilter::Create(