grpc 1.50.0 → 1.51.0

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -18,18 +18,10 @@
 
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 
-#include <algorithm>
-#include <map>
 #include <new>
-#include <string>
-#include <utility>
-#include <vector>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-#include "absl/types/optional.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/status.h>
@@ -39,8 +31,8 @@
 #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/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"
@@ -71,64 +63,59 @@ const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
       svc_cfg_call_data->GetMethodParsedConfig(service_config_parser_index));
 }
 
+MessageSizeParsedConfig MessageSizeParsedConfig::GetFromChannelArgs(
+    const ChannelArgs& channel_args) {
+  MessageSizeParsedConfig limits;
+  limits.max_send_size_ = GetMaxSendSizeFromChannelArgs(channel_args);
+  limits.max_recv_size_ = GetMaxRecvSizeFromChannelArgs(channel_args);
+  return limits;
+}
+
+absl::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(
+    const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return absl::nullopt;
+  int size = args.GetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH)
+                 .value_or(GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH);
+  if (size < 0) return absl::nullopt;
+  return static_cast<uint32_t>(size);
+}
+
+absl::optional<uint32_t> GetMaxSendSizeFromChannelArgs(
+    const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return absl::nullopt;
+  int size = args.GetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
+                 .value_or(GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH);
+  if (size < 0) return absl::nullopt;
+  return static_cast<uint32_t>(size);
+}
+
+const JsonLoaderInterface* MessageSizeParsedConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<MessageSizeParsedConfig>()
+          .OptionalField("maxRequestMessageBytes",
+                         &MessageSizeParsedConfig::max_send_size_)
+          .OptionalField("maxResponseMessageBytes",
+                         &MessageSizeParsedConfig::max_recv_size_)
+          .Finish();
+  return loader;
+}
+
 //
 // MessageSizeParser
 //
 
-absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
 MessageSizeParser::ParsePerMethodParams(const ChannelArgs& /*args*/,
-                                        const Json& json) {
-  std::vector<grpc_error_handle> error_list;
-  // Max request size.
-  int max_request_message_bytes = -1;
-  auto it = json.object_value().find("maxRequestMessageBytes");
-  if (it != json.object_value().end()) {
-    if (it->second.type() != Json::Type::STRING &&
-        it->second.type() != Json::Type::NUMBER) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:maxRequestMessageBytes error:should be of type number"));
-    } else {
-      max_request_message_bytes =
-          gpr_parse_nonnegative_int(it->second.string_value().c_str());
-      if (max_request_message_bytes == -1) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxRequestMessageBytes error:should be non-negative"));
-      }
-    }
-  }
-  // Max response size.
-  int max_response_message_bytes = -1;
-  it = json.object_value().find("maxResponseMessageBytes");
-  if (it != json.object_value().end()) {
-    if (it->second.type() != Json::Type::STRING &&
-        it->second.type() != Json::Type::NUMBER) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:maxResponseMessageBytes error:should be of type number"));
-    } else {
-      max_response_message_bytes =
-          gpr_parse_nonnegative_int(it->second.string_value().c_str());
-      if (max_response_message_bytes == -1) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxResponseMessageBytes error:should be non-negative"));
-      }
-    }
-  }
-  if (!error_list.empty()) {
-    grpc_error_handle error =
-        GRPC_ERROR_CREATE_FROM_VECTOR("Message size parser", &error_list);
-    absl::Status status = absl::InvalidArgumentError(
-        absl::StrCat("error parsing message size method parameters: ",
-                     grpc_error_std_string(error)));
-    GRPC_ERROR_UNREF(error);
-    return status;
-  }
-  return absl::make_unique<MessageSizeParsedConfig>(max_request_message_bytes,
-                                                    max_response_message_bytes);
+                                        const Json& json,
+                                        ValidationErrors* errors) {
+  return LoadFromJson<std::unique_ptr<MessageSizeParsedConfig>>(
+      json, JsonArgs(), errors);
 }
 
 void MessageSizeParser::Register(CoreConfiguration::Builder* builder) {
   builder->service_config_parser()->RegisterParser(
-      absl::make_unique<MessageSizeParser>());
+      std::make_unique<MessageSizeParser>());
 }
 
 size_t MessageSizeParser::ParserIndex() {
@@ -136,23 +123,11 @@ size_t MessageSizeParser::ParserIndex() {
       parser_name());
 }
 
