grpc 1.27.0 → 1.30.2

data/src/core/ext/filters/client_channel/xds/xds_api.h

@@ -25,196 +25,255 @@
 
 #include <set>
 
+#include "absl/container/inlined_vector.h"
+#include "absl/types/optional.h"
+
 #include <grpc/slice_buffer.h>
 
 #include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
 #include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
-#include "src/core/lib/gprpp/optional.h"
 
 namespace grpc_core {
 
-constexpr char kCdsTypeUrl[] = "type.googleapis.com/envoy.api.v2.Cluster";
-constexpr char kEdsTypeUrl[] =
-    "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment";
-
-// The version state for each specific ADS resource type.
-struct VersionState {
-  // The version of the latest response that is accepted and used.
-  std::string version_info;
-  // The nonce of the latest response.
-  std::string nonce;
-  // The error message to be included in a NACK with the nonce. Consumed when a
-  // nonce is NACK'ed for the first time.
-  grpc_error* error = GRPC_ERROR_NONE;
-
-  ~VersionState() { GRPC_ERROR_UNREF(error); }
-};
-
-struct CdsUpdate {
-  // The name to use in the EDS request.
-  // If empty, the cluster name will be used.
-  std::string eds_service_name;
-  // The LRS server to use for load reporting.
-  // If not set, load reporting will be disabled.
-  // If set to the empty string, will use the same server we obtained the CDS
-  // data from.
-  Optional<std::string> lrs_load_reporting_server_name;
-};
-
-using CdsUpdateMap = std::map<std::string /*cluster_name*/, CdsUpdate>;
+class XdsClient;
 
-class XdsPriorityListUpdate {
+class XdsApi {
  public:
-  struct LocalityMap {
-    struct Locality {
-      bool operator==(const Locality& other) const {
-        return *name == *other.name && serverlist == other.serverlist &&
-               lb_weight == other.lb_weight && priority == other.priority;
-      }
-
-      // This comparator only compares the locality names.
-      struct Less {
-        bool operator()(const Locality& lhs, const Locality& rhs) const {
-          return XdsLocalityName::Less()(lhs.name, rhs.name);
+  static const char* kLdsTypeUrl;
+  static const char* kRdsTypeUrl;
+  static const char* kCdsTypeUrl;
+  static const char* kEdsTypeUrl;
+
+  struct RdsUpdate {
+    struct RdsRoute {
+      std::string service;
+      std::string method;
+      // TODO(donnadionne): When we can use absl::variant<>, consider using that
+      // here, to enforce the fact that only one of cluster_name and
+      // weighted_clusters can be set.
+      std::string cluster_name;
+      struct ClusterWeight {
+        std::string name;
+        uint32_t weight;
+
+        bool operator==(const ClusterWeight& other) const {
+          return (name == other.name && weight == other.weight);
         }
       };
+      std::vector<ClusterWeight> weighted_clusters;
 
-      RefCountedPtr<XdsLocalityName> name;
-      ServerAddressList serverlist;
-      uint32_t lb_weight;
-      uint32_t priority;
+      bool operator==(const RdsRoute& other) const {
+        return (service == other.service && method == other.method &&
+                cluster_name == other.cluster_name &&
+                weighted_clusters == other.weighted_clusters);
+      }
     };
 
-    bool Contains(const RefCountedPtr<XdsLocalityName>& name) const {
-      return localities.find(name) != localities.end();
+    std::vector<RdsRoute> routes;
+
+    bool operator==(const RdsUpdate& other) const {
+      return routes == other.routes;
     }
+  };
 
-    size_t size() const { return localities.size(); }
+  // TODO(roth): When we can use absl::variant<>, consider using that
+  // here, to enforce the fact that only one of the two fields can be set.
+  struct LdsUpdate {
+    // The name to use in the RDS request.
+    std::string route_config_name;
+    // The name to use in the CDS request. Present if the LDS response has it
+    // inlined.
+    absl::optional<RdsUpdate> rds_update;
+
+    bool operator==(const LdsUpdate& other) const {
+      return route_config_name == other.route_config_name &&
+             rds_update == other.rds_update;
+    }
+  };
 
-    std::map<RefCountedPtr<XdsLocalityName>, Locality, XdsLocalityName::Less>
-        localities;
+  using LdsUpdateMap = std::map<std::string /*server_name*/, LdsUpdate>;
+
+  using RdsUpdateMap = std::map<std::string /*route_config_name*/, RdsUpdate>;
+
+  struct CdsUpdate {
+    // The name to use in the EDS request.
+    // If empty, the cluster name will be used.
+    std::string eds_service_name;
+    // The LRS server to use for load reporting.
+    // If not set, load reporting will be disabled.
+    // If set to the empty string, will use the same server we obtained the CDS
+    // data from.
+    absl::optional<std::string> lrs_load_reporting_server_name;
   };
 
-  bool operator==(const XdsPriorityListUpdate& other) const;
-  bool operator!=(const XdsPriorityListUpdate& other) const {
-    return !(*this == other);
-  }
+  using CdsUpdateMap = std::map<std::string /*cluster_name*/, CdsUpdate>;
 
-  void Add(LocalityMap::Locality locality);
+  class PriorityListUpdate {
+   public:
+    struct LocalityMap {
+      struct Locality {
+        bool operator==(const Locality& other) const {
+          return *name == *other.name && serverlist == other.serverlist &&
+                 lb_weight == other.lb_weight && priority == other.priority;
+        }
 
-  const LocalityMap* Find(uint32_t priority) const;
+        // This comparator only compares the locality names.
+        struct Less {
+          bool operator()(const Locality& lhs, const Locality& rhs) const {
+            return XdsLocalityName::Less()(lhs.name, rhs.name);
+          }
+        };
+
+        RefCountedPtr<XdsLocalityName> name;
+        ServerAddressList serverlist;
+        uint32_t lb_weight;
+        uint32_t priority;
+      };
 
-  bool Contains(uint32_t priority) const {
-    return priority < priorities_.size();
-  }
-  bool Contains(const RefCountedPtr<XdsLocalityName>& name);
+      bool Contains(const RefCountedPtr<XdsLocalityName>& name) const {
+        return localities.find(name) != localities.end();
+      }
 
-  bool empty() const { return priorities_.empty(); }
-  size_t size() const { return priorities_.size(); }
+      size_t size() const { return localities.size(); }
 
-  // Callers should make sure the priority list is non-empty.
-  uint32_t LowestPriority() const {
-    return static_cast<uint32_t>(priorities_.size()) - 1;
-  }
+      std::map<RefCountedPtr<XdsLocalityName>, Locality, XdsLocalityName::Less>
+          localities;
+    };
 
- private:
-  InlinedVector<LocalityMap, 2> priorities_;
-};
+    bool operator==(const PriorityListUpdate& other) const;
+    bool operator!=(const PriorityListUpdate& other) const {
+      return !(*this == other);
+    }
 
-// There are two phases of accessing this class's content:
-// 1. to initialize in the control plane combiner;
-// 2. to use in the data plane combiner.
-// So no additional synchronization is needed.
-class XdsDropConfig : public RefCounted<XdsDropConfig> {
- public:
-  struct DropCategory {
-    bool operator==(const DropCategory& other) const {
-      return name == other.name && parts_per_million == other.parts_per_million;
+    void Add(LocalityMap::Locality locality);
+
+    const LocalityMap* Find(uint32_t priority) const;
+
+    bool Contains(uint32_t priority) const {
+      return priority < priorities_.size();
+    }
+    bool Contains(const RefCountedPtr<XdsLocalityName>& name);
+
+    bool empty() const { return priorities_.empty(); }
+    size_t size() const { return priorities_.size(); }
+
+    // Callers should make sure the priority list is non-empty.
+    uint32_t LowestPriority() const {
+      return static_cast<uint32_t>(priorities_.size()) - 1;
     }
 
-    std::string name;
-    const uint32_t parts_per_million;
+   private:
+    absl::InlinedVector<LocalityMap, 2> priorities_;
   };
 
-  using DropCategoryList = InlinedVector<DropCategory, 2>;
+  // There are two phases of accessing this class's content:
+  // 1. to initialize in the control plane combiner;
+  // 2. to use in the data plane combiner.
+  // So no additional synchronization is needed.
+  class DropConfig : public RefCounted<DropConfig> {
+   public:
+    struct DropCategory {
+      bool operator==(const DropCategory& other) const {
+        return name == other.name &&
+               parts_per_million == other.parts_per_million;
+      }
 
-  void AddCategory(std::string name, uint32_t parts_per_million) {
-    drop_category_list_.emplace_back(
-        DropCategory{std::move(name), parts_per_million});
-  }
+      std::string name;
+      const uint32_t parts_per_million;
+    };
 
-  // The only method invoked from the data plane combiner.
-  bool ShouldDrop(const std::string** category_name) const;
+    using DropCategoryList = absl::InlinedVector<DropCategory, 2>;
 
-  const DropCategoryList& drop_category_list() const {
-    return drop_category_list_;
-  }
+    void AddCategory(std::string name, uint32_t parts_per_million) {
+      drop_category_list_.emplace_back(
+          DropCategory{std::move(name), parts_per_million});
+      if (parts_per_million == 1000000) drop_all_ = true;
+    }
 
-  bool operator==(const XdsDropConfig& other) const {
-    return drop_category_list_ == other.drop_category_list_;
-  }
-  bool operator!=(const XdsDropConfig& other) const {
-    return !(*this == other);
-  }
+    // The only method invoked from the data plane combiner.
+    bool ShouldDrop(const std::string** category_name) const;
 
- private:
-  DropCategoryList drop_category_list_;
-};
+    const DropCategoryList& drop_category_list() const {
+      return drop_category_list_;
+    }
 
-struct EdsUpdate {
-  XdsPriorityListUpdate priority_list_update;
-  RefCountedPtr<XdsDropConfig> drop_config;
-  bool drop_all = false;
-};
+    bool drop_all() const { return drop_all_; }
 
-using EdsUpdateMap = std::map<std::string /*eds_service_name*/, EdsUpdate>;
-
-// Creates a request to nack an unsupported resource type.
-// Takes ownership of \a error.
-grpc_slice XdsUnsupportedTypeNackRequestCreateAndEncode(
-    const std::string& type_url, const std::string& nonce, grpc_error* error);
-
-// Creates a CDS request querying \a cluster_names.
-// Takes ownership of \a error.
-grpc_slice XdsCdsRequestCreateAndEncode(
-    const std::set<StringView>& cluster_names, const XdsBootstrap::Node* node,
-    const char* build_version, const std::string& version,
-    const std::string& nonce, grpc_error* error);
-
-// Creates an EDS request querying \a eds_service_names.
-// Takes ownership of \a error.
-grpc_slice XdsEdsRequestCreateAndEncode(
-    const std::set<StringView>& eds_service_names,
-    const XdsBootstrap::Node* node, const char* build_version,
-    const std::string& version, const std::string& nonce, grpc_error* error);
-
-// Parses the ADS response and outputs the validated update for either CDS or
-// EDS. If the response can't be parsed at the top level, \a type_url will point
-// to an empty string; otherwise, it will point to the received data.
-grpc_error* XdsAdsResponseDecodeAndParse(
-    const grpc_slice& encoded_response,
-    const std::set<StringView>& expected_eds_service_names,
-    CdsUpdateMap* cds_update_map, EdsUpdateMap* eds_update_map,
-    std::string* version, std::string* nonce, std::string* type_url);
-
-// Creates an LRS request querying \a server_name.
-grpc_slice XdsLrsRequestCreateAndEncode(const std::string& server_name,
-                                        const XdsBootstrap::Node* node,
-                                        const char* build_version);
-
-// Creates an LRS request sending client-side load reports. If all the counters
-// are zero, returns empty slice.
-grpc_slice XdsLrsRequestCreateAndEncode(
-    std::map<StringView /*cluster_name*/, std::set<XdsClientStats*>>
-        client_stats_map);
-
-// Parses the LRS response and returns \a
-// load_reporting_interval for client-side load reporting. If there is any
-// error, the output config is invalid.
-grpc_error* XdsLrsResponseDecodeAndParse(const grpc_slice& encoded_response,
-                                         std::set<std::string>* cluster_names,
-                                         grpc_millis* load_reporting_interval);
+    bool operator==(const DropConfig& other) const {
+      return drop_category_list_ == other.drop_category_list_;
+    }
+    bool operator!=(const DropConfig& other) const { return !(*this == other); }
+
+   private:
+    DropCategoryList drop_category_list_;
+    bool drop_all_ = false;
+  };
+
+  struct EdsUpdate {
+    PriorityListUpdate priority_list_update;
+    RefCountedPtr<DropConfig> drop_config;
+  };
+
+  using EdsUpdateMap = std::map<std::string /*eds_service_name*/, EdsUpdate>;
+
+  struct ClusterLoadReport {
+    XdsClusterDropStats::DroppedRequestsMap dropped_requests;
+    std::map<RefCountedPtr<XdsLocalityName>, XdsClusterLocalityStats::Snapshot,
+             XdsLocalityName::Less>
+        locality_stats;
+    grpc_millis load_report_interval;
+  };
+  using ClusterLoadReportMap = std::map<
+      std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
+      ClusterLoadReport>;
+
+  XdsApi(XdsClient* client, TraceFlag* tracer, const XdsBootstrap::Node* node);
+
+  // Creates an ADS request.
+  // Takes ownership of \a error.
+  grpc_slice CreateAdsRequest(const std::string& type_url,
+                              const std::set<absl::string_view>& resource_names,
+                              const std::string& version,
+                              const std::string& nonce, grpc_error* error,
+                              bool populate_node);
+
+  // Parses the ADS response and outputs the validated update for either CDS or
+  // EDS. If the response can't be parsed at the top level, \a type_url will
+  // point to an empty string; otherwise, it will point to the received data.
+  grpc_error* ParseAdsResponse(
+      const grpc_slice& encoded_response,
+      const std::string& expected_server_name,
+      const std::set<absl::string_view>& expected_route_configuration_names,
+      const std::set<absl::string_view>& expected_cluster_names,
+      const std::set<absl::string_view>& expected_eds_service_names,
+      absl::optional<LdsUpdate>* lds_update,
+      absl::optional<RdsUpdate>* rds_update, CdsUpdateMap* cds_update_map,
+      EdsUpdateMap* eds_update_map, std::string* version, std::string* nonce,
+      std::string* type_url);
+
+  // Creates an LRS request querying \a server_name.
+  grpc_slice CreateLrsInitialRequest(const std::string& server_name);
+
+  // Creates an LRS request sending a client-side load report.
+  grpc_slice CreateLrsRequest(ClusterLoadReportMap cluster_load_report_map);
+
+  // Parses the LRS response and returns \a
+  // load_reporting_interval for client-side load reporting. If there is any
+  // error, the output config is invalid.
+  grpc_error* ParseLrsResponse(const grpc_slice& encoded_response,
+                               bool* send_all_clusters,
+                               std::set<std::string>* cluster_names,
+                               grpc_millis* load_reporting_interval);
+
+ private:
+  XdsClient* client_;
+  TraceFlag* tracer_;
+  const bool xds_routing_enabled_;
+  const XdsBootstrap::Node* node_;
+  const std::string build_version_;
+  const std::string user_agent_name_;
+};
 
 }  // namespace grpc_core
 

data/src/core/ext/filters/client_channel/xds/xds_bootstrap.cc

@@ -18,107 +18,148 @@
 
 #include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
 
+#include <vector>
+
 #include <errno.h>
 #include <stdlib.h>
 
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
+
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 namespace grpc_core {
 
-std::unique_ptr<XdsBootstrap> XdsBootstrap::ReadFromFile(grpc_error** error) {
+namespace {
+
+std::string BootstrapString(const XdsBootstrap& bootstrap) {
+  std::vector<std::string> parts;
+  if (bootstrap.node() != nullptr) {
+    parts.push_back(absl::StrFormat(
+        "node={\n"
+        "  id=\"%s\",\n"
+        "  cluster=\"%s\",\n"
+        "  locality={\n"
+        "    region=\"%s\",\n"
+        "    zone=\"%s\",\n"
+        "    subzone=\"%s\"\n"
+        "  },\n"
+        "  metadata=%s,\n"
+        "},\n",
+        bootstrap.node()->id, bootstrap.node()->cluster,
+        bootstrap.node()->locality_region, bootstrap.node()->locality_zone,
+        bootstrap.node()->locality_subzone, bootstrap.node()->metadata.Dump()));
+  }
+  parts.push_back(
+      absl::StrFormat("servers=[\n"
+                      "  {\n"
+                      "    uri=\"%s\",\n"
+                      "    creds=[\n",
+                      bootstrap.server().server_uri));
+  for (const auto& creds : bootstrap.server().channel_creds) {
+    parts.push_back(absl::StrFormat("      {type=\"%s\", config=%s},\n",
+                                    creds.type, creds.config.Dump()));
+  }
+  parts.push_back("    ]\n  }\n]");
+  return absl::StrJoin(parts, "");
+}
+
+}  // namespace
+
+std::unique_ptr<XdsBootstrap> XdsBootstrap::ReadFromFile(XdsClient* client,
+                                                         TraceFlag* tracer,
+                                                         grpc_error** error) {
   grpc_core::UniquePtr<char> path(gpr_getenv("GRPC_XDS_BOOTSTRAP"));
   if (path == nullptr) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "GRPC_XDS_BOOTSTRAP env var not set");
+        "Environment variable GRPC_XDS_BOOTSTRAP not defined");
     return nullptr;
   }
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer)) {
+    gpr_log(GPR_INFO,
+            "[xds_client %p] Got bootstrap file location from "
+            "GRPC_XDS_BOOTSTRAP environment variable: %s",
+            client, path.get());
+  }
   grpc_slice contents;
   *error = grpc_load_file(path.get(), /*add_null_terminator=*/true, &contents);
   if (*error != GRPC_ERROR_NONE) return nullptr;
-  return MakeUnique<XdsBootstrap>(contents, error);
+  absl::string_view contents_str_view = StringViewFromSlice(contents);
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer)) {
+    gpr_log(GPR_DEBUG, "[xds_client %p] Bootstrap file contents: %s", client,
+            std::string(contents_str_view).c_str());
+  }
+  Json json = Json::Parse(contents_str_view, error);
+  grpc_slice_unref_internal(contents);
+  if (*error != GRPC_ERROR_NONE) {
+    char* msg;
+    gpr_asprintf(&msg, "Failed to parse bootstrap file %s", path.get());
+    grpc_error* error_out =
+        GRPC_ERROR_CREATE_REFERENCING_FROM_COPIED_STRING(msg, error, 1);
+    gpr_free(msg);
+    GRPC_ERROR_UNREF(*error);
+    *error = error_out;
+    return nullptr;
+  }
+  std::unique_ptr<XdsBootstrap> result =
+      absl::make_unique<XdsBootstrap>(std::move(json), error);
+  if (*error == GRPC_ERROR_NONE && GRPC_TRACE_FLAG_ENABLED(*tracer)) {
+    gpr_log(GPR_INFO,
+            "[xds_client %p] Bootstrap config for creating xds client:\n%s",
+            client, BootstrapString(*result).c_str());
+  }
+  return result;
 }
 
-XdsBootstrap::XdsBootstrap(grpc_slice contents, grpc_error** error)
-    : contents_(contents) {
-  tree_ = grpc_json_parse_string_with_len(
-      reinterpret_cast<char*>(GPR_SLICE_START_PTR(contents_)),
-      GPR_SLICE_LENGTH(contents_));
-  if (tree_ == nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "failed to parse bootstrap file JSON");
-    return;
-  }
-  if (tree_->type != GRPC_JSON_OBJECT || tree_->key != nullptr) {
+XdsBootstrap::XdsBootstrap(Json json, grpc_error** error) {
+  if (json.type() != Json::Type::OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "malformed JSON in bootstrap file");
     return;
   }
-  InlinedVector<grpc_error*, 1> error_list;
-  bool seen_xds_servers = false;
-  bool seen_node = false;
-  for (grpc_json* child = tree_->child; child != nullptr; child = child->next) {
-    if (child->key == nullptr) {
-      error_list.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON key is null"));
-    } else if (strcmp(child->key, "xds_servers") == 0) {
-      if (child->type != GRPC_JSON_ARRAY) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"xds_servers\" field is not an array"));
-      }
-      if (seen_xds_servers) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "duplicate \"xds_servers\" field"));
-      }
-      seen_xds_servers = true;
-      grpc_error* parse_error = ParseXdsServerList(child);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
-    } else if (strcmp(child->key, "node") == 0) {
-      if (child->type != GRPC_JSON_OBJECT) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"node\" field is not an object"));
-      }
-      if (seen_node) {
-        error_list.push_back(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("duplicate \"node\" field"));
-      }
-      seen_node = true;
-      grpc_error* parse_error = ParseNode(child);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
-    }
-  }
-  if (!seen_xds_servers) {
+  std::vector<grpc_error*> error_list;
+  auto it = json.mutable_object()->find("xds_servers");
+  if (it == json.mutable_object()->end()) {
     error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "\"xds_servers\" field not present"));
