grpc 1.54.3 → 1.59.2

data/src/core/ext/xds/xds_client.cc

@@ -31,7 +31,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
-#include "upb/arena.h"
+#include "upb/mem/arena.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
@@ -152,7 +152,8 @@ class XdsClient::ChannelState::AdsCallState
                        absl::string_view serialized_resource) override
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
-    void ResourceWrapperParsingFailed(size_t idx) override;
+    void ResourceWrapperParsingFailed(size_t idx,
+                                      absl::string_view message) override;
 
     Result TakeResult() { return std::move(result_); }
 
@@ -445,8 +446,8 @@ XdsClient::ChannelState::ChannelState(WeakRefCountedPtr<XdsClient> xds_client,
       xds_client_(std::move(xds_client)),
       server_(server) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-    gpr_log(GPR_INFO, "[xds_client %p] creating channel to %s",
-            xds_client_.get(), server.server_uri().c_str());
+    gpr_log(GPR_INFO, "[xds_client %p] creating channel %p for server %s",
+            xds_client_.get(), this, server.server_uri().c_str());
   }
   absl::Status status;
   transport_ = xds_client_->transport_factory_->Create(
@@ -473,6 +474,10 @@ XdsClient::ChannelState::~ChannelState() {
 // called from DualRefCounted::Unref, which cannot have a lock annotation for
 // a lock in this subclass.
 void XdsClient::ChannelState::Orphan() ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    gpr_log(GPR_INFO, "[xds_client %p] orphaning xds channel %p for server %s",
+            xds_client(), this, server_.server_uri().c_str());
+  }
   shutting_down_ = true;
   transport_.reset();
   // At this time, all strong refs are removed, remove from channel map to
@@ -860,23 +865,20 @@ void XdsClient::ChannelState::AdsCallState::AdsResponseParser::ParseResource(
       std::string(serialized_resource), result_.version, update_time_);
   // Notify watchers.
   auto& watchers_list = resource_state.watchers;
-  auto* value =
-      result_.type->CopyResource(resource_state.resource.get()).release();
   xds_client()->work_serializer_.Schedule(
-      [watchers_list, value]()
+      [watchers_list, value = resource_state.resource]()
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&xds_client()->work_serializer_) {
             for (const auto& p : watchers_list) {
               p.first->OnGenericResourceChanged(value);
             }
-            delete value;
           },
       DEBUG_LOCATION);
 }
 
 void XdsClient::ChannelState::AdsCallState::AdsResponseParser::
-    ResourceWrapperParsingFailed(size_t idx) {
-  result_.errors.emplace_back(absl::StrCat(
-      "resource index ", idx, ": Can't decode Resource proto wrapper"));
+    ResourceWrapperParsingFailed(size_t idx, absl::string_view message) {
+  result_.errors.emplace_back(
+      absl::StrCat("resource index ", idx, ": ", message));
 }
 
 //
@@ -1208,6 +1210,11 @@ void XdsClient::ChannelState::LrsCallState::Reporter::Orphan() {
 
 void XdsClient::ChannelState::LrsCallState::Reporter::
     ScheduleNextReportLocked() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_client %p] xds server %s: scheduling load report timer",
+            xds_client(), parent_->chand()->server_.server_uri().c_str());
+  }
   timer_handle_ = xds_client()->engine()->RunAfter(report_interval_, [this]() {
     ApplicationCallbackExecCtx callback_exec_ctx;
     ExecCtx exec_ctx;
@@ -1354,6 +1361,10 @@ void XdsClient::ChannelState::LrsCallState::MaybeStartReportingLocked() {
     return;
   }
   // Start reporting.
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    gpr_log(GPR_INFO, "[xds_client %p] xds server %s: creating load reporter",
+            xds_client(), chand()->server_.server_uri().c_str());
+  }
   reporter_ = MakeOrphanable<Reporter>(
       Ref(DEBUG_LOCATION, "LRS+load_report+start"), load_reporting_interval_);
 }