-int GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args) {
-  if (args.WantMinimalStack()) return -1;
-  return std::max(-1, args.GetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH)
-                          .value_or(GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH));
-}
-
-int GetMaxSendSizeFromChannelArgs(const ChannelArgs& args) {
-  if (args.WantMinimalStack()) return -1;
-  return std::max(-1, args.GetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
-                          .value_or(GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH));
-}
-
 }  // namespace grpc_core
 
 namespace {
 struct channel_data {
-  grpc_core::MessageSizeParsedConfig::message_size_limits limits;
+  grpc_core::MessageSizeParsedConfig limits;
   const size_t service_config_parser_index{
       grpc_core::MessageSizeParser::ParserIndex()};
 };
@@ -170,34 +145,37 @@ struct call_data {
     // Note: Per-method config is only available on the client, so we
     // apply the max request size to the send limit and the max response
     // size to the receive limit.
-    const grpc_core::MessageSizeParsedConfig* limits =
+    const grpc_core::MessageSizeParsedConfig* config_from_call_context =
         grpc_core::MessageSizeParsedConfig::GetFromCallContext(
             args.context, chand.service_config_parser_index);
-    if (limits != nullptr) {
-      if (limits->limits().max_send_size >= 0 &&
-          (limits->limits().max_send_size < this->limits.max_send_size ||
-           this->limits.max_send_size < 0)) {
-        this->limits.max_send_size = limits->limits().max_send_size;
+    if (config_from_call_context != nullptr) {
+      absl::optional<uint32_t> max_send_size = limits.max_send_size();
+      absl::optional<uint32_t> max_recv_size = limits.max_recv_size();
+      if (config_from_call_context->max_send_size().has_value() &&
+          (!max_send_size.has_value() ||
+           *config_from_call_context->max_send_size() < *max_send_size)) {
+        max_send_size = *config_from_call_context->max_send_size();
       }
-      if (limits->limits().max_recv_size >= 0 &&
-          (limits->limits().max_recv_size < this->limits.max_recv_size ||
-           this->limits.max_recv_size < 0)) {
-        this->limits.max_recv_size = limits->limits().max_recv_size;
+      if (config_from_call_context->max_recv_size().has_value() &&
+          (!max_recv_size.has_value() ||
+           *config_from_call_context->max_recv_size() < *max_recv_size)) {
+        max_recv_size = *config_from_call_context->max_recv_size();
       }
+      limits = grpc_core::MessageSizeParsedConfig(max_send_size, max_recv_size);
     }
   }
 
-  ~call_data() { GRPC_ERROR_UNREF(error); }
+  ~call_data() {}
 
   grpc_core::CallCombiner* call_combiner;
-  grpc_core::MessageSizeParsedConfig::message_size_limits limits;
+  grpc_core::MessageSizeParsedConfig limits;
   // Receive closures are chained: we inject this closure as the
   // recv_message_ready up-call on transport_stream_op, and remember to
   // call our next_recv_message_ready member after handling it.
   grpc_closure recv_message_ready;
   grpc_closure recv_trailing_metadata_ready;
-  // The error caused by a message that is too large, or GRPC_ERROR_NONE
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  // The error caused by a message that is too large, or absl::OkStatus()
+  grpc_error_handle error;
   // Used by recv_message_ready.
   absl::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
   // Original recv_message_ready callback, invoked after our own.
@@ -215,19 +193,18 @@ struct call_data {
 static void recv_message_ready(void* user_data, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
-  if (calld->recv_message->has_value() && calld->limits.max_recv_size >= 0 &&
+  if (calld->recv_message->has_value() &&
+      calld->limits.max_recv_size().has_value() &&
       (*calld->recv_message)->Length() >
-          static_cast<size_t>(calld->limits.max_recv_size)) {
+          static_cast<size_t>(*calld->limits.max_recv_size())) {
     grpc_error_handle new_error = grpc_error_set_int(
-        GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+        GRPC_ERROR_CREATE(absl::StrFormat(
             "Received message larger than max (%u vs. %d)",
-            (*calld->recv_message)->Length(), calld->limits.max_recv_size)),
-        GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
-    error = grpc_error_add_child(GRPC_ERROR_REF(error), new_error);
-    GRPC_ERROR_UNREF(calld->error);
-    calld->error = GRPC_ERROR_REF(error);
-  } else {
-    (void)GRPC_ERROR_REF(error);
+            (*calld->recv_message)->Length(), *calld->limits.max_recv_size())),
+        grpc_core::StatusIntProperty::kRpcStatus,
+        GRPC_STATUS_RESOURCE_EXHAUSTED);
+    error = grpc_error_add_child(error, new_error);
+    calld->error = error;
   }
   // Invoke the next callback.
   grpc_closure* closure = calld->next_recv_message_ready;
@@ -255,14 +232,13 @@ static void recv_trailing_metadata_ready(void* user_data,
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (calld->next_recv_message_ready != nullptr) {
     calld->seen_recv_trailing_metadata = true;
-    calld->recv_trailing_metadata_error = GRPC_ERROR_REF(error);
+    calld->recv_trailing_metadata_error = error;
     GRPC_CALL_COMBINER_STOP(calld->call_combiner,
                             "deferring recv_trailing_metadata_ready until "
                             "after recv_message_ready");
     return;
   }
-  error =
-      grpc_error_add_child(GRPC_ERROR_REF(error), GRPC_ERROR_REF(calld->error));
+  error = grpc_error_add_child(error, calld->error);
   // Invoke the next callback.
   grpc_core::Closure::Run(DEBUG_LOCATION,
                           calld->original_recv_trailing_metadata_ready, error);
@@ -273,16 +249,16 @@ static void message_size_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   // Check max send message size.
-  if (op->send_message && calld->limits.max_send_size >= 0 &&
+  if (op->send_message && calld->limits.max_send_size().has_value() &&
       op->payload->send_message.send_message->Length() >
-          static_cast<size_t>(calld->limits.max_send_size)) {
+          static_cast<size_t>(*calld->limits.max_send_size())) {
     grpc_transport_stream_op_batch_finish_with_failure(
         op,
-        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+        grpc_error_set_int(GRPC_ERROR_CREATE(absl::StrFormat(
                                "Sent message larger than max (%u vs. %d)",
                                op->payload->send_message.send_message->Length(),
-                               calld->limits.max_send_size)),
-                           GRPC_ERROR_INT_GRPC_STATUS,
+                               *calld->limits.max_send_size())),
+                           grpc_core::StatusIntProperty::kRpcStatus,
                            GRPC_STATUS_RESOURCE_EXHAUSTED),
         calld->call_combiner);
     return;
@@ -310,7 +286,7 @@ static grpc_error_handle message_size_init_call_elem(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   new (elem->call_data) call_data(elem, *chand, *args);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 // Destructor for call_data.
@@ -321,23 +297,15 @@ static void message_size_destroy_call_elem(
   calld->~call_data();
 }
 
-grpc_core::MessageSizeParsedConfig::message_size_limits get_message_size_limits(
-    const grpc_core::ChannelArgs& channel_args) {
-  grpc_core::MessageSizeParsedConfig::message_size_limits lim;
-  lim.max_send_size = grpc_core::GetMaxSendSizeFromChannelArgs(channel_args);
-  lim.max_recv_size = grpc_core::GetMaxRecvSizeFromChannelArgs(channel_args);
-  return lim;
-}
-
 // Constructor for channel_data.
 static grpc_error_handle message_size_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   GPR_ASSERT(!args->is_last);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   new (chand) channel_data();
-  chand->limits = get_message_size_limits(
+  chand->limits = grpc_core::MessageSizeParsedConfig::GetFromChannelArgs(
       grpc_core::ChannelArgs::FromC(args->channel_args));
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 // Destructor for channel_data.
@@ -379,10 +347,11 @@ static bool maybe_add_message_size_filter(
   if (channel_args.WantMinimalStack()) {
     return true;
   }
-  grpc_core::MessageSizeParsedConfig::message_size_limits lim =
-      get_message_size_limits(channel_args);
+  grpc_core::MessageSizeParsedConfig limits =
+      grpc_core::MessageSizeParsedConfig::GetFromChannelArgs(channel_args);
   const bool enable =
-      lim.max_send_size != -1 || lim.max_recv_size != -1 ||
+      limits.max_send_size().has_value() ||
+      limits.max_recv_size().has_value() ||
       channel_args.GetString(GRPC_ARG_SERVICE_CONFIG).has_value();
   if (enable) builder->PrependFilter(&grpc_message_size_filter);
   return true;

data/src/core/ext/filters/message_size/message_size_filter.h

@@ -20,18 +20,22 @@
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include <memory>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.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"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
 extern const grpc_channel_filter grpc_message_size_filter;
@@ -40,32 +44,35 @@ namespace grpc_core {
 
 class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
  public:
-  struct message_size_limits {
-    int max_send_size;
-    int max_recv_size;
-  };
+  absl::optional<uint32_t> max_send_size() const { return max_send_size_; }
+  absl::optional<uint32_t> max_recv_size() const { return max_recv_size_; }
 
-  MessageSizeParsedConfig(int max_send_size, int max_recv_size) {
-    limits_.max_send_size = max_send_size;
-    limits_.max_recv_size = max_recv_size;
-  }
+  MessageSizeParsedConfig() = default;
 
-  const message_size_limits& limits() const { return limits_; }
+  MessageSizeParsedConfig(absl::optional<uint32_t> max_send_size,
+                          absl::optional<uint32_t> max_recv_size)
+      : max_send_size_(max_send_size), max_recv_size_(max_recv_size) {}
 
   static const MessageSizeParsedConfig* GetFromCallContext(
       const grpc_call_context_element* context,
       size_t service_config_parser_index);
 
+  static MessageSizeParsedConfig GetFromChannelArgs(const ChannelArgs& args);
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+
  private:
-  message_size_limits limits_;
+  absl::optional<uint32_t> max_send_size_;
+  absl::optional<uint32_t> max_recv_size_;
 };
 
 class MessageSizeParser : public ServiceConfigParser::Parser {
  public:
   absl::string_view name() const override { return parser_name(); }
 
-  absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-  ParsePerMethodParams(const ChannelArgs& /*args*/, const Json& json) override;
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
+      const ChannelArgs& /*args*/, const Json& json,
+      ValidationErrors* errors) override;
 
   static void Register(CoreConfiguration::Builder* builder);
 
@@ -75,8 +82,8 @@ class MessageSizeParser : public ServiceConfigParser::Parser {
   static absl::string_view parser_name() { return "message_size"; }
 };
 
-int GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
-int GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
+absl::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
+absl::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
 
 }  // namespace grpc_core
 

data/src/core/ext/filters/rbac/rbac_filter.cc

@@ -21,6 +21,8 @@
 #include <new>
 #include <utility>
 
+#include "absl/status/status.h"
+
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
@@ -28,6 +30,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
 #include "src/core/lib/security/authorization/grpc_authorization_engine.h"
 #include "src/core/lib/security/context/security_context.h"
@@ -45,7 +48,7 @@ namespace grpc_core {
 grpc_error_handle RbacFilter::CallData::Init(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   new (elem->call_data) CallData(elem, *args);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void RbacFilter::CallData::Destroy(grpc_call_element* elem,
@@ -82,7 +85,7 @@ void RbacFilter::CallData::RecvInitialMetadataReady(void* user_data,
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   RbacFilter* filter = static_cast<RbacFilter*>(elem->channel_data);
-  if (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok()) {
     // Fetch and apply the rbac policy from the service config.
     auto* service_config_call_data = static_cast<ServiceConfigCallData*>(
         calld->call_context_[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
@@ -90,7 +93,7 @@ void RbacFilter::CallData::RecvInitialMetadataReady(void* user_data,
         service_config_call_data->GetMethodParsedConfig(
             filter->service_config_parser_index_));
     if (method_params == nullptr) {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("No RBAC policy found.");
+      error = GRPC_ERROR_CREATE("No RBAC policy found.");
     } else {
       RbacFilter* chand = static_cast<RbacFilter*>(elem->channel_data);
       auto* authorization_engine =
@@ -99,16 +102,13 @@ void RbacFilter::CallData::RecvInitialMetadataReady(void* user_data,
               ->Evaluate(EvaluateArgs(calld->recv_initial_metadata_,
                                       &chand->per_channel_evaluate_args_))
               .type == AuthorizationEngine::Decision::Type::kDeny) {
-        error =
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unauthorized RPC rejected");
+        error = GRPC_ERROR_CREATE("Unauthorized RPC rejected");
       }
     }
-    if (!GRPC_ERROR_IS_NONE(error)) {
-      error = grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS,
+    if (!error.ok()) {
+      error = grpc_error_set_int(error, StatusIntProperty::kRpcStatus,
                                  GRPC_STATUS_PERMISSION_DENIED);
     }
-  } else {
-    (void)GRPC_ERROR_REF(error);
   }
   grpc_closure* closure = calld->original_recv_initial_metadata_ready_;
   calld->original_recv_initial_metadata_ready_ = nullptr;
@@ -146,20 +146,20 @@ grpc_error_handle RbacFilter::Init(grpc_channel_element* elem,
   GPR_ASSERT(elem->filter == &kFilterVtable);
   auto* auth_context = grpc_find_auth_context_in_args(args->channel_args);
   if (auth_context == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No auth context found");
+    return GRPC_ERROR_CREATE("No auth context found");
   }
   auto* transport = grpc_channel_args_find_pointer<grpc_transport>(
       args->channel_args, GRPC_ARG_TRANSPORT);
   if (transport == nullptr) {
     // This should never happen since the transport is always set on the server
     // side.
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No transport configured");
+    return GRPC_ERROR_CREATE("No transport configured");
   }
   new (elem->channel_data) RbacFilter(
       grpc_channel_stack_filter_instance_number(args->channel_stack, elem),
       EvaluateArgs::PerChannelArgs(auth_context,
                                    grpc_transport_get_endpoint(transport)));
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void RbacFilter::Destroy(grpc_channel_element* elem) {