grpc 1.55.0 → 1.56.0.pre3

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_resolver.cc

@@ -38,6 +38,7 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/address_filtering.h"
@@ -308,10 +309,10 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
     void Start() override;
     void Orphan() override;
     Json::Array override_child_policy() override {
-      return Json::Array{
-          Json::Object{
-              {"pick_first", Json::Object()},
-          },
+      return {
+          Json::FromObject({
+              {"pick_first", Json::FromObject({})},
+          }),
       };
     }
     bool disable_reresolution() override { return false; };
@@ -878,8 +879,8 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
       Json child_policy;
       if (!discovery_entry.discovery_mechanism->override_child_policy()
                .empty()) {
-        child_policy =
-            discovery_entry.discovery_mechanism->override_child_policy();
+        child_policy = Json::FromArray(
+            discovery_entry.discovery_mechanism->override_child_policy());
       } else {
         child_policy = config_->xds_lb_policy();
       }
@@ -889,32 +890,34 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
       };
       if (!discovery_config.override_host_statuses.empty()) {
         xds_override_host_lb_config["overrideHostStatus"] =
-            discovery_config.override_host_statuses;
+            Json::FromArray(discovery_config.override_host_statuses);
       }
-      Json::Array xds_override_host_config = {Json::Object{
+      Json::Array xds_override_host_config = {Json::FromObject({
           {"xds_override_host_experimental",
-           std::move(xds_override_host_lb_config)},
-      }};
+           Json::FromObject(std::move(xds_override_host_lb_config))},
+      })};
       // Wrap it in the xds_cluster_impl policy.
       Json::Array drop_categories;
       if (discovery_entry.latest_update->drop_config != nullptr) {
         for (const auto& category :
              discovery_entry.latest_update->drop_config->drop_category_list()) {
-          drop_categories.push_back(Json::Object{
-              {"category", category.name},
-              {"requests_per_million", category.parts_per_million},
-          });
+          drop_categories.push_back(Json::FromObject({
+              {"category", Json::FromString(category.name)},
+              {"requests_per_million",
+               Json::FromNumber(category.parts_per_million)},
+          }));
         }
       }
       Json::Object xds_cluster_impl_config = {
-          {"clusterName", discovery_config.cluster_name},
-          {"childPolicy", std::move(xds_override_host_config)},
-          {"dropCategories", std::move(drop_categories)},
-          {"maxConcurrentRequests", discovery_config.max_concurrent_requests},
+          {"clusterName", Json::FromString(discovery_config.cluster_name)},
+          {"childPolicy", Json::FromArray(std::move(xds_override_host_config))},
+          {"dropCategories", Json::FromArray(std::move(drop_categories))},
+          {"maxConcurrentRequests",
+           Json::FromNumber(discovery_config.max_concurrent_requests)},
       };
       if (!discovery_config.eds_service_name.empty()) {
         xds_cluster_impl_config["edsServiceName"] =
-            discovery_config.eds_service_name;
+            Json::FromString(discovery_config.eds_service_name);
       }
       if (discovery_config.lrs_load_reporting_server.has_value()) {
         xds_cluster_impl_config["lrsLoadReportingServer"] =
@@ -926,32 +929,34 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
         outlier_detection_config =
             discovery_entry.config().outlier_detection_lb_config.value();
       }
-      outlier_detection_config["childPolicy"] = Json::Array{Json::Object{
-          {"xds_cluster_impl_experimental", std::move(xds_cluster_impl_config)},
-      }};
-      Json locality_picking_policy = Json::Array{Json::Object{
+      outlier_detection_config["childPolicy"] =
+          Json::FromArray({Json::FromObject({
+              {"xds_cluster_impl_experimental",
+               Json::FromObject(std::move(xds_cluster_impl_config))},
+          })});
+      Json locality_picking_policy = Json::FromArray({Json::FromObject({
           {"outlier_detection_experimental",
-           std::move(outlier_detection_config)},
-      }};
+           Json::FromObject(std::move(outlier_detection_config))},
+      })});
       // Add priority entry, with the appropriate child name.
       std::string child_name = discovery_entry.GetChildPolicyName(priority);
-      priority_priorities.emplace_back(child_name);
+      priority_priorities.emplace_back(Json::FromString(child_name));
       Json::Object child_config = {
           {"config", std::move(locality_picking_policy)},
       };
       if (discovery_entry.discovery_mechanism->disable_reresolution()) {
-        child_config["ignore_reresolution_requests"] = true;
+        child_config["ignore_reresolution_requests"] = Json::FromBool(true);
       }