@@ -1480,6 +1491,7 @@ XdsClient::XdsClient(
       xds_federation_enabled_(XdsFederationEnabled()),
       api_(this, &grpc_xds_client_trace, bootstrap_->node(), &symtab_,
            std::move(user_agent_name), std::move(user_agent_version)),
+      work_serializer_(engine),
       engine_(std::move(engine)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO, "[xds_client %p] creating xds client", this);
@@ -1566,6 +1578,14 @@ void XdsClient::WatchResource(const XdsResourceType* type,
     xds_server = authority->server();
   }
   if (xds_server == nullptr) xds_server = &bootstrap_->server();
+  // Canonify the xDS server instance, so that we make sure we're using
+  // the same instance as will be used in AddClusterDropStats() and
+  // AddClusterLocalityStats().  This may yield a different result than
+  // the logic above if the same server is listed both in the authority
+  // and as the top-level server.
+  // TODO(roth): This is really ugly -- need to find a better way to
+  // index the xDS server than by address here.
+  xds_server = bootstrap_->FindXdsServer(*xds_server);
   {
     MutexLock lock(&mu_);
     MaybeRegisterResourceTypeLocked(type);
@@ -1582,12 +1602,11 @@ void XdsClient::WatchResource(const XdsResourceType* type,
                 "[xds_client %p] returning cached listener data for %s", this,
                 std::string(name).c_str());
       }
-      auto* value = type->CopyResource(resource_state.resource.get()).release();
       work_serializer_.Schedule(
-          [watcher, value]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) {
-            watcher->OnGenericResourceChanged(value);
-            delete value;
-          },
+          [watcher, value = resource_state.resource]()
+              ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) {
+                watcher->OnGenericResourceChanged(value);
+              },
           DEBUG_LOCATION);
     } else if (resource_state.meta.client_status ==
                XdsApi::ResourceMetadata::DOES_NOT_EXIST) {

data/src/core/ext/xds/xds_client.h

@@ -30,7 +30,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "upb/def.hpp"
+#include "upb/reflection/def.hpp"
 
 #include <grpc/event_engine/event_engine.h>
 
@@ -63,7 +63,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
   class ResourceWatcherInterface : public RefCounted<ResourceWatcherInterface> {
    public:
     virtual void OnGenericResourceChanged(
-        const XdsResourceType::ResourceData* resource)
+        std::shared_ptr<const XdsResourceType::ResourceData> resource)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
     virtual void OnError(absl::Status status)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
@@ -238,7 +238,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
     std::map<ResourceWatcherInterface*, RefCountedPtr<ResourceWatcherInterface>>
         watchers;
     // The latest data seen for the resource.
-    std::unique_ptr<XdsResourceType::ResourceData> resource;
+    std::shared_ptr<const XdsResourceType::ResourceData> resource;
     XdsApi::ResourceMetadata meta;
     bool ignored_deletion = false;
   };

data/src/core/ext/xds/xds_client_grpc.cc

@@ -30,6 +30,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -145,8 +146,10 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
     if (!bootstrap.ok()) return bootstrap.status();
     grpc_channel_args* xds_channel_args = args.GetPointer<grpc_channel_args>(
         GRPC_ARG_TEST_ONLY_DO_NOT_USE_IN_PROD_XDS_CLIENT_CHANNEL_ARGS);
-    return MakeRefCounted<GrpcXdsClient>(std::move(*bootstrap),
-                                         ChannelArgs::FromC(xds_channel_args));
+    auto channel_args = ChannelArgs::FromC(xds_channel_args);
+    return MakeRefCounted<GrpcXdsClient>(
+        std::move(*bootstrap), channel_args,
+        MakeOrphanable<GrpcXdsTransportFactory>(channel_args));
   }
   // Otherwise, use the global instance.
   MutexLock lock(g_mu);
@@ -165,16 +168,19 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
   auto bootstrap = GrpcXdsBootstrap::Create(*bootstrap_contents);
   if (!bootstrap.ok()) return bootstrap.status();
   // Instantiate XdsClient.
+  auto channel_args = ChannelArgs::FromC(g_channel_args);
   auto xds_client = MakeRefCounted<GrpcXdsClient>(
-      std::move(*bootstrap), ChannelArgs::FromC(g_channel_args));
+      std::move(*bootstrap), channel_args,
+      MakeOrphanable<GrpcXdsTransportFactory>(channel_args));
   g_xds_client = xds_client.get();
   return xds_client;
 }
 