+  } else if (it->second.type() != Json::Type::ARRAY) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "\"xds_servers\" field is not an array"));
+  } else {
+    grpc_error* parse_error = ParseXdsServerList(&it->second);
+    if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+  }
+  it = json.mutable_object()->find("node");
+  if (it != json.mutable_object()->end()) {
+    if (it->second.type() != Json::Type::OBJECT) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"node\" field is not an object"));
+    } else {
+      grpc_error* parse_error = ParseNode(&it->second);
+      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+    }
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing xds bootstrap file",
                                          &error_list);
 }
 
-XdsBootstrap::~XdsBootstrap() {
-  grpc_json_destroy(tree_);
-  grpc_slice_unref_internal(contents_);
-}
-
-grpc_error* XdsBootstrap::ParseXdsServerList(grpc_json* json) {
-  InlinedVector<grpc_error*, 1> error_list;
-  size_t idx = 0;
-  for (grpc_json *child = json->child; child != nullptr;
-       child = child->next, ++idx) {
-    if (child->key != nullptr) {
+grpc_error* XdsBootstrap::ParseXdsServerList(Json* json) {
+  std::vector<grpc_error*> error_list;
+  for (size_t i = 0; i < json->mutable_array()->size(); ++i) {
+    Json& child = json->mutable_array()->at(i);
+    if (child.type() != Json::Type::OBJECT) {
       char* msg;
-      gpr_asprintf(&msg, "array element %" PRIuPTR " key is not null", idx);
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-    }
-    if (child->type != GRPC_JSON_OBJECT) {
-      char* msg;
-      gpr_asprintf(&msg, "array element %" PRIuPTR " is not an object", idx);
+      gpr_asprintf(&msg, "array element %" PRIuPTR " is not an object", i);
       error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
+      gpr_free(msg);
     } else {
-      grpc_error* parse_error = ParseXdsServer(child, idx);
+      grpc_error* parse_error = ParseXdsServer(&child, i);
       if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
     }
   }
@@ -126,42 +167,29 @@ grpc_error* XdsBootstrap::ParseXdsServerList(grpc_json* json) {
                                        &error_list);
 }
 
-grpc_error* XdsBootstrap::ParseXdsServer(grpc_json* json, size_t idx) {
-  InlinedVector<grpc_error*, 1> error_list;
+grpc_error* XdsBootstrap::ParseXdsServer(Json* json, size_t idx) {
+  std::vector<grpc_error*> error_list;
   servers_.emplace_back();
   XdsServer& server = servers_[servers_.size() - 1];
-  bool seen_channel_creds = false;
-  for (grpc_json* child = json->child; child != nullptr; child = child->next) {
-    if (child->key == nullptr) {
-      error_list.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON key is null"));
-    } else if (strcmp(child->key, "server_uri") == 0) {
-      if (child->type != GRPC_JSON_STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"server_uri\" field is not a string"));
-      }
-      if (server.server_uri != nullptr) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "duplicate \"server_uri\" field"));
-      }
-      server.server_uri = child->value;
-    } else if (strcmp(child->key, "channel_creds") == 0) {
-      if (child->type != GRPC_JSON_ARRAY) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"channel_creds\" field is not an array"));
-      }
-      if (seen_channel_creds) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "duplicate \"channel_creds\" field"));
-      }
-      seen_channel_creds = true;
-      grpc_error* parse_error = ParseChannelCredsArray(child, &server);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
-    }
-  }
-  if (server.server_uri == nullptr) {
+  auto it = json->mutable_object()->find("server_uri");
+  if (it == json->mutable_object()->end()) {
     error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "\"server_uri\" field not present"));