-      priority_children[child_name] = std::move(child_config);
+      priority_children[child_name] = Json::FromObject(std::move(child_config));
     }
   }
-  Json json = Json::Array{Json::Object{
+  Json json = Json::FromArray({Json::FromObject({
       {"priority_experimental",
-       Json::Object{
-           {"children", std::move(priority_children)},
-           {"priorities", std::move(priority_priorities)},
-       }},
-  }};
+       Json::FromObject({
+           {"children", Json::FromObject(std::move(priority_children))},
+           {"priorities", Json::FromArray(std::move(priority_priorities))},
+       })},
+  })});
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_cluster_resolver_trace)) {
     gpr_log(
         GPR_INFO,
@@ -1145,15 +1150,7 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::kNull) {
-      // xds_cluster_resolver was mentioned as a policy in the deprecated
-      // loadBalancingPolicy field or in the client API.
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:xds_cluster_resolver policy "
-          "requires configuration. "
-          "Please use loadBalancingConfig field of service config instead.");
-    }
-    return LoadRefCountedFromJson<XdsClusterResolverLbConfig>(
+    return LoadFromJson<RefCountedPtr<XdsClusterResolverLbConfig>>(
         json, JsonArgs(),
         "errors validating xds_cluster_resolver LB policy config");
   }

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_override_host.cc

@@ -319,7 +319,7 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
   OrphanablePtr<LoadBalancingPolicy> child_policy_;
 
   // Latest state and picker reported by the child policy.
-  grpc_connectivity_state state_ = GRPC_CHANNEL_IDLE;
+  grpc_connectivity_state state_ = GRPC_CHANNEL_CONNECTING;
   absl::Status status_;
   RefCountedPtr<SubchannelPicker> picker_;
   Mutex subchannel_map_mu_;
@@ -370,8 +370,11 @@ XdsOverrideHostLb::Picker::PickOverridenHost(absl::string_view override_host) {
 LoadBalancingPolicy::PickResult XdsOverrideHostLb::Picker::Pick(
     LoadBalancingPolicy::PickArgs args) {
   auto* call_state = static_cast<ClientChannelLbCallState*>(args.call_state);
-  auto override_host = call_state->GetCallAttribute(XdsOverrideHostTypeName());
-  auto overridden_host_pick = PickOverridenHost(override_host);
+  auto* override_host = static_cast<XdsOverrideHostAttribute*>(
+      call_state->GetCallAttribute(XdsOverrideHostAttribute::TypeName()));
+  auto overridden_host_pick =
+      PickOverridenHost(override_host != nullptr ? override_host->host_name()
+                                                 : absl::string_view());
   if (overridden_host_pick.has_value()) {
     return std::move(*overridden_host_pick);
   }
@@ -740,15 +743,7 @@ class XdsOverrideHostLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::kNull) {
-      // This policy was configured in the deprecated loadBalancingPolicy
-      // field or in the client API.
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:xds_override_host policy requires "
-          "configuration. Please use loadBalancingConfig field of service "
-          "config instead.");
-    }
-    return LoadRefCountedFromJson<XdsOverrideHostLbConfig>(
+    return LoadFromJson<RefCountedPtr<XdsOverrideHostLbConfig>>(
         json, JsonArgs(),
         "errors validating xds_override_host LB policy config");
   }

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_wrr_locality.cc

@@ -30,6 +30,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/connectivity_state.h>
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_attributes.h"
@@ -211,19 +212,19 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
     const std::string& locality_name = p.first;
     uint32_t weight = p.second;
     // Add weighted target entry.
-    weighted_targets[locality_name] = Json::Object{
-        {"weight", weight},
+    weighted_targets[locality_name] = Json::FromObject({
+        {"weight", Json::FromNumber(weight)},
         {"childPolicy", config->child_config()},
-    };
+    });
   }
