grpc 1.26.0 → 1.28.0

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

@@ -23,6 +23,10 @@
 
 #include <stdint.h>
 
+#include <set>
+
+#include "absl/types/optional.h"
+
 #include <grpc/slice_buffer.h>
 
 #include "src/core/ext/filters/client_channel/server_address.h"
@@ -31,151 +35,246 @@
 
 namespace grpc_core {
 
-class XdsPriorityListUpdate {
+class XdsClient;
+
+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;
-      }
+  static const char* kLdsTypeUrl;
+  static const char* kRdsTypeUrl;
+  static const char* kCdsTypeUrl;
+  static const char* kEdsTypeUrl;
+
+  struct RdsUpdate {
+    // The name to use in the CDS request.
+    std::string cluster_name;
+
+    bool operator==(const RdsUpdate& other) const {
+      return cluster_name == other.cluster_name;
+    }
+  };
+
+  // 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;
+    }
+  };
+
+  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;
+  };
 
-      // 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);
+  using CdsUpdateMap = std::map<std::string /*cluster_name*/, CdsUpdate>;
+
+  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;
         }
+
+        // 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;
       };
 
-      RefCountedPtr<XdsLocalityName> name;
-      ServerAddressList serverlist;
-      uint32_t lb_weight;
-      uint32_t priority;
+      bool Contains(const RefCountedPtr<XdsLocalityName>& name) const {
+        return localities.find(name) != localities.end();
+      }
+
+      size_t size() const { return localities.size(); }
+
+      std::map<RefCountedPtr<XdsLocalityName>, Locality, XdsLocalityName::Less>
+          localities;
     };
 
-    bool Contains(const RefCountedPtr<XdsLocalityName>& name) const {
-      return localities.find(name) != localities.end();
+    bool operator==(const PriorityListUpdate& other) const;
+    bool operator!=(const PriorityListUpdate& other) const {
+      return !(*this == other);
     }
 
-    size_t size() const { return localities.size(); }
+    void Add(LocalityMap::Locality locality);
 
-    std::map<RefCountedPtr<XdsLocalityName>, Locality, XdsLocalityName::Less>
-        localities;
-  };
+    const LocalityMap* Find(uint32_t priority) const;
 
-  bool operator==(const XdsPriorityListUpdate& other) const;
-  bool operator!=(const XdsPriorityListUpdate& other) const {
-    return !(*this == other);
-  }
+    bool Contains(uint32_t priority) const {
+      return priority < priorities_.size();
+    }
+    bool Contains(const RefCountedPtr<XdsLocalityName>& name);
 
-  void Add(LocalityMap::Locality locality);
+    bool empty() const { return priorities_.empty(); }
+    size_t size() const { return priorities_.size(); }
 
-  const LocalityMap* Find(uint32_t priority) const;
+    // Callers should make sure the priority list is non-empty.
+    uint32_t LowestPriority() const {
+      return static_cast<uint32_t>(priorities_.size()) - 1;
+    }
 
-  bool Contains(uint32_t priority) const {
-    return priority < priorities_.size();
-  }
-  bool Contains(const RefCountedPtr<XdsLocalityName>& name);
+   private:
+    InlinedVector<LocalityMap, 2> priorities_;
+  };
 
-  bool empty() const { return priorities_.empty(); }
-  size_t size() const { return priorities_.size(); }
+  // 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;
+      }
 
-  // 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:
-  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 XdsDropConfig : public RefCounted<XdsDropConfig> {
- public:
-  struct DropCategory {
-    bool operator==(const DropCategory& other) const {
-      return strcmp(name.get(), other.name.get()) == 0 &&
-             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});
+      if (parts_per_million == 1000000) drop_all_ = true;
     }
 
-    grpc_core::UniquePtr<char> 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 = InlinedVector<DropCategory, 2>;
+    const DropCategoryList& drop_category_list() const {
+      return drop_category_list_;
+    }
 
-  void AddCategory(grpc_core::UniquePtr<char> name,
-                   uint32_t parts_per_million) {
-    drop_category_list_.emplace_back(
-        DropCategory{std::move(name), parts_per_million});
-  }
+    bool drop_all() const { return drop_all_; }
 
-  // The only method invoked from the data plane combiner.
-  bool ShouldDrop(const grpc_core::UniquePtr<char>** category_name) const;
+    bool operator==(const DropConfig& other) const {
+      return drop_category_list_ == other.drop_category_list_;
+    }
+    bool operator!=(const DropConfig& other) const { return !(*this == other); }
 
