grpc 1.28.0 → 1.36.0

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

@@ -1,280 +0,0 @@
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_API_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_API_H
-
-#include <grpc/support/port_platform.h>
-
-#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"
-#include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
-#include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
-
-namespace grpc_core {
-
-class XdsClient;
-
-class XdsApi {
- public:
-  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;
-  };
-
-  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;
-      };
-
-      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 operator==(const PriorityListUpdate& other) const;
-    bool operator!=(const PriorityListUpdate& other) const {
-      return !(*this == other);
-    }
-
-    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;
-    }
-
-   private:
-    InlinedVector<LocalityMap, 2> priorities_;
-  };
-
-  // 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;
-      }
-
-      std::string name;
-      const uint32_t parts_per_million;
-    };
-
-    using DropCategoryList = InlinedVector<DropCategory, 2>;
-
-    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;
-    }
-
-    // The only method invoked from the data plane combiner.
-    bool ShouldDrop(const std::string** category_name) const;
-
-    const DropCategoryList& drop_category_list() const {
-      return drop_category_list_;
-    }
-
-    bool drop_all() const { return drop_all_; }
-
-    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 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);
-
- private:
-  XdsClient* client_;
-  TraceFlag* tracer_;
-  const XdsBootstrap::Node* node_;
-  const std::string build_version_;
-  const std::string user_agent_name_;
-};
-
-}  // 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

@@ -1,347 +0,0 @@
-//
-// Copyright 2019 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
-
-#include <errno.h>
-#include <stdlib.h>
-
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/iomgr/load_file.h"
-#include "src/core/lib/slice/slice_internal.h"
-
-namespace grpc_core {
-
-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(
-        "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;
-  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(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;
-  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);
-}
-
-grpc_error* XdsBootstrap::ParseXdsServerList(Json* json) {
-  InlinedVector<grpc_error*, 1> 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 " 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);
-    }
-  }
-  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());
-  }
-  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(Json* json,
-                                                 XdsServer* server) {
-  InlinedVector<grpc_error*, 1> 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 " 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, i, server);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
-    }
-  }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"channel_creds\" array",
-                                       &error_list);
-}
-
-grpc_error* XdsBootstrap::ParseChannelCreds(Json* json, size_t idx,
-                                            XdsServer* server) {
-  InlinedVector<grpc_error*, 1> error_list;
-  ChannelCreds channel_creds;
-  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.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;
-  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::ParseNode(Json* json) {
-  InlinedVector<grpc_error*, 1> 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("\"id\" field is not a string"));
-    } else {
-      node_->id = std::move(*it->second.mutable_string_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());
-    }
-  }
-  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);
-    }
-  }
-  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);
-    }
-  }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"node\" object",
-                                       &error_list);
-}
-
-grpc_error* XdsBootstrap::ParseLocality(Json* json) {
-  InlinedVector<grpc_error*, 1> 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 {
-      node_->locality_region = std::move(*it->second.mutable_string_value());
-    }
-  }
-  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());
-    }
-  }
-  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());
-    }
-  }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"locality\" object",
-                                       &error_list);
-}
-
-}  // namespace grpc_core