-  Json child_config_json = Json::Array{
-      Json::Object{
+  Json child_config_json = Json::FromArray({
+      Json::FromObject({
           {"weighted_target_experimental",
-           Json::Object{
-               {"targets", std::move(weighted_targets)},
-           }},
-      },
-  };
+           Json::FromObject({
+               {"targets", Json::FromObject(std::move(weighted_targets))},
+           })},
+      }),
+  });
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_wrr_locality_lb_trace)) {
     gpr_log(GPR_INFO,
             "[xds_wrr_locality_lb %p] generated child policy config: %s", this,
@@ -346,15 +347,7 @@ class XdsWrrLocalityLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::kNull) {
-      // xds_wrr_locality was mentioned as a policy in the deprecated
-      // loadBalancingPolicy field or in the client API.
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:xds_wrr_locality policy requires "
-          "configuration.  Please use loadBalancingConfig field of service "
-          "config instead.");
-    }
-    return LoadRefCountedFromJson<XdsWrrLocalityLbConfig>(
+    return LoadFromJson<RefCountedPtr<XdsWrrLocalityLbConfig>>(
         json, JsonArgs(),
         "errors validating xds_wrr_locality LB policy config");
   }

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -666,35 +666,33 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
       if (hr->is_balancer) {
         args = args.Set(GRPC_ARG_DEFAULT_AUTHORITY, hr->host);
       }