-  const DropCategoryList& drop_category_list() const {
-    return drop_category_list_;
-  }
+   private:
+    DropCategoryList drop_category_list_;
+    bool drop_all_ = false;
+  };
 
-  bool operator==(const XdsDropConfig& other) const {
-    return drop_category_list_ == other.drop_category_list_;
-  }
-  bool operator!=(const XdsDropConfig& other) const {
-    return !(*this == other);
-  }
+  struct EdsUpdate {
+    PriorityListUpdate priority_list_update;
+    RefCountedPtr<DropConfig> drop_config;
+  };
 
- private:
-  DropCategoryList drop_category_list_;
-};
+  using EdsUpdateMap = std::map<std::string /*eds_service_name*/, EdsUpdate>;
 
-struct EdsUpdate {
-  XdsPriorityListUpdate priority_list_update;
-  RefCountedPtr<XdsDropConfig> drop_config;
-  bool drop_all = false;
-};
+  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 a request to nack an unsupported resource type.
+  // Takes ownership of \a error.
+  grpc_slice CreateUnsupportedTypeNackRequest(const std::string& type_url,
+                                              const std::string& nonce,
+                                              grpc_error* error);
+
+  // Creates an LDS request querying \a server_name.
+  // Takes ownership of \a error.
+  grpc_slice CreateLdsRequest(const std::string& server_name,
+                              const std::string& version,
+                              const std::string& nonce, grpc_error* error,
+                              bool populate_node);
+
+  // Creates an RDS request querying \a route_config_name.
+  // Takes ownership of \a error.
+  grpc_slice CreateRdsRequest(const std::string& route_config_name,
+                              const std::string& version,
+                              const std::string& nonce, grpc_error* error,
+                              bool populate_node);
+
+  // Creates a CDS request querying \a cluster_names.
+  // Takes ownership of \a error.
+  grpc_slice CreateCdsRequest(const std::set<StringView>& cluster_names,
+                              const std::string& version,
+                              const std::string& nonce, grpc_error* error,
+                              bool populate_node);
+
+  // Creates an EDS request querying \a eds_service_names.
+  // Takes ownership of \a error.
+  grpc_slice CreateEdsRequest(const std::set<StringView>& eds_service_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::string& expected_route_config_name,
+      const std::set<StringView>& expected_cluster_names,
+      const std::set<StringView>& 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,
+                               std::set<std::string>* cluster_names,
+                               grpc_millis* load_reporting_interval);
 
-struct CdsUpdate {
-  // The name to use in the EDS request.
-  // If null, the cluster name will be used.
-  grpc_core::UniquePtr<char> eds_service_name;
-  // The LRS server to use for load reporting.
-  // If null, load reporting will be disabled.
-  // If set to the empty string, will use the same server we obtained
-  // the CDS data from.
-  grpc_core::UniquePtr<char> lrs_load_reporting_server_name;
+ private:
+  XdsClient* client_;
+  TraceFlag* tracer_;
+  const XdsBootstrap::Node* node_;
+  const std::string build_version_;
+  const std::string user_agent_name_;
 };
 
-// Creates an EDS request querying \a service_name.
-grpc_slice XdsEdsRequestCreateAndEncode(const char* server_name,
-                                        const XdsBootstrap::Node* node,
-                                        const char* build_version);
-
-// Parses the EDS response and returns the args to update locality map. If there
-// is any error, the output update is invalid.
-grpc_error* XdsEdsResponseDecodeAndParse(const grpc_slice& encoded_response,
-                                         EdsUpdate* update);
-
-// Creates an LRS request querying \a server_name.
-grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
-                                        const XdsBootstrap::Node* node,
-                                        const char* build_version);
-
-// Creates an LRS request sending client-side load reports. If all the counters
-// in \a client_stats are zero, returns empty slice.
-grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
-                                        XdsClientStats* client_stats);
-
-// Parses the LRS response and returns \a cluster_name and \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,
-    grpc_core::UniquePtr<char>* cluster_name,
-    grpc_millis* load_reporting_interval);
-
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_API_H */

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