+  } else if (it->second.type() != Json::Type::STRING) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "\"server_uri\" field is not a string"));
+  } else {
+    server.server_uri = std::move(*it->second.mutable_string_value());
+  }
+  it = json->mutable_object()->find("channel_creds");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::ARRAY) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"channel_creds\" field is not an array"));
+    } else {
+      grpc_error* parse_error = ParseChannelCredsArray(&it->second, &server);
+      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+    }
   }
   // Can't use GRPC_ERROR_CREATE_FROM_VECTOR() here, because the error
   // string is not static in this case.
@@ -176,23 +204,18 @@ grpc_error* XdsBootstrap::ParseXdsServer(grpc_json* json, size_t idx) {
   return error;
 }
 
-grpc_error* XdsBootstrap::ParseChannelCredsArray(grpc_json* json,
+grpc_error* XdsBootstrap::ParseChannelCredsArray(Json* json,
                                                  XdsServer* server) {
-  InlinedVector<grpc_error*, 1> error_list;
-  size_t idx = 0;
-  for (grpc_json *child = json->child; child != nullptr;
-       child = child->next, ++idx) {
-    if (child->key != nullptr) {
+  std::vector<grpc_error*> error_list;
+  for (size_t i = 0; i < json->mutable_array()->size(); ++i) {
+    Json& child = json->mutable_array()->at(i);
+    if (child.type() != Json::Type::OBJECT) {
       char* msg;
-      gpr_asprintf(&msg, "array element %" PRIuPTR " key is not null", idx);
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-    }
-    if (child->type != GRPC_JSON_OBJECT) {
-      char* msg;
-      gpr_asprintf(&msg, "array element %" PRIuPTR " is not an object", idx);
+      gpr_asprintf(&msg, "array element %" PRIuPTR " is not an object", i);
       error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
+      gpr_free(msg);
     } else {
-      grpc_error* parse_error = ParseChannelCreds(child, idx, server);
+      grpc_error* parse_error = ParseChannelCreds(&child, i, server);
       if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
     }
   }
@@ -200,38 +223,31 @@ grpc_error* XdsBootstrap::ParseChannelCredsArray(grpc_json* json,
                                        &error_list);
 }
 
-grpc_error* XdsBootstrap::ParseChannelCreds(grpc_json* json, size_t idx,
+grpc_error* XdsBootstrap::ParseChannelCreds(Json* json, size_t idx,
                                             XdsServer* server) {
-  InlinedVector<grpc_error*, 1> error_list;
+  std::vector<grpc_error*> error_list;
   ChannelCreds channel_creds;
-  for (grpc_json* child = json->child; child != nullptr; child = child->next) {
-    if (child->key == nullptr) {
-      error_list.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON key is null"));
-    } else if (strcmp(child->key, "type") == 0) {
-      if (child->type != GRPC_JSON_STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"type\" field is not a string"));
-      }
-      if (channel_creds.type != nullptr) {
-        error_list.push_back(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("duplicate \"type\" field"));
-      }
-      channel_creds.type = child->value;
-    } else if (strcmp(child->key, "config") == 0) {
-      if (child->type != GRPC_JSON_OBJECT) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"config\" field is not an object"));
-      }
-      if (channel_creds.config != nullptr) {
-        error_list.push_back(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("duplicate \"config\" field"));
-      }
-      channel_creds.config = child;
+  auto it = json->mutable_object()->find("type");
+  if (it == json->mutable_object()->end()) {
+    error_list.push_back(
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("\"type\" field not present"));
+  } else if (it->second.type() != Json::Type::STRING) {
+    error_list.push_back(
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("\"type\" field is not a string"));
+  } else {
+    channel_creds.type = std::move(*it->second.mutable_string_value());
+  }
+  it = json->mutable_object()->find("config");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::OBJECT) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"config\" field is not an object"));
+    } else {
+      channel_creds.config = std::move(it->second);
     }
   }