+      grpc_resolved_address address;
+      memset(&address, 0, sizeof(address));
       switch (hostent->h_addrtype) {
         case AF_INET6: {
-          size_t addr_len = sizeof(struct sockaddr_in6);
-          struct sockaddr_in6 addr;
-          memset(&addr, 0, addr_len);
-          memcpy(&addr.sin6_addr, hostent->h_addr_list[i],
+          address.len = sizeof(struct sockaddr_in6);
+          auto* addr = reinterpret_cast<struct sockaddr_in6*>(&address.addr);
+          memcpy(&addr->sin6_addr, hostent->h_addr_list[i],
                  sizeof(struct in6_addr));
-          addr.sin6_family = static_cast<unsigned char>(hostent->h_addrtype);
-          addr.sin6_port = hr->port;
-          addresses.emplace_back(&addr, addr_len, args);
+          addr->sin6_family = static_cast<unsigned char>(hostent->h_addrtype);
+          addr->sin6_port = hr->port;
           char output[INET6_ADDRSTRLEN];
-          ares_inet_ntop(AF_INET6, &addr.sin6_addr, output, INET6_ADDRSTRLEN);
+          ares_inet_ntop(AF_INET6, &addr->sin6_addr, output, INET6_ADDRSTRLEN);
           GRPC_CARES_TRACE_LOG(
               "request:%p c-ares resolver gets a AF_INET6 result: \n"
               "  addr: %s\n  port: %d\n  sin6_scope_id: %d\n",
-              r, output, ntohs(hr->port), addr.sin6_scope_id);
+              r, output, ntohs(hr->port), addr->sin6_scope_id);
           break;
         }
         case AF_INET: {
-          size_t addr_len = sizeof(struct sockaddr_in);
-          struct sockaddr_in addr;
-          memset(&addr, 0, addr_len);
-          memcpy(&addr.sin_addr, hostent->h_addr_list[i],
+          address.len = sizeof(struct sockaddr_in);
+          auto* addr = reinterpret_cast<struct sockaddr_in*>(&address.addr);
+          memcpy(&addr->sin_addr, hostent->h_addr_list[i],
                  sizeof(struct in_addr));
-          addr.sin_family = static_cast<unsigned char>(hostent->h_addrtype);
-          addr.sin_port = hr->port;
-          addresses.emplace_back(&addr, addr_len, args);
+          addr->sin_family = static_cast<unsigned char>(hostent->h_addrtype);
+          addr->sin_port = hr->port;
           char output[INET_ADDRSTRLEN];
-          ares_inet_ntop(AF_INET, &addr.sin_addr, output, INET_ADDRSTRLEN);
+          ares_inet_ntop(AF_INET, &addr->sin_addr, output, INET_ADDRSTRLEN);
           GRPC_CARES_TRACE_LOG(
               "request:%p c-ares resolver gets a AF_INET result: \n"
               "  addr: %s\n  port: %d\n",
@@ -702,6 +700,7 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
           break;
         }
       }
+      addresses.emplace_back(address, args);
     }
   } else {
     std::string error_msg = absl::StrFormat(
@@ -920,7 +919,7 @@ static bool inner_resolve_as_ip_literal_locked(
                                false /* log errors */)) {
     GPR_ASSERT(*addrs == nullptr);
     *addrs = std::make_unique<ServerAddressList>();
-    (*addrs)->emplace_back(addr.addr, addr.len, grpc_core::ChannelArgs());
+    (*addrs)->emplace_back(addr, grpc_core::ChannelArgs());
     return true;
   }
   return false;
@@ -979,23 +978,26 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     GPR_ASSERT(*addrs == nullptr);
     *addrs = std::make_unique<grpc_core::ServerAddressList>();
     uint16_t numeric_port = grpc_strhtons(port->c_str());
+    grpc_resolved_address address;
     // Append the ipv6 loopback address.
-    struct sockaddr_in6 ipv6_loopback_addr;
-    memset(&ipv6_loopback_addr, 0, sizeof(ipv6_loopback_addr));
-    ((char*)&ipv6_loopback_addr.sin6_addr)[15] = 1;
-    ipv6_loopback_addr.sin6_family = AF_INET6;
-    ipv6_loopback_addr.sin6_port = numeric_port;
-    (*addrs)->emplace_back(&ipv6_loopback_addr, sizeof(ipv6_loopback_addr),
-                           grpc_core::ChannelArgs() /* args */);
+    memset(&address, 0, sizeof(address));
+    auto* ipv6_loopback_addr =
+        reinterpret_cast<struct sockaddr_in6*>(&address.addr);
+    ((char*)&ipv6_loopback_addr->sin6_addr)[15] = 1;
+    ipv6_loopback_addr->sin6_family = AF_INET6;
+    ipv6_loopback_addr->sin6_port = numeric_port;
+    address.len = sizeof(struct sockaddr_in6);
+    (*addrs)->emplace_back(address, grpc_core::ChannelArgs());
     // Append the ipv4 loopback address.
-    struct sockaddr_in ipv4_loopback_addr;
-    memset(&ipv4_loopback_addr, 0, sizeof(ipv4_loopback_addr));
-    ((char*)&ipv4_loopback_addr.sin_addr)[0] = 0x7f;
-    ((char*)&ipv4_loopback_addr.sin_addr)[3] = 0x01;
-    ipv4_loopback_addr.sin_family = AF_INET;
-    ipv4_loopback_addr.sin_port = numeric_port;
-    (*addrs)->emplace_back(&ipv4_loopback_addr, sizeof(ipv4_loopback_addr),
-                           grpc_core::ChannelArgs() /* args */);
+    memset(&address, 0, sizeof(address));
+    auto* ipv4_loopback_addr =
+        reinterpret_cast<struct sockaddr_in*>(&address.addr);
+    ((char*)&ipv4_loopback_addr->sin_addr)[0] = 0x7f;
+    ((char*)&ipv4_loopback_addr->sin_addr)[3] = 0x01;
+    ipv4_loopback_addr->sin_family = AF_INET;
+    ipv4_loopback_addr->sin_port = numeric_port;
+    address.len = sizeof(struct sockaddr_in);
+    (*addrs)->emplace_back(address, grpc_core::ChannelArgs());
     // Let the address sorter figure out which one should be tried first.
     grpc_cares_wrapper_address_sorting_sort(r, addrs->get());
     return true;

data/src/core/ext/filters/client_channel/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -31,6 +31,7 @@
 #include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
@@ -128,7 +129,7 @@ class EventEngineClientChannelDNSResolver : public PollingResolver {
     void OnBalancerHostnamesResolved(
         std::string authority,
         absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses);
-    void OnTXTResolved(absl::StatusOr<std::string> service_config);
+    void OnTXTResolved(absl::StatusOr<std::vector<std::string>> service_config);
     // Returns a Result if resolution is complete.
     // callers must release the lock and call OnRequestComplete if a Result is
     // returned. This is because OnRequestComplete may Orphan the resolver,
@@ -251,7 +252,7 @@ EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
         resolver_.get(), resolver_->name_to_resolve().c_str());
     txt_handle_ = event_engine_resolver_->LookupTXT(
         [self = Ref(DEBUG_LOCATION, "OnTXTResolved")](
-            absl::StatusOr<std::string> service_config) {
+            absl::StatusOr<std::vector<std::string>> service_config) {
           self->OnTXTResolved(std::move(service_config));
         },
         absl::StrCat("_grpc_config.", resolver_->name_to_resolve()),
@@ -333,6 +334,10 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     result = OnResolvedLocked();
     return;
   }
+  if (srv_records->empty()) {
+    result = OnResolvedLocked();
+    return;
+  }
   // Do a subsequent hostname query since SRV records were returned
   for (auto& srv_record : *srv_records) {
     GRPC_EVENT_ENGINE_RESOLVER_TRACE(
@@ -388,7 +393,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
 }
 
 void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
-    OnTXTResolved(absl::StatusOr<std::string> service_config) {
+    OnTXTResolved(absl::StatusOr<std::vector<std::string>> service_config) {
   ValidationErrors::ScopedField field(&errors_, "txt lookup");
   absl::optional<Resolver::Result> result;
   {
@@ -400,7 +405,22 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
       errors_.AddError(service_config.status().message());
       service_config_json_ = service_config.status();
     } else {
-      service_config_json_ = absl::StrCat("grpc_config=", *service_config);
+      static constexpr absl::string_view kServiceConfigAttributePrefix =
+          "grpc_config=";
+      auto result = std::find_if(service_config->begin(), service_config->end(),
+                                 [&](absl::string_view s) {
+                                   return absl::StartsWith(
+                                       s, kServiceConfigAttributePrefix);
+                                 });
+      if (result != service_config->end()) {
+        service_config_json_ =
+            result->substr(kServiceConfigAttributePrefix.size());
+      } else {
+        service_config_json_ = absl::UnavailableError(absl::StrCat(
+            "failed to find attribute prefix: ", kServiceConfigAttributePrefix,
+            " in TXT records"));
+        errors_.AddError(service_config_json_.status().message());
+      }
     }
     result = OnResolvedLocked();
   }
@@ -480,6 +500,11 @@ absl::optional<Resolver::Result> EventEngineClientChannelDNSResolver::
     absl::Status status = errors_.status(
         absl::StatusCode::kUnavailable,
         absl::StrCat("errors resolving ", resolver_->name_to_resolve()));
+    if (status.ok()) {
+      // If no errors were returned, but the results are empty, we still need to
+      // return an error. Validation errors may be empty.
+      status = absl::UnavailableError("No results from DNS queries");
+    }
     GRPC_EVENT_ENGINE_RESOLVER_TRACE("%s", status.message().data());
     result.addresses = status;
     result.service_config = status;

data/src/core/ext/filters/client_channel/resolver/dns/event_engine/service_config_helper.cc

@@ -88,7 +88,7 @@ absl::StatusOr<std::string> ChooseServiceConfig(
         continue;
       }
     }
-    return JsonDump(choice.service_config);
+    return JsonDump(Json::FromObject(choice.service_config));
   }
   // No matching service config was found
   return "";

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -29,6 +29,7 @@
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/gcp/metadata_query.h"
@@ -219,17 +220,17 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
   std::mt19937 mt(rd());
   std::uniform_int_distribution<uint64_t> dist(1, UINT64_MAX);
   Json::Object node = {
-      {"id", absl::StrCat("C2P-", dist(mt))},
+      {"id", Json::FromString(absl::StrCat("C2P-", dist(mt)))},
   };
   if (!zone_->empty()) {
-    node["locality"] = Json::Object{
-        {"zone", *zone_},
-    };
+    node["locality"] = Json::FromObject({
+        {"zone", Json::FromString(*zone_)},
+    });
   };
   if (*supports_ipv6_) {
-    node["metadata"] = Json::Object{
-        {"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", true},
-    };
+    node["metadata"] = Json::FromObject({
+        {"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", Json::FromBool(true)},
+    });
   }
   // Allow the TD server uri to be overridden for testing purposes.
   auto override_server =
@@ -238,29 +239,29 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
       override_server.has_value() && !override_server->empty()
           ? override_server->c_str()
           : "directpath-pa.googleapis.com";
-  Json xds_server = Json::Array{
-      Json::Object{
-          {"server_uri", server_uri},
+  Json xds_server = Json::FromArray({
+      Json::FromObject({
+          {"server_uri", Json::FromString(server_uri)},
           {"channel_creds",
-           Json::Array{
-               Json::Object{
-                   {"type", "google_default"},
-               },
-           }},
-          {"server_features", Json::Array{"ignore_resource_deletion"}},
-      },
-  };
-  Json bootstrap = Json::Object{
+           Json::FromArray({
+               Json::FromObject({
+                   {"type", Json::FromString("google_default")},
+               }),
+           })},
+          {"server_features",
+           Json::FromArray({Json::FromString("ignore_resource_deletion")})},
+      }),
+  });
+  Json bootstrap = Json::FromObject({
       {"xds_servers", xds_server},
       {"authorities",
-       Json::Object{
-           {kC2PAuthority,
-            Json::Object{
-                {"xds_servers", std::move(xds_server)},
-            }},
-       }},
-      {"node", std::move(node)},
-  };
+       Json::FromObject({
+           {kC2PAuthority, Json::FromObject({
+                               {"xds_servers", std::move(xds_server)},
+                           })},
+       })},
+      {"node", Json::FromObject(std::move(node))},
+  });
   // Inject bootstrap JSON as fallback config.
   internal::SetXdsFallbackBootstrapConfig(JsonDump(bootstrap).c_str());
   // Now start xDS resolver.