@@ -29,136 +29,198 @@
 
 namespace grpc_core {
 
-std::unique_ptr<XdsBootstrap> XdsBootstrap::ReadFromFile(grpc_error** error) {
+namespace {
+
+UniquePtr<char> BootstrapString(const XdsBootstrap& bootstrap) {
+  gpr_strvec v;
+  gpr_strvec_init(&v);
+  char* tmp;
+  if (bootstrap.node() != nullptr) {
+    gpr_asprintf(&tmp,
+                 "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.c_str(),
+                 bootstrap.node()->cluster.c_str(),
+                 bootstrap.node()->locality_region.c_str(),
+                 bootstrap.node()->locality_zone.c_str(),
+                 bootstrap.node()->locality_subzone.c_str(),
+                 bootstrap.node()->metadata.Dump().c_str());
+    gpr_strvec_add(&v, tmp);
+  }
+  gpr_asprintf(&tmp,
+               "servers=[\n"
+               "  {\n"
+               "    uri=\"%s\",\n"
+               "    creds=[\n",
+               bootstrap.server().server_uri.c_str());
+  gpr_strvec_add(&v, tmp);
+  for (size_t i = 0; i < bootstrap.server().channel_creds.size(); ++i) {
+    const auto& creds = bootstrap.server().channel_creds[i];
+    gpr_asprintf(&tmp, "      {type=\"%s\", config=%s},\n", creds.type.c_str(),
+                 creds.config.Dump().c_str());
+    gpr_strvec_add(&v, tmp);
+  }
+  gpr_strvec_add(&v, gpr_strdup("    ]\n  }\n]"));
+  UniquePtr<char> result(gpr_strvec_flatten(&v, nullptr));
+  gpr_strvec_destroy(&v);
+  return result;
+}
+
+}  // 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);
+  StringView contents_str_view = StringViewFromSlice(contents);
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer)) {
+    UniquePtr<char> str = StringViewToCString(contents_str_view);
+    gpr_log(GPR_DEBUG, "[xds_client %p] Bootstrap file contents: %s", client,
+            str.get());
+  }
+  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).get());
+  }
+  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_server = 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_server") == 0) {
-      if (child->type != GRPC_JSON_OBJECT) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "\"xds_server\" field is not an object"));
-      }
-      if (seen_xds_server) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "duplicate \"xds_server\" field"));
-      }
-      seen_xds_server = true;
-      grpc_error* parse_error = ParseXdsServer(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);
+  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);
     }
   }
-  if (!seen_xds_server) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "\"xds_server\" field not present"));
-  }
   *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::ParseXdsServer(grpc_json* json) {
+grpc_error* XdsBootstrap::ParseXdsServerList(Json* json) {
   InlinedVector<grpc_error*, 1> error_list;
-  server_uri_ = nullptr;
-  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_uri_ != nullptr) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "duplicate \"server_uri\" field"));
-      }
-      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);
+  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 " 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, i);
       if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
     }
   }
-  if (server_uri_ == nullptr) {
+  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"xds_servers\" array",
+                                       &error_list);
+}
+
+grpc_error* XdsBootstrap::ParseXdsServer(Json* json, size_t idx) {
+  InlinedVector<grpc_error*, 1> error_list;
+  servers_.emplace_back();
+  XdsServer& server = servers_[servers_.size() - 1];
+  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());
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"xds_server\" object",
-                                       &error_list);
+  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.
+  if (error_list.empty()) return GRPC_ERROR_NONE;
+  char* msg;
+  gpr_asprintf(&msg, "errors parsing index %" PRIuPTR, idx);
+  grpc_error* error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+  gpr_free(msg);
+  for (size_t i = 0; i < error_list.size(); ++i) {
+    error = grpc_error_add_child(error, error_list[i]);
+  }
+  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) {
-      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) {
+  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 " 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);
+      grpc_error* parse_error = ParseChannelCreds(&child, i, server);
       if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
     }
   }
@@ -166,36 +228,32 @@ 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;
   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) 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.
   if (error_list.empty()) return GRPC_ERROR_NONE;
@@ -209,242 +267,81 @@ grpc_error* XdsBootstrap::ParseChannelCreds(grpc_json* json, size_t idx) {
   return error;
 }
 
-grpc_error* XdsBootstrap::ParseNode(grpc_json* json) {
+grpc_error* XdsBootstrap::ParseNode(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) {
+  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;
+  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);
     }
-    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("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);
     }
-    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;
+  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"node\" object",
+                                       &error_list);
 }
 
-InlinedVector<grpc_error*, 1> XdsBootstrap::ParseMetadataList(
-    grpc_json* json, std::vector<MetadataValue>* result) {
+grpc_error* XdsBootstrap::ParseLocality(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) {
-      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);
+  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 {
+      node_->locality_region = std::move(*it->second.mutable_string_value());
     }
-    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;
-}
-
-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);
+  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 {
-      gpr_asprintf(&context, "index %" PRIuPTR, idx);
+      node_->locality_zone = 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;
-    }
-    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