-  if (channel_creds.type != nullptr) {
-    server->channel_creds.push_back(channel_creds);
+  if (!channel_creds.type.empty()) {
+    server->channel_creds.emplace_back(std::move(channel_creds));
   }
   // Can't use GRPC_ERROR_CREATE_FROM_VECTOR() here, because the error
   // string is not static in this case.
@@ -246,242 +262,81 @@ grpc_error* XdsBootstrap::ParseChannelCreds(grpc_json* json, size_t idx,
   return error;
 }
 
-grpc_error* XdsBootstrap::ParseNode(grpc_json* json) {
-  InlinedVector<grpc_error*, 1> error_list;
-  node_ = MakeUnique<Node>();
-  bool seen_metadata = false;
-  bool seen_locality = false;
-  for (grpc_json* child = json->child; child != nullptr; child = child->next) {
-    if (child->key == nullptr) {
+grpc_error* XdsBootstrap::ParseNode(Json* json) {
+  std::vector<grpc_error*> error_list;
+  node_ = absl::make_unique<Node>();
+  auto it = json->mutable_object()->find("id");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::STRING) {
       error_list.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON key is null"));
-    } else if (strcmp(child->key, "id") == 0) {
-      if (child->type != GRPC_JSON_STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"id\" field is not a string"));
-      }
-      if (node_->id != nullptr) {
-        error_list.push_back(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("duplicate \"id\" field"));
-      }
-      node_->id = child->value;
-    } else if (strcmp(child->key, "cluster") == 0) {
-      if (child->type != GRPC_JSON_STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"cluster\" field is not a string"));
-      }
-      if (node_->cluster != nullptr) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "duplicate \"cluster\" field"));
-      }
-      node_->cluster = child->value;
-    } else if (strcmp(child->key, "locality") == 0) {
-      if (child->type != GRPC_JSON_OBJECT) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"locality\" field is not an object"));
-      }
-      if (seen_locality) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "duplicate \"locality\" field"));
-      }
-      seen_locality = true;
-      grpc_error* parse_error = ParseLocality(child);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
-    } else if (strcmp(child->key, "metadata") == 0) {
-      if (child->type != GRPC_JSON_OBJECT) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"metadata\" field is not an object"));
-      }
-      if (seen_metadata) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "duplicate \"metadata\" field"));
-      }
-      seen_metadata = true;
-      InlinedVector<grpc_error*, 1> parse_errors =
-          ParseMetadataStruct(child, &node_->metadata);
-      if (!parse_errors.empty()) {
-        grpc_error* parse_error = GRPC_ERROR_CREATE_FROM_VECTOR(
-            "errors parsing \"metadata\" object", &parse_errors);
-        error_list.push_back(parse_error);
-      }
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("\"id\" field is not a string"));
+    } else {
+      node_->id = std::move(*it->second.mutable_string_value());
     }
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"node\" object",
-                                       &error_list);
-}
-
-grpc_error* XdsBootstrap::ParseLocality(grpc_json* json) {
-  InlinedVector<grpc_error*, 1> error_list;
-  node_->locality_region = nullptr;
-  node_->locality_zone = nullptr;
-  node_->locality_subzone = nullptr;
-  for (grpc_json* child = json->child; child != nullptr; child = child->next) {
-    if (child->key == nullptr) {
-      error_list.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON key is null"));
-    } else if (strcmp(child->key, "region") == 0) {
-      if (child->type != GRPC_JSON_STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"region\" field is not a string"));
-      }
-      if (node_->locality_region != nullptr) {
-        error_list.push_back(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("duplicate \"region\" field"));
-      }
-      node_->locality_region = child->value;
-    } else if (strcmp(child->key, "zone") == 0) {
-      if (child->type != GRPC_JSON_STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"zone\" field is not a string"));
-      }
-      if (node_->locality_zone != nullptr) {
-        error_list.push_back(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("duplicate \"zone\" field"));
-      }
-      node_->locality_zone = child->value;
-    } else if (strcmp(child->key, "subzone") == 0) {
-      if (child->type != GRPC_JSON_STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"subzone\" field is not a string"));
-      }
-      if (node_->locality_subzone != nullptr) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "duplicate \"subzone\" field"));
-      }
-      node_->locality_subzone = child->value;
+  it = json->mutable_object()->find("cluster");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::STRING) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"cluster\" field is not a string"));
+    } else {
+      node_->cluster = std::move(*it->second.mutable_string_value());
     }
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"locality\" object",
-                                       &error_list);
-}
-
-InlinedVector<grpc_error*, 1> XdsBootstrap::ParseMetadataStruct(
-    grpc_json* json,
-    std::map<const char*, XdsBootstrap::MetadataValue, StringLess>* result) {
-  InlinedVector<grpc_error*, 1> error_list;
-  for (grpc_json* child = json->child; child != nullptr; child = child->next) {
-    if (child->key == nullptr) {
-      error_list.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON key is null"));
-      continue;
-    }
-    if (result->find(child->key) != result->end()) {
-      char* msg;
-      gpr_asprintf(&msg, "duplicate metadata key \"%s\"", child->key);
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-      gpr_free(msg);
+  it = json->mutable_object()->find("locality");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::OBJECT) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"locality\" field is not an object"));
+    } else {
+      grpc_error* parse_error = ParseLocality(&it->second);
+      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
     }