-GrpcXdsClient::GrpcXdsClient(std::unique_ptr<GrpcXdsBootstrap> bootstrap,
-                             const ChannelArgs& args)
+GrpcXdsClient::GrpcXdsClient(
+    std::unique_ptr<GrpcXdsBootstrap> bootstrap, const ChannelArgs& args,
+    OrphanablePtr<XdsTransportFactory> transport_factory)
     : XdsClient(
-          std::move(bootstrap), MakeOrphanable<GrpcXdsTransportFactory>(args),
+          std::move(bootstrap), std::move(transport_factory),
           grpc_event_engine::experimental::GetDefaultEventEngine(),
           absl::StrCat("gRPC C-core ", GPR_PLATFORM_STRING,
                        GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING),

data/src/core/ext/xds/xds_client_grpc.h

@@ -29,11 +29,13 @@
 #include "src/core/ext/xds/certificate_provider_store.h"
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_transport.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/resolver/server_address.h"
 
 namespace grpc_core {
 
@@ -44,13 +46,25 @@ class GrpcXdsClient : public XdsClient {
       const ChannelArgs& args, const char* reason);
 
   // Do not instantiate directly -- use GetOrCreate() instead.
+  // TODO(roth): The transport factory is injectable here to support
+  // tests that want to use a fake transport factory with code that
+  // expects a GrpcXdsClient instead of an XdsClient, typically because
+  // it needs to call the interested_parties() method.  Once we
+  // finish the EventEngine migration and remove the interested_parties()
+  // method, consider instead changing callers to an approach where the
+  // production code uses XdsClient instead of GrpcXdsClient, and then
+  // passing in a fake XdsClient impl in the tests.  Note that this will
+  // work for callers that use interested_parties() but not for callers
+  // that also use certificate_provider_store(), but we should consider
+  // alternatives for that case as well.
   GrpcXdsClient(std::unique_ptr<GrpcXdsBootstrap> bootstrap,
-                const ChannelArgs& args);
+                const ChannelArgs& args,
+                OrphanablePtr<XdsTransportFactory> transport_factory);
   ~GrpcXdsClient() override;
 
   // Helpers for encoding the XdsClient object in channel args.
   static absl::string_view ChannelArgName() {
-    return "grpc.internal.xds_client";
+    return GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_client";
   }
   static int ChannelArgsCompare(const XdsClient* a, const XdsClient* b) {
     return QsortCompare(a, b);

data/src/core/ext/xds/xds_client_stats.h

@@ -38,6 +38,7 @@
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/resolver/server_address.h"
 
 namespace grpc_core {
 
@@ -95,6 +96,15 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
     return human_readable_string_;
   }
 
+  // Channel args traits.
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_locality_name";
+  }
+  static int ChannelArgsCompare(const XdsLocalityName* a,
+                                const XdsLocalityName* b) {
+    return a->Compare(*b);
+  }
+
  private:
   std::string region_;
   std::string zone_;
@@ -239,7 +249,7 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
   absl::string_view cluster_name_;
   absl::string_view eds_service_name_;
   RefCountedPtr<XdsLocalityName> name_;
-  PerCpu<Stats> stats_{32};
+  PerCpu<Stats> stats_{PerCpuOptions().SetMaxShards(32).SetCpusPerShard(4)};
 };
 
 }  // namespace grpc_core

data/src/core/ext/xds/xds_cluster.cc

@@ -20,10 +20,13 @@
 
 #include <stddef.h>
 
+#include <algorithm>
+#include <memory>
 #include <utility>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/strip.h"
@@ -43,9 +46,10 @@
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "upb/text_encode.h"
-#include "upb/upb.h"
+#include "upb/base/string_view.h"
+#include "upb/text/encode.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/xds/upb_utils.h"
@@ -55,36 +59,17 @@
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/json/json_writer.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/core/lib/matchers/matchers.h"
 
 namespace grpc_core {
 
-// TODO(roth): Remove once custom LB policy support is no longer experimental.
-bool XdsCustomLbPolicyEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_CUSTOM_LB_CONFIG");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
-// TODO(eostroukhov): Remove once this feature is no longer experimental.
-bool XdsOverrideHostEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_ENABLE_OVERRIDE_HOST");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 //
 // XdsClusterResource
 //
@@ -110,8 +95,8 @@ std::string XdsClusterResource::ToString() const {
             "prioritized_cluster_names=[",
             absl::StrJoin(aggregate.prioritized_cluster_names, ", "), "]"));
       });
