grpc 1.53.0 → 1.56.0

data/src/core/lib/json/json_object_loader.cc

@@ -22,20 +22,22 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 
+#include <grpc/support/json.h>
+
 namespace grpc_core {
 namespace json_detail {
 
 void LoadScalar::LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
                           ValidationErrors* errors) const {
-  // We accept either STRING or NUMBER for numeric values, as per
+  // We accept either kString or kNumber for numeric values, as per
   // https://developers.google.com/protocol-buffers/docs/proto3#json.
-  if (json.type() != Json::Type::STRING &&
-      (!IsNumber() || json.type() != Json::Type::NUMBER)) {
+  if (json.type() != Json::Type::kString &&
+      (!IsNumber() || json.type() != Json::Type::kNumber)) {
     errors->AddError(
         absl::StrCat("is not a ", IsNumber() ? "number" : "string"));
     return;
   }
-  return LoadInto(json.string_value(), dst, errors);
+  return LoadInto(json.string(), dst, errors);
 }
 
 bool LoadString::IsNumber() const { return false; }
@@ -91,42 +93,40 @@ bool LoadNumber::IsNumber() const { return true; }
 
 void LoadBool::LoadInto(const Json& json, const JsonArgs&, void* dst,
                         ValidationErrors* errors) const {
-  if (json.type() == Json::Type::JSON_TRUE) {
-    *static_cast<bool*>(dst) = true;
-  } else if (json.type() == Json::Type::JSON_FALSE) {
-    *static_cast<bool*>(dst) = false;
-  } else {
+  if (json.type() != Json::Type::kBoolean) {
     errors->AddError("is not a boolean");
+    return;
   }
+  *static_cast<bool*>(dst) = json.boolean();
 }
 
 void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
                                          void* dst,
                                          ValidationErrors* errors) const {
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::kObject) {
     errors->AddError("is not an object");
     return;
   }
-  *static_cast<Json::Object*>(dst) = json.object_value();
+  *static_cast<Json::Object*>(dst) = json.object();
 }
 
 void LoadUnprocessedJsonArray::LoadInto(const Json& json, const JsonArgs&,
                                         void* dst,
                                         ValidationErrors* errors) const {
-  if (json.type() != Json::Type::ARRAY) {
+  if (json.type() != Json::Type::kArray) {
     errors->AddError("is not an array");
     return;
   }
-  *static_cast<Json::Array*>(dst) = json.array_value();
+  *static_cast<Json::Array*>(dst) = json.array();
 }
 
 void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
                           ValidationErrors* errors) const {
-  if (json.type() != Json::Type::ARRAY) {
+  if (json.type() != Json::Type::kArray) {
     errors->AddError("is not an array");
     return;
   }
-  const auto& array = json.array_value();
+  const auto& array = json.array();
   const LoaderInterface* element_loader = ElementLoader();
   for (size_t i = 0; i < array.size(); ++i) {
     ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
@@ -138,11 +138,11 @@ void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
 void AutoLoader<std::vector<bool>>::LoadInto(const Json& json,
                                              const JsonArgs& args, void* dst,
                                              ValidationErrors* errors) const {
-  if (json.type() != Json::Type::ARRAY) {
+  if (json.type() != Json::Type::kArray) {
     errors->AddError("is not an array");
     return;
   }
-  const auto& array = json.array_value();
+  const auto& array = json.array();
   const LoaderInterface* element_loader = LoaderForType<bool>();
   std::vector<bool>* vec = static_cast<std::vector<bool>*>(dst);
   for (size_t i = 0; i < array.size(); ++i) {
@@ -155,12 +155,12 @@ void AutoLoader<std::vector<bool>>::LoadInto(const Json& json,
 
 void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
                        ValidationErrors* errors) const {
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::kObject) {
     errors->AddError("is not an object");
     return;
   }
   const LoaderInterface* element_loader = ElementLoader();
-  for (const auto& pair : json.object_value()) {
+  for (const auto& pair : json.object()) {
     ValidationErrors::ScopedField field(errors,
                                         absl::StrCat("[\"", pair.first, "\"]"));
     void* element = Insert(pair.first, dst);
@@ -168,9 +168,8 @@ void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
   }
 }
 
-void LoadOptional::LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                            ValidationErrors* errors) const {
-  if (json.type() == Json::Type::JSON_NULL) return;
+void LoadWrapped::LoadInto(const Json& json, const JsonArgs& args, void* dst,
+                           ValidationErrors* errors) const {
   void* element = Emplace(dst);
   size_t starting_error_size = errors->size();
   ElementLoader()->LoadInto(json, args, element, errors);
@@ -179,7 +178,7 @@ void LoadOptional::LoadInto(const Json& json, const JsonArgs& args, void* dst,
 
 bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
                 size_t num_elements, void* dst, ValidationErrors* errors) {
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::kObject) {
     errors->AddError("is not an object");
     return false;
   }
@@ -190,8 +189,8 @@ bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
     }
     ValidationErrors::ScopedField field(errors,
                                         absl::StrCat(".", element.name));
-    const auto& it = json.object_value().find(element.name);
-    if (it == json.object_value().end()) {
+    const auto& it = json.object().find(element.name);
+    if (it == json.object().end() || it->second.type() == Json::Type::kNull) {
       if (element.optional) continue;
       errors->AddError("field not present");
       continue;

data/src/core/lib/json/json_object_loader.h

@@ -26,6 +26,7 @@
 #include <vector>
 
 #include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -252,14 +253,14 @@ class LoadMap : public LoaderInterface {
   virtual const LoaderInterface* ElementLoader() const = 0;
 };
 
-// Load an optional of some type.
-class LoadOptional : public LoaderInterface {
+// Load a wrapped value of some type.
+class LoadWrapped : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
                 ValidationErrors* errors) const override;
 
  protected:
-  ~LoadOptional() = default;
+  ~LoadWrapped() = default;
 
  private:
   virtual void* Emplace(void* dst) const = 0;
@@ -391,7 +392,7 @@ class AutoLoader<std::map<std::string, T>> final : public LoadMap {
 
 // Specializations of AutoLoader for absl::optional<>.
 template <typename T>
-class AutoLoader<absl::optional<T>> final : public LoadOptional {
+class AutoLoader<absl::optional<T>> final : public LoadWrapped {
  public:
   void* Emplace(void* dst) const final {
     return &static_cast<absl::optional<T>*>(dst)->emplace();
@@ -409,7 +410,7 @@ class AutoLoader<absl::optional<T>> final : public LoadOptional {
 
 // Specializations of AutoLoader for std::unique_ptr<>.
 template <typename T>
-class AutoLoader<std::unique_ptr<T>> final : public LoadOptional {
+class AutoLoader<std::unique_ptr<T>> final : public LoadWrapped {
  public:
   void* Emplace(void* dst) const final {
     auto& p = *static_cast<std::unique_ptr<T>*>(dst);
@@ -427,6 +428,26 @@ class AutoLoader<std::unique_ptr<T>> final : public LoadOptional {
   ~AutoLoader() = default;
 };
 
+// Specializations of AutoLoader for RefCountedPtr<>.
+template <typename T>
+class AutoLoader<RefCountedPtr<T>> final : public LoadWrapped {
+ public:
+  void* Emplace(void* dst) const final {
+    auto& p = *static_cast<RefCountedPtr<T>*>(dst);
+    p = MakeRefCounted<T>();
+    return p.get();
+  }
+  void Reset(void* dst) const final {
+    static_cast<RefCountedPtr<T>*>(dst)->reset();
+  }
+  const LoaderInterface* ElementLoader() const final {
+    return LoaderForType<T>();
+  }
+
+ private:
+  ~AutoLoader() = default;
+};
+
 // Implementation of aforementioned LoaderForType.
 // Simply keeps a static AutoLoader<T> and returns a pointer to that.
 template <typename T>
@@ -485,7 +506,7 @@ class Vec<T, 0> {
 
 // Given a list of elements, and a destination object, load the elements into
 // the object from some parsed JSON.
-// Returns false if the JSON object was not of type Json::Type::OBJECT.
+// Returns false if the JSON object was not of type Json::Type::kObject.
 bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
                 size_t num_elements, void* dst, ValidationErrors* errors);
 
@@ -589,18 +610,9 @@ absl::StatusOr<T> LoadFromJson(
   ValidationErrors errors;
   T result{};
   json_detail::LoaderForType<T>()->LoadInto(json, args, &result, &errors);
-  if (!errors.ok()) return errors.status(error_prefix);
-  return std::move(result);
-}
-
-template <typename T>
-absl::StatusOr<RefCountedPtr<T>> LoadRefCountedFromJson(
-    const Json& json, const JsonArgs& args = JsonArgs(),
-    absl::string_view error_prefix = "errors validating JSON") {
-  ValidationErrors errors;
-  auto result = MakeRefCounted<T>();
-  json_detail::LoaderForType<T>()->LoadInto(json, args, result.get(), &errors);
-  if (!errors.ok()) return errors.status(error_prefix);
+  if (!errors.ok()) {
+    return errors.status(absl::StatusCode::kInvalidArgument, error_prefix);
+  }
   return std::move(result);
 }
 

data/src/core/lib/json/json_reader.cc

@@ -33,9 +33,12 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/json/json.h"
 
 #define GRPC_JSON_MAX_DEPTH 255
@@ -93,6 +96,28 @@ class JsonReader {
   //
   static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0;
 
+  struct Scope {
+    std::string parent_object_key;
+    absl::variant<Json::Object, Json::Array> data;
+
+    Json::Type type() const {
+      return Match(
+          data, [](const Json::Object&) { return Json::Type::kObject; },
+          [](const Json::Array&) { return Json::Type::kArray; });
+    }
+
+    Json TakeAsJson() {
+      return MatchMutable(
+          &data,
+          [&](Json::Object* object) {
+            return Json::FromObject(std::move(*object));
+          },
+          [&](Json::Array* array) {
+            return Json::FromArray(std::move(*array));
+          });
+    }
+  };
+
   explicit JsonReader(absl::string_view input)
       : original_input_(reinterpret_cast<const uint8_t*>(input.data())),
         input_(original_input_),
@@ -132,7 +157,7 @@ class JsonReader {
   uint8_t utf8_first_byte_ = 0;
 
   Json root_value_;
-  std::vector<Json*> stack_;
+  std::vector<Scope> stack_;
 
   std::string key_;
   std::string string_;
@@ -229,28 +254,14 @@ uint32_t JsonReader::ReadChar() {
 }
 
 Json* JsonReader::CreateAndLinkValue() {
-  Json* value;
-  if (stack_.empty()) {
-    value = &root_value_;
-  } else {
-    Json* parent = stack_.back();
-    if (parent->type() == Json::Type::OBJECT) {
-      if (parent->object_value().find(key_) != parent->object_value().end()) {
-        if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
-          truncated_errors_ = true;
-        } else {
-          errors_.push_back(absl::StrFormat(
-              "duplicate key \"%s\" at index %" PRIuPTR, key_, CurrentIndex()));
-        }
-      }
-      value = &(*parent->mutable_object())[std::move(key_)];
-    } else {
-      GPR_ASSERT(parent->type() == Json::Type::ARRAY);
-      parent->mutable_array()->emplace_back();
-      value = &parent->mutable_array()->back();
-    }
-  }
-  return value;
+  if (stack_.empty()) return &root_value_;
+  return MatchMutable(
+      &stack_.back().data,
+      [&](Json::Object* object) { return &(*object)[std::move(key_)]; },
+      [&](Json::Array* array) {
+        array->emplace_back();
+        return &array->back();
+      });
 }
 
 bool JsonReader::StartContainer(Json::Type type) {
@@ -264,49 +275,64 @@ bool JsonReader::StartContainer(Json::Type type) {
     }
     return false;
   }
-  Json* value = CreateAndLinkValue();
-  if (type == Json::Type::OBJECT) {
-    *value = Json::Object();
+  stack_.emplace_back();
+  Scope& scope = stack_.back();
+  scope.parent_object_key = std::move(key_);
+  if (type == Json::Type::kObject) {
+    scope.data = Json::Object();
   } else {
-    GPR_ASSERT(type == Json::Type::ARRAY);
-    *value = Json::Array();
+    GPR_ASSERT(type == Json::Type::kArray);
+    scope.data = Json::Array();
   }
-  stack_.push_back(value);
   return true;
 }
 
 void JsonReader::EndContainer() {
   GPR_ASSERT(!stack_.empty());
+  Scope scope = std::move(stack_.back());
   stack_.pop_back();
+  key_ = std::move(scope.parent_object_key);
+  Json* value = CreateAndLinkValue();
+  *value = scope.TakeAsJson();
 }
 
 void JsonReader::SetKey() {
   key_ = std::move(string_);
   string_.clear();
+  const Json::Object& object = absl::get<Json::Object>(stack_.back().data);
+  if (object.find(key_) != object.end()) {
+    if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
+      truncated_errors_ = true;
+    } else {
+      errors_.push_back(
+          absl::StrFormat("duplicate key \"%s\" at index %" PRIuPTR, key_,
+                          CurrentIndex() - key_.size() - 2));
+    }
+  }
 }
 
 void JsonReader::SetString() {
   Json* value = CreateAndLinkValue();
-  *value = std::move(string_);
+  *value = Json::FromString(std::move(string_));
   string_.clear();
 }
 
 bool JsonReader::SetNumber() {
   Json* value = CreateAndLinkValue();
-  *value = Json(string_, /*is_number=*/true);
+  *value = Json::FromNumber(std::move(string_));
   string_.clear();
   return true;
 }
 
 void JsonReader::SetTrue() {
   Json* value = CreateAndLinkValue();
-  *value = true;
+  *value = Json::FromBool(true);
   string_.clear();
 }
 
 void JsonReader::SetFalse() {
   Json* value = CreateAndLinkValue();
-  *value = false;
+  *value = Json::FromBool(false);
   string_.clear();
 }
 
@@ -405,9 +431,9 @@ JsonReader::Status JsonReader::Run() {
             if (stack_.empty()) {
               return Status::GRPC_JSON_PARSE_ERROR;
             } else if (c == '}' &&
-                       stack_.back()->type() != Json::Type::OBJECT) {
+                       stack_.back().type() != Json::Type::kObject) {
               return Status::GRPC_JSON_PARSE_ERROR;
-            } else if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) {
+            } else if (c == ']' && stack_.back().type() != Json::Type::kArray) {
               return Status::GRPC_JSON_PARSE_ERROR;
             }
             if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
@@ -422,10 +448,10 @@ JsonReader::Status JsonReader::Run() {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
               if (!stack_.empty() &&
-                  stack_.back()->type() == Json::Type::OBJECT) {
+                  stack_.back().type() == Json::Type::kObject) {
                 state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
               } else if (!stack_.empty() &&
-                         stack_.back()->type() == Json::Type::ARRAY) {
+                         stack_.back().type() == Json::Type::kArray) {
                 state_ = State::GRPC_JSON_STATE_VALUE_BEGIN;
               } else {
                 return Status::GRPC_JSON_PARSE_ERROR;
@@ -434,7 +460,7 @@ JsonReader::Status JsonReader::Run() {
               if (stack_.empty()) {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
-              if (c == '}' && stack_.back()->type() != Json::Type::OBJECT) {
+              if (c == '}' && stack_.back().type() != Json::Type::kObject) {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
               if (c == '}' &&
@@ -442,7 +468,7 @@ JsonReader::Status JsonReader::Run() {
                   !container_just_begun_) {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
-              if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) {
+              if (c == ']' && stack_.back().type() != Json::Type::kArray) {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
               if (c == ']' && state_ == State::GRPC_JSON_STATE_VALUE_BEGIN &&
@@ -450,6 +476,7 @@ JsonReader::Status JsonReader::Run() {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
               state_ = State::GRPC_JSON_STATE_VALUE_END;
+              container_just_begun_ = false;
               EndContainer();
               if (stack_.empty()) {
                 state_ = State::GRPC_JSON_STATE_END;
@@ -581,7 +608,7 @@ JsonReader::Status JsonReader::Run() {
 
               case '{':
                 container_just_begun_ = true;
-                if (!StartContainer(Json::Type::OBJECT)) {
+                if (!StartContainer(Json::Type::kObject)) {
                   return Status::GRPC_JSON_PARSE_ERROR;
                 }
                 state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
@@ -589,7 +616,7 @@ JsonReader::Status JsonReader::Run() {
 
               case '[':
                 container_just_begun_ = true;
-                if (!StartContainer(Json::Type::ARRAY)) {
+                if (!StartContainer(Json::Type::kArray)) {
                   return Status::GRPC_JSON_PARSE_ERROR;
                 }
                 break;
@@ -923,7 +950,7 @@ absl::StatusOr<Json> JsonReader::Parse(absl::string_view input) {
 
 }  // namespace
 
-absl::StatusOr<Json> Json::Parse(absl::string_view json_str) {
+absl::StatusOr<Json> JsonParse(absl::string_view json_str) {
   return JsonReader::Parse(json_str);
 }
 

data/src/core/{ext/filters/client_channel/lb_call_state_internal.h → lib/json/json_reader.h}

@@ -14,26 +14,21 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_CALL_STATE_INTERNAL_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_CALL_STATE_INTERNAL_H
+#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_READER_H
+#define GRPC_SRC_CORE_LIB_JSON_JSON_READER_H
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include "src/core/lib/gprpp/unique_type_name.h"
-#include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/lib/json/json.h"
 
 namespace grpc_core {
 
-//
-// LbCallStateInternal
-//
-class LbCallStateInternal : public LoadBalancingPolicy::CallState {
- public:
-  virtual absl::string_view GetCallAttribute(UniqueTypeName type) = 0;
-};
+// Parses JSON string from json_str.
+absl::StatusOr<Json> JsonParse(absl::string_view json_str);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_CALL_STATE_INTERNAL_H
+#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_READER_H

data/src/core/lib/json/json_util.cc

@@ -37,43 +37,38 @@ bool ParseDurationFromJson(const Json& field, Duration* duration) {
 
 bool ExtractJsonBool(const Json& json, absl::string_view field_name,
                      bool* output, std::vector<grpc_error_handle>* error_list) {
-  switch (json.type()) {
-    case Json::Type::JSON_TRUE:
-      *output = true;
-      return true;
-    case Json::Type::JSON_FALSE:
-      *output = false;
-      return true;
-    default:
-      error_list->push_back(GRPC_ERROR_CREATE(
-          absl::StrCat("field:", field_name, " error:type should be BOOLEAN")));
-      return false;
+  if (json.type() != Json::Type::kBoolean) {
+    error_list->push_back(GRPC_ERROR_CREATE(
+        absl::StrCat("field:", field_name, " error:type should be BOOLEAN")));
+    return false;
   }
+  *output = json.boolean();
+  return true;
 }
 
 bool ExtractJsonArray(const Json& json, absl::string_view field_name,
                       const Json::Array** output,
                       std::vector<grpc_error_handle>* error_list) {
-  if (json.type() != Json::Type::ARRAY) {
+  if (json.type() != Json::Type::kArray) {
     *output = nullptr;
     error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:type should be ARRAY")));
     return false;
   }
-  *output = &json.array_value();
+  *output = &json.array();
   return true;
 }
 
 bool ExtractJsonObject(const Json& json, absl::string_view field_name,
                        const Json::Object** output,
                        std::vector<grpc_error_handle>* error_list) {
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::kObject) {
     *output = nullptr;
     error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:type should be OBJECT")));
     return false;
   }
-  *output = &json.object_value();
+  *output = &json.object();
   return true;
 }
 

data/src/core/lib/json/json_util.h

@@ -54,12 +54,13 @@ bool ExtractJsonNumber(const Json& json, absl::string_view field_name,
                        NumericType* output,
                        std::vector<grpc_error_handle>* error_list) {
   static_assert(std::is_integral<NumericType>::value, "Integral required");
-  if (json.type() != Json::Type::NUMBER && json.type() != Json::Type::STRING) {
+  if (json.type() != Json::Type::kNumber &&
+      json.type() != Json::Type::kString) {
     error_list->push_back(GRPC_ERROR_CREATE(absl::StrCat(
         "field:", field_name, " error:type should be NUMBER or STRING")));
     return false;
   }
-  if (!absl::SimpleAtoi(json.string_value(), output)) {
+  if (!absl::SimpleAtoi(json.string(), output)) {
     error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:failed to parse.")));
     return false;
@@ -75,13 +76,13 @@ template <typename OutputType>
 bool ExtractJsonString(const Json& json, absl::string_view field_name,
                        OutputType* output,
                        std::vector<grpc_error_handle>* error_list) {
-  if (json.type() != Json::Type::STRING) {
+  if (json.type() != Json::Type::kString) {
     *output = "";
     error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:type should be STRING")));
     return false;
   }
-  *output = json.string_value();
+  *output = json.string();
   return true;
 }