-    MetadataValue& value = (*result)[child->key];
-    grpc_error* parse_error = ParseMetadataValue(child, 0, &value);
-    if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
   }
-  return error_list;
-}
-
-InlinedVector<grpc_error*, 1> XdsBootstrap::ParseMetadataList(
-    grpc_json* json, std::vector<MetadataValue>* result) {
-  InlinedVector<grpc_error*, 1> error_list;
-  size_t idx = 0;
-  for (grpc_json *child = json->child; child != nullptr;
-       child = child->next, ++idx) {
-    if (child->key != nullptr) {
-      char* msg;
-      gpr_asprintf(&msg, "JSON key is non-null for index %" PRIuPTR, idx);
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-      gpr_free(msg);
+  it = json->mutable_object()->find("metadata");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::OBJECT) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"metadata\" field is not an object"));
+    } else {
+      node_->metadata = std::move(it->second);
     }
-    result->emplace_back();
-    grpc_error* parse_error = ParseMetadataValue(child, idx, &result->back());
-    if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
   }
-  return error_list;
+  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"node\" object",
+                                       &error_list);
 }
 
-grpc_error* XdsBootstrap::ParseMetadataValue(grpc_json* json, size_t idx,
-                                             MetadataValue* result) {
-  grpc_error* error = GRPC_ERROR_NONE;
-  auto context_func = [json, idx]() {
-    char* context;
-    if (json->key != nullptr) {
-      gpr_asprintf(&context, "key \"%s\"", json->key);
+grpc_error* XdsBootstrap::ParseLocality(Json* json) {
+  std::vector<grpc_error*> error_list;
+  auto it = json->mutable_object()->find("region");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::STRING) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"region\" field is not a string"));
     } else {
-      gpr_asprintf(&context, "index %" PRIuPTR, idx);
+      node_->locality_region = std::move(*it->second.mutable_string_value());
     }