-  contents.push_back(
-      absl::StrCat("lb_policy_config=", Json{lb_policy_config}.Dump()));
+  contents.push_back(absl::StrCat("lb_policy_config=",
+                                  JsonDump(Json::FromArray(lb_policy_config))));
   if (lrs_load_reporting_server.has_value()) {
     contents.push_back(absl::StrCat("lrs_load_reporting_server_name=",
                                     lrs_load_reporting_server->server_uri()));
@@ -194,23 +179,32 @@ XdsClusterResource::Eds EdsConfigParse(
   if (eds_cluster_config == nullptr) {
     errors->AddError("field not present");
   } else {
-    ValidationErrors::ScopedField field(errors, ".eds_config");
-    const envoy_config_core_v3_ConfigSource* eds_config =
-        envoy_config_cluster_v3_Cluster_EdsClusterConfig_eds_config(
-            eds_cluster_config);
-    if (eds_config == nullptr) {
-      errors->AddError("field not present");
-    } else {
-      if (!envoy_config_core_v3_ConfigSource_has_ads(eds_config) &&
-          !envoy_config_core_v3_ConfigSource_has_self(eds_config)) {
-        errors->AddError("ConfigSource is not ads or self");
-      }
-      // Record EDS service_name (if any).
-      upb_StringView service_name =
-          envoy_config_cluster_v3_Cluster_EdsClusterConfig_service_name(
+    // Validate ConfigSource.
+    {
+      ValidationErrors::ScopedField field(errors, ".eds_config");
+      const envoy_config_core_v3_ConfigSource* eds_config =
+          envoy_config_cluster_v3_Cluster_EdsClusterConfig_eds_config(
               eds_cluster_config);
-      if (service_name.size != 0) {
-        eds.eds_service_name = UpbStringToStdString(service_name);
+      if (eds_config == nullptr) {
+        errors->AddError("field not present");
+      } else {
+        if (!envoy_config_core_v3_ConfigSource_has_ads(eds_config) &&
+            !envoy_config_core_v3_ConfigSource_has_self(eds_config)) {
+          errors->AddError("ConfigSource is not ads or self");
+        }
+      }
+    }
+    // Record EDS service_name (if any).
+    // This field is required if the CDS resource has an xdstp name.
+    eds.eds_service_name = UpbStringToStdString(
+        envoy_config_cluster_v3_Cluster_EdsClusterConfig_service_name(
+            eds_cluster_config));
+    if (eds.eds_service_name.empty()) {
+      absl::string_view cluster_name =
+          UpbStringToAbsl(envoy_config_cluster_v3_Cluster_name(cluster));
+      if (absl::StartsWith(cluster_name, "xdstp:")) {
+        ValidationErrors::ScopedField field(errors, ".service_name");
+        errors->AddError("must be set if Cluster resource has an xdstp name");
       }
     }
   }
@@ -322,45 +316,42 @@ void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
                          XdsClusterResource* cds_update,
                          ValidationErrors* errors) {
   // First, check the new load_balancing_policy field.
-  if (XdsCustomLbPolicyEnabled()) {
-    const auto* load_balancing_policy =
-        envoy_config_cluster_v3_Cluster_load_balancing_policy(cluster);
-    if (load_balancing_policy != nullptr) {
-      const auto& registry =
-          static_cast<const GrpcXdsBootstrap&>(context.client->bootstrap())
-              .lb_policy_registry();
-      ValidationErrors::ScopedField field(errors, ".load_balancing_policy");
-      const size_t original_error_count = errors->size();
-      cds_update->lb_policy_config = registry.ConvertXdsLbPolicyConfig(
-          context, load_balancing_policy, errors);
-      // If there were no conversion errors, validate that the converted config
-      // parses with the gRPC LB policy registry.
-      if (original_error_count == errors->size()) {
-        auto config =
-            CoreConfiguration::Get()
-                .lb_policy_registry()
-                .ParseLoadBalancingConfig(cds_update->lb_policy_config);
-        if (!config.ok()) errors->AddError(config.status().message());
-      }
-      return;
+  const auto* load_balancing_policy =
+      envoy_config_cluster_v3_Cluster_load_balancing_policy(cluster);
+  if (load_balancing_policy != nullptr) {
+    const auto& registry =
+        static_cast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+            .lb_policy_registry();
+    ValidationErrors::ScopedField field(errors, ".load_balancing_policy");
+    const size_t original_error_count = errors->size();
+    cds_update->lb_policy_config = registry.ConvertXdsLbPolicyConfig(
+        context, load_balancing_policy, errors);
+    // If there were no conversion errors, validate that the converted config
+    // parses with the gRPC LB policy registry.
+    if (original_error_count == errors->size()) {
+      auto config = CoreConfiguration::Get()
+                        .lb_policy_registry()
+                        .ParseLoadBalancingConfig(
+                            Json::FromArray(cds_update->lb_policy_config));
+      if (!config.ok()) errors->AddError(config.status().message());
     }
+    return;
   }
   // Didn't find load_balancing_policy field, so fall back to the old
   // lb_policy enum field.
   if (envoy_config_cluster_v3_Cluster_lb_policy(cluster) ==
       envoy_config_cluster_v3_Cluster_ROUND_ROBIN) {
     cds_update->lb_policy_config = {
-        Json::Object{
+        Json::FromObject({
             {"xds_wrr_locality_experimental",
-             Json::Object{
-                 {"childPolicy",
-                  Json::Array{
-                      Json::Object{
-                          {"round_robin", Json::Object()},
-                      },
-                  }},
-             }},
-        },
+             Json::FromObject({
+                 {"childPolicy", Json::FromArray({
+                                     Json::FromObject({
+                                         {"round_robin", Json::FromObject({})},
+                                     }),
+                                 })},
+             })},
+        }),
     };
   } else if (envoy_config_cluster_v3_Cluster_lb_policy(cluster) ==
              envoy_config_cluster_v3_Cluster_RING_HASH) {
@@ -402,13 +393,13 @@ void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
       }
     }
     cds_update->lb_policy_config = {
-        Json::Object{
+        Json::FromObject({
             {"ring_hash_experimental",
-             Json::Object{
-                 {"minRingSize", min_ring_size},
-                 {"maxRingSize", max_ring_size},
-             }},
-        },
+             Json::FromObject({
+                 {"minRingSize", Json::FromNumber(min_ring_size)},
+                 {"maxRingSize", Json::FromNumber(max_ring_size)},
+             })},
+        }),
     };
   } else {
     ValidationErrors::ScopedField field(errors, ".lb_policy");
@@ -416,18 +407,18 @@ void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
   }
 }
 
-absl::StatusOr<XdsClusterResource> CdsResourceParse(
+absl::StatusOr<std::shared_ptr<const XdsClusterResource>> CdsResourceParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_cluster_v3_Cluster* cluster) {
-  XdsClusterResource cds_update;
+  auto cds_update = std::make_shared<XdsClusterResource>();
   ValidationErrors errors;
   // Check the cluster discovery type.
   if (envoy_config_cluster_v3_Cluster_type(cluster) ==
       envoy_config_cluster_v3_Cluster_EDS) {
-    cds_update.type = EdsConfigParse(cluster, &errors);
+    cds_update->type = EdsConfigParse(cluster, &errors);
   } else if (envoy_config_cluster_v3_Cluster_type(cluster) ==
              envoy_config_cluster_v3_Cluster_LOGICAL_DNS) {
-    cds_update.type = LogicalDnsParse(cluster, &errors);
+    cds_update->type = LogicalDnsParse(cluster, &errors);
   } else if (envoy_config_cluster_v3_Cluster_has_cluster_type(cluster)) {
     ValidationErrors::ScopedField field(&errors, ".cluster_type");
     const auto* custom_cluster_type =
@@ -454,7 +445,7 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
             ".value[envoy.extensions.clusters.aggregate.v3.ClusterConfig]");
         absl::string_view serialized_config =
             UpbStringToAbsl(google_protobuf_Any_value(typed_config));
-        cds_update.type =
+        cds_update->type =
             AggregateClusterParse(context, serialized_config, &errors);
       }
     }
@@ -463,13 +454,13 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
     errors.AddError("unknown discovery type");
   }
   // Check the LB policy.