-    return context;
-  };
-  switch (json->type) {
-    case GRPC_JSON_STRING:
-      result->type = MetadataValue::Type::STRING;
-      result->string_value = json->value;
-      break;
-    case GRPC_JSON_NUMBER:
-      result->type = MetadataValue::Type::DOUBLE;
-      errno = 0;  // To distinguish error.
-      result->double_value = strtod(json->value, nullptr);
-      if (errno != 0) {
-        char* context = context_func();
-        char* msg;
-        gpr_asprintf(&msg, "error parsing numeric value for %s: \"%s\"",
-                     context, json->value);
-        error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-        gpr_free(context);
-        gpr_free(msg);
-      }
-      break;
-    case GRPC_JSON_TRUE:
-      result->type = MetadataValue::Type::BOOL;
-      result->bool_value = true;
-      break;
-    case GRPC_JSON_FALSE:
-      result->type = MetadataValue::Type::BOOL;
-      result->bool_value = false;
-      break;
-    case GRPC_JSON_NULL:
-      result->type = MetadataValue::Type::MD_NULL;
-      break;
-    case GRPC_JSON_ARRAY: {
-      result->type = MetadataValue::Type::LIST;
-      InlinedVector<grpc_error*, 1> error_list =
-          ParseMetadataList(json, &result->list_value);
-      if (!error_list.empty()) {
-        // Can't use GRPC_ERROR_CREATE_FROM_VECTOR() here, because the error
-        // string is not static in this case.
-        char* context = context_func();
-        char* msg;
-        gpr_asprintf(&msg, "errors parsing struct for %s", context);
-        error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-        gpr_free(context);
-        gpr_free(msg);
-        for (size_t i = 0; i < error_list.size(); ++i) {
-          error = grpc_error_add_child(error, error_list[i]);
-        }
-      }
-      break;
+  }
+  it = json->mutable_object()->find("zone");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::STRING) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"zone\" field is not a string"));
+    } else {
+      node_->locality_zone = std::move(*it->second.mutable_string_value());
     }
-    case GRPC_JSON_OBJECT: {
-      result->type = MetadataValue::Type::STRUCT;
-      InlinedVector<grpc_error*, 1> error_list =
-          ParseMetadataStruct(json, &result->struct_value);
-      if (!error_list.empty()) {
-        // Can't use GRPC_ERROR_CREATE_FROM_VECTOR() here, because the error
-        // string is not static in this case.
-        char* context = context_func();
-        char* msg;
-        gpr_asprintf(&msg, "errors parsing struct for %s", context);
-        error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-        gpr_free(context);
-        gpr_free(msg);
-        for (size_t i = 0; i < error_list.size(); ++i) {
-          error = grpc_error_add_child(error, error_list[i]);
-          GRPC_ERROR_UNREF(error_list[i]);
-        }
-      }
-      break;
+  }
+  it = json->mutable_object()->find("subzone");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::STRING) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"subzone\" field is not a string"));
+    } else {
+      node_->locality_subzone = std::move(*it->second.mutable_string_value());
     }
-    default:
-      break;
   }
-  return error;
+  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"locality\" object",
+                                       &error_list);
 }
 
 }  // namespace grpc_core