-  ParseLbPolicyConfig(context, cluster, &cds_update, &errors);
+  ParseLbPolicyConfig(context, cluster, cds_update.get(), &errors);
   // transport_socket
   auto* transport_socket =
       envoy_config_cluster_v3_Cluster_transport_socket(cluster);
   if (transport_socket != nullptr) {
     ValidationErrors::ScopedField field(&errors, ".transport_socket");
-    cds_update.common_tls_context =
+    cds_update->common_tls_context =
         UpstreamTlsContextParse(context, transport_socket, &errors);
   }
   // Record LRS server name (if any).
@@ -480,7 +471,7 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
       ValidationErrors::ScopedField field(&errors, ".lrs_server");
       errors.AddError("ConfigSource is not self");
     }
-    cds_update.lrs_load_reporting_server.emplace(
+    cds_update->lrs_load_reporting_server.emplace(
         static_cast<const GrpcXdsBootstrap::GrpcXdsServer&>(context.server));
   }
   // The Cluster resource encodes the circuit breaking parameters in a list of
@@ -502,7 +493,7 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
             envoy_config_cluster_v3_CircuitBreakers_Thresholds_max_requests(
                 threshold);
         if (max_requests != nullptr) {
-          cds_update.max_concurrent_requests =
+          cds_update->max_concurrent_requests =
               google_protobuf_UInt32Value_value(max_requests);
         }
         break;
@@ -629,33 +620,34 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
             failure_percentage_ejection;
       }
     }
-    cds_update.outlier_detection = outlier_detection_update;
+    cds_update->outlier_detection = outlier_detection_update;
   }
   // Validate override host status.
-  if (XdsOverrideHostEnabled()) {
-    const auto* common_lb_config =
-        envoy_config_cluster_v3_Cluster_common_lb_config(cluster);
-    if (common_lb_config != nullptr) {
-      ValidationErrors::ScopedField field(&errors, ".common_lb_config");
-      const auto* override_host_status =
-          envoy_config_cluster_v3_Cluster_CommonLbConfig_override_host_status(
-              common_lb_config);
-      if (override_host_status != nullptr) {
-        ValidationErrors::ScopedField field(&errors, ".override_host_status");
-        size_t size;
-        const int32_t* statuses = envoy_config_core_v3_HealthStatusSet_statuses(
-            override_host_status, &size);
-        for (size_t i = 0; i < size; ++i) {
-          auto status = XdsHealthStatus::FromUpb(statuses[i]);
-          if (status.has_value()) {
-            cds_update.override_host_statuses.insert(*status);
-          }
+  const auto* common_lb_config =
+      envoy_config_cluster_v3_Cluster_common_lb_config(cluster);
+  if (common_lb_config != nullptr) {
+    ValidationErrors::ScopedField field(&errors, ".common_lb_config");
+    const auto* override_host_status =
+        envoy_config_cluster_v3_Cluster_CommonLbConfig_override_host_status(
+            common_lb_config);
+    if (override_host_status != nullptr) {
+      ValidationErrors::ScopedField field(&errors, ".override_host_status");
+      size_t size;
+      const int32_t* statuses = envoy_config_core_v3_HealthStatusSet_statuses(
+          override_host_status, &size);
+      for (size_t i = 0; i < size; ++i) {
+        auto status = XdsHealthStatus::FromUpb(statuses[i]);
+        if (status.has_value()) {
+          cds_update->override_host_statuses.insert(*status);
         }
       }
     }
   }
   // Return result.
-  if (!errors.ok()) return errors.status("errors validating Cluster resource");
+  if (!errors.ok()) {
+    return errors.status(absl::StatusCode::kInvalidArgument,
+                         "errors validating Cluster resource");
+  }
   return cds_update;
 }
 
@@ -700,10 +692,9 @@ XdsResourceType::DecodeResult XdsClusterResourceType::Decode(
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed Cluster %s: %s", context.client,
-              result.name->c_str(), cds_resource->ToString().c_str());
+              result.name->c_str(), (*cds_resource)->ToString().c_str());
     }
-    result.resource =
-        std::make_unique<XdsClusterResource>(std::move(*cds_resource));
+    result.resource = std::move(*cds_resource);
   }
   return result;
 }

data/src/core/ext/xds/xds_cluster.h

@@ -21,8 +21,6 @@
 
 #include <stdint.h>
 
-#include <algorithm>
-#include <memory>
 #include <set>
 #include <string>
 #include <vector>
@@ -33,7 +31,7 @@
 #include "envoy/config/cluster/v3/cluster.upbdefs.h"
 #include "envoy/extensions/clusters/aggregate/v3/cluster.upbdefs.h"
 #include "envoy/extensions/transport_sockets/tls/v3/tls.upbdefs.h"
-#include "upb/def.h"
+#include "upb/reflection/def.h"
 
 #include "src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
@@ -47,9 +45,6 @@
 
 namespace grpc_core {
 
-bool XdsCustomLbPolicyEnabled();
-bool XdsOverrideHostEnabled();
-
 struct XdsClusterResource : public XdsResourceType::ResourceData {
   struct Eds {
     // If empty, defaults to the cluster name.