grpc 1.49.0.pre1-x86_64-linux → 1.50.0.pre1-x86_64-linux

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

@@ -45,7 +45,6 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
@@ -76,9 +75,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
   ~XdsClient() override;
 
   const XdsBootstrap& bootstrap() const {
-    // bootstrap_ is guaranteed to be non-null since XdsClient::GetOrCreate()
-    // would return a null object if bootstrap_ was null.
-    return *bootstrap_;
+    return *bootstrap_;  // ctor asserts that it is non-null
   }
 
   XdsTransportFactory* transport_factory() const {
@@ -188,8 +185,9 @@ class XdsClient : public DualRefCounted<XdsClient> {
     void MaybeStartLrsCall();
     void StopLrsCallLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
-    bool HasAdsCall() const;
-    bool HasActiveAdsCall() const;
+    // Returns non-OK if there has been an error since the last time the
+    // ADS stream saw a response.
+    const absl::Status& status() const { return status_; }
 
     void SubscribeLocked(const XdsResourceType* type,
                          const XdsResourceName& name)
@@ -200,14 +198,17 @@ class XdsClient : public DualRefCounted<XdsClient> {
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
    private:
-    void OnConnectivityStateChange(absl::Status status);
-    void OnConnectivityStateChangeLocked(absl::Status status)
+    void OnConnectivityFailure(absl::Status status);
+
+    // Enqueues error notifications to watchers.  Caller must drain
+    // XdsClient::work_serializer_ after releasing the lock.
+    void SetChannelStatusLocked(absl::Status status)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
     // The owning xds client.
     WeakRefCountedPtr<XdsClient> xds_client_;
 
-    const XdsBootstrap::XdsServer& server_;
+    const XdsBootstrap::XdsServer& server_;  // Owned by bootstrap.
 
     OrphanablePtr<XdsTransportFactory::XdsTransport> transport_;
 
@@ -220,6 +221,8 @@ class XdsClient : public DualRefCounted<XdsClient> {
     // Stores the most recent accepted resource version for each resource type.
     std::map<const XdsResourceType*, std::string /*version*/>
         resource_type_version_map_;
+
+    absl::Status status_;
   };
 
   struct ResourceState {
@@ -248,7 +251,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
     std::map<RefCountedPtr<XdsLocalityName>, LocalityState,
              XdsLocalityName::Less>
         locality_stats;
-    Timestamp last_report_time = ExecCtx::Get()->Now();
+    Timestamp last_report_time = Timestamp::Now();
   };
 
   // Load report data.
@@ -261,9 +264,6 @@ class XdsClient : public DualRefCounted<XdsClient> {
     LoadReportMap load_report_map;
   };
 
-  // Sends an error notification to all watchers.
-  void NotifyOnErrorLocked(absl::Status status)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   // Sends an error notification to a specific set of watchers.
   void NotifyWatchersOnErrorLocked(
       const std::map<ResourceWatcherInterface*,
@@ -311,14 +311,16 @@ class XdsClient : public DualRefCounted<XdsClient> {
       v2_resource_types_ ABSL_GUARDED_BY(mu_);
   upb::SymbolTable symtab_ ABSL_GUARDED_BY(mu_);
 
-  //  Map of existing xDS server channels.
-  std::map<XdsBootstrap::XdsServer, ChannelState*> xds_server_channel_map_
-      ABSL_GUARDED_BY(mu_);
+  // Map of existing xDS server channels.
+  // Key is owned by the bootstrap config.
+  std::map<const XdsBootstrap::XdsServer*, ChannelState*>
+      xds_server_channel_map_ ABSL_GUARDED_BY(mu_);
 
   std::map<std::string /*authority*/, AuthorityState> authority_state_map_
       ABSL_GUARDED_BY(mu_);
 
-  std::map<XdsBootstrap::XdsServer, LoadReportServer>
+  // Key is owned by the bootstrap config.
+  std::map<const XdsBootstrap::XdsServer*, LoadReportServer>
       xds_load_report_server_map_ ABSL_GUARDED_BY(mu_);
 
   // Stores started watchers whose resource name was not parsed successfully,

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

@@ -19,18 +19,12 @@
 #include "src/core/ext/xds/xds_client_grpc.h"
 
 #include <algorithm>
-#include <map>
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -40,9 +34,8 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/xds/certificate_provider_factory.h"
-#include "src/core/ext/xds/certificate_provider_registry.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
+#include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
 #include "src/core/ext/xds/xds_http_filters.h"
@@ -50,9 +43,8 @@
 #include "src/core/ext/xds/xds_transport_grpc.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -60,7 +52,6 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/load_file.h"
-#include "src/core/lib/json/json.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -101,31 +92,31 @@ namespace {
 
 absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
   // First, try GRPC_XDS_BOOTSTRAP env var.
-  UniquePtr<char> path(gpr_getenv("GRPC_XDS_BOOTSTRAP"));
-  if (path != nullptr) {
+  auto path = GetEnv("GRPC_XDS_BOOTSTRAP");
+  if (path.has_value()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
       gpr_log(GPR_INFO,
               "Got bootstrap file location from GRPC_XDS_BOOTSTRAP "
               "environment variable: %s",
-              path.get());
+              path->c_str());
     }
     grpc_slice contents;
     grpc_error_handle error =
-        grpc_load_file(path.get(), /*add_null_terminator=*/true, &contents);
+        grpc_load_file(path->c_str(), /*add_null_terminator=*/true, &contents);
     if (!GRPC_ERROR_IS_NONE(error)) return grpc_error_to_absl_status(error);
     std::string contents_str(StringViewFromSlice(contents));
     grpc_slice_unref_internal(contents);
     return contents_str;
   }
   // Next, try GRPC_XDS_BOOTSTRAP_CONFIG env var.
-  UniquePtr<char> env_config(gpr_getenv("GRPC_XDS_BOOTSTRAP_CONFIG"));
-  if (env_config != nullptr) {
+  auto env_config = GetEnv("GRPC_XDS_BOOTSTRAP_CONFIG");
+  if (env_config.has_value()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
       gpr_log(GPR_INFO,
               "Got bootstrap contents from GRPC_XDS_BOOTSTRAP_CONFIG "
               "environment variable");
     }
-    return env_config.get();
+    return std::move(*env_config);
   }
   // Finally, try fallback config.
   if (fallback_config != nullptr) {
@@ -144,21 +135,16 @@ absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
 
 absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
     const ChannelArgs& args, const char* reason) {
-  // Construct certificate provider plugin map.
-  auto certificate_provider_plugin_map =
-      absl::make_unique<GrpcXdsCertificateProviderPluginMap>();
   // If getting bootstrap from channel args, create a local XdsClient
   // instance for the channel or server instead of using the global instance.
   absl::optional<absl::string_view> bootstrap_config = args.GetString(
       GRPC_ARG_TEST_ONLY_DO_NOT_USE_IN_PROD_XDS_BOOTSTRAP_CONFIG);
   if (bootstrap_config.has_value()) {
-    grpc_error_handle error = GRPC_ERROR_NONE;
-    std::unique_ptr<XdsBootstrap> bootstrap = XdsBootstrap::Create(
-        *bootstrap_config, std::move(certificate_provider_plugin_map), &error);
-    if (!GRPC_ERROR_IS_NONE(error)) return grpc_error_to_absl_status(error);
+    auto bootstrap = GrpcXdsBootstrap::Create(*bootstrap_config);
+    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),
+    return MakeRefCounted<GrpcXdsClient>(std::move(*bootstrap),
                                          ChannelArgs::FromC(xds_channel_args));
   }
   // Otherwise, use the global instance.
@@ -175,18 +161,16 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
             bootstrap_contents->c_str());
   }
   // Parse bootstrap.
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  std::unique_ptr<XdsBootstrap> bootstrap = XdsBootstrap::Create(
-      *bootstrap_contents, std::move(certificate_provider_plugin_map), &error);
-  if (!GRPC_ERROR_IS_NONE(error)) return grpc_error_to_absl_status(error);
+  auto bootstrap = GrpcXdsBootstrap::Create(*bootstrap_contents);
+  if (!bootstrap.ok()) return bootstrap.status();
   // Instantiate XdsClient.
   auto xds_client = MakeRefCounted<GrpcXdsClient>(
-      std::move(bootstrap), ChannelArgs::FromC(g_channel_args));
+      std::move(*bootstrap), ChannelArgs::FromC(g_channel_args));
   g_xds_client = xds_client.get();
   return xds_client;
 }
 
-GrpcXdsClient::GrpcXdsClient(std::unique_ptr<XdsBootstrap> bootstrap,
+GrpcXdsClient::GrpcXdsClient(std::unique_ptr<GrpcXdsBootstrap> bootstrap,
                              const ChannelArgs& args)
     : XdsClient(
           std::move(bootstrap), MakeOrphanable<GrpcXdsTransportFactory>(args),
@@ -195,9 +179,8 @@ GrpcXdsClient::GrpcXdsClient(std::unique_ptr<XdsBootstrap> bootstrap,
                            GRPC_ARG_XDS_RESOURCE_DOES_NOT_EXIST_TIMEOUT_MS)
                        .value_or(Duration::Seconds(15)))),
       certificate_provider_store_(MakeOrphanable<CertificateProviderStore>(
-          static_cast<const GrpcXdsCertificateProviderPluginMap*>(
-              this->bootstrap().certificate_provider_plugin_map())
-              ->plugin_map())) {}
+          static_cast<const GrpcXdsBootstrap&>(this->bootstrap())
+              .certificate_providers())) {}
 
 GrpcXdsClient::~GrpcXdsClient() {
   MutexLock lock(g_mu);
@@ -229,51 +212,6 @@ void SetXdsFallbackBootstrapConfig(const char* config) {
 
 }  // namespace internal
 
-//
-// GrpcXdsCertificateProviderPluginMap
-//
-
-absl::Status GrpcXdsCertificateProviderPluginMap::AddPlugin(
-    const std::string& instance_name, const std::string& plugin_name,
-    const Json& config) {
-  CertificateProviderFactory* factory =
-      CertificateProviderRegistry::LookupCertificateProviderFactory(
-          plugin_name);
-  if (factory == nullptr) {
-    return absl::InvalidArgumentError(
-        absl::StrCat("Unrecognized plugin name: ", plugin_name));
-  }
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  auto parsed_config = factory->CreateCertificateProviderConfig(config, &error);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    absl::Status status = grpc_error_to_absl_status(error);
-    GRPC_ERROR_UNREF(error);
-    return status;
-  }
-  plugin_map_.insert({instance_name, {plugin_name, std::move(parsed_config)}});
-  return absl::OkStatus();
-}
-
-bool GrpcXdsCertificateProviderPluginMap::HasPlugin(
-    const std::string& instance_name) const {
-  return plugin_map_.find(instance_name) != plugin_map_.end();
-}
-
-std::string GrpcXdsCertificateProviderPluginMap::ToString() const {
-  std::vector<std::string> parts = {"{\n"};
-  for (const auto& entry : plugin_map_) {
-    parts.push_back(
-        absl::StrFormat("  %s={\n"
-                        "    plugin_name=%s\n"
-                        "    config=%s\n"
-                        "  },\n",
-                        entry.first, entry.second.plugin_name,
-                        entry.second.config->ToString()));
-  }
-  parts.push_back("}");
-  return absl::StrJoin(parts, "");
-}
-
 }  // namespace grpc_core
 
 // The returned bytes may contain NULL(0), so we can't use c-string.

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

@@ -20,23 +20,20 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
-#include <string>
 
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/ext/xds/certificate_provider_store.h"
-#include "src/core/ext/xds/xds_bootstrap.h"
+#include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.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/json/json.h"
 
 namespace grpc_core {
 
@@ -47,7 +44,7 @@ class GrpcXdsClient : public XdsClient {
       const ChannelArgs& args, const char* reason);
 
   // Do not instantiate directly -- use GetOrCreate() instead.
-  GrpcXdsClient(std::unique_ptr<XdsBootstrap> bootstrap,
+  GrpcXdsClient(std::unique_ptr<GrpcXdsBootstrap> bootstrap,
                 const ChannelArgs& args);
   ~GrpcXdsClient() override;
 
@@ -77,26 +74,6 @@ void UnsetGlobalXdsClientForTest();
 void SetXdsFallbackBootstrapConfig(const char* config);
 }  // namespace internal
 
-// Exposed for testing purposes only.
-class GrpcXdsCertificateProviderPluginMap
-    : public XdsCertificateProviderPluginMapInterface {
- public:
-  const CertificateProviderStore::PluginDefinitionMap& plugin_map() const {
-    return plugin_map_;
-  }
-
-  absl::Status AddPlugin(const std::string& instance_name,
-                         const std::string& plugin_name,
-                         const Json& config) override;
-
-  bool HasPlugin(const std::string& instance_name) const override;
-
-  std::string ToString() const override;
-
- private:
-  CertificateProviderStore::PluginDefinitionMap plugin_map_;
-};
-
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_EXT_XDS_XDS_CLIENT_GRPC_H

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

@@ -53,7 +53,7 @@ XdsClusterDropStats::XdsClusterDropStats(
       eds_service_name_(eds_service_name) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO, "[xds_client %p] created drop stats %p for {%s, %s, %s}",
-            xds_client_.get(), this, lrs_server_.server_uri.c_str(),
+            xds_client_.get(), this, lrs_server_.server_uri().c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str());
   }
@@ -63,7 +63,7 @@ XdsClusterDropStats::~XdsClusterDropStats() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] destroying drop stats %p for {%s, %s, %s}",
-            xds_client_.get(), this, lrs_server_.server_uri.c_str(),
+            xds_client_.get(), this, lrs_server_.server_uri().c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str());
   }
@@ -108,7 +108,7 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] created locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, lrs_server_.server_uri.c_str(),
+            xds_client_.get(), this, lrs_server_.server_uri().c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str(),
             name_->AsHumanReadableString().c_str());
@@ -119,7 +119,7 @@ XdsClusterLocalityStats::~XdsClusterLocalityStats() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] destroying locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, lrs_server_.server_uri.c_str(),
+            xds_client_.get(), this, lrs_server_.server_uri().c_str(),
             std::string(cluster_name_).c_str(),
             std::string(eds_service_name_).c_str(),
             name_->AsHumanReadableString().c_str());

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

@@ -24,9 +24,10 @@
 
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/strip.h"
 #include "envoy/config/cluster/v3/circuit_breaker.upb.h"
 #include "envoy/config/cluster/v3/cluster.upb.h"
 #include "envoy/config/cluster/v3/cluster.upbdefs.h"
@@ -65,27 +66,26 @@ std::string XdsClusterResource::ToString() const {
     case EDS:
       contents.push_back("cluster_type=EDS");
       if (!eds_service_name.empty()) {
-        contents.push_back(
-            absl::StrFormat("eds_service_name=%s", eds_service_name));
+        contents.push_back(absl::StrCat("eds_service_name=", eds_service_name));
       }
       break;
     case LOGICAL_DNS:
       contents.push_back("cluster_type=LOGICAL_DNS");
-      contents.push_back(absl::StrFormat("dns_hostname=%s", dns_hostname));
+      contents.push_back(absl::StrCat("dns_hostname=", dns_hostname));
       break;
     case AGGREGATE:
       contents.push_back("cluster_type=AGGREGATE");
       contents.push_back(
-          absl::StrFormat("prioritized_cluster_names=[%s]",
-                          absl::StrJoin(prioritized_cluster_names, ", ")));
+          absl::StrCat("prioritized_cluster_names=[",
+                       absl::StrJoin(prioritized_cluster_names, ", "), "]"));
   }
   if (!common_tls_context.Empty()) {
-    contents.push_back(absl::StrFormat("common_tls_context=%s",
-                                       common_tls_context.ToString()));
+    contents.push_back(
+        absl::StrCat("common_tls_context=", common_tls_context.ToString()));
   }
   if (lrs_load_reporting_server.has_value()) {
-    contents.push_back(absl::StrFormat("lrs_load_reporting_server_name=%s",
-                                       lrs_load_reporting_server->server_uri));
+    contents.push_back(absl::StrCat("lrs_load_reporting_server_name=",
+                                    lrs_load_reporting_server->server_uri()));
   }
   contents.push_back(absl::StrCat("lb_policy=", lb_policy));
   if (lb_policy == "RING_HASH") {
@@ -93,7 +93,7 @@ std::string XdsClusterResource::ToString() const {
     contents.push_back(absl::StrCat("max_ring_size=", max_ring_size));
   }
   contents.push_back(
-      absl::StrFormat("max_concurrent_requests=%d", max_concurrent_requests));
+      absl::StrCat("max_concurrent_requests=", max_concurrent_requests));
   return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
 }
 
@@ -106,39 +106,41 @@ namespace {
 absl::StatusOr<CommonTlsContext> UpstreamTlsContextParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_core_v3_TransportSocket* transport_socket) {
-  CommonTlsContext common_tls_context;
-  // Record Upstream tls context
-  absl::string_view name = UpbStringToAbsl(
-      envoy_config_core_v3_TransportSocket_name(transport_socket));
-  if (name != "envoy.transport_sockets.tls") {
-    return absl::InvalidArgumentError(
-        absl::StrCat("Unrecognized transport socket: ", name));
-  }
   auto* typed_config =
       envoy_config_core_v3_TransportSocket_typed_config(transport_socket);
-  if (typed_config != nullptr) {
-    const upb_StringView encoded_upstream_tls_context =
-        google_protobuf_Any_value(typed_config);
-    auto* upstream_tls_context =
-        envoy_extensions_transport_sockets_tls_v3_UpstreamTlsContext_parse(
-            encoded_upstream_tls_context.data,
-            encoded_upstream_tls_context.size, context.arena);
-    if (upstream_tls_context == nullptr) {
-      return absl::InvalidArgumentError("Can't decode upstream tls context.");
-    }
-    auto* common_tls_context_proto =
-        envoy_extensions_transport_sockets_tls_v3_UpstreamTlsContext_common_tls_context(
-            upstream_tls_context);
-    if (common_tls_context_proto != nullptr) {
-      auto common_context =
-          CommonTlsContext::Parse(context, common_tls_context_proto);
-      if (!common_context.ok()) {
-        return absl::InvalidArgumentError(
-            absl::StrCat("Error parsing UpstreamTlsContext: ",
-                         common_context.status().message()));
-      }
-      common_tls_context = std::move(*common_context);
+  if (typed_config == nullptr) {
+    return absl::InvalidArgumentError("transport_socket.typed_config not set");
+  }
+  absl::string_view type_url = absl::StripPrefix(
+      UpbStringToAbsl(google_protobuf_Any_type_url(typed_config)),
+      "type.googleapis.com/");
+  if (type_url !=
+      "envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext") {
+    return absl::InvalidArgumentError(
+        absl::StrCat("Unrecognized transport socket type: ", type_url));
+  }
+  const upb_StringView encoded_upstream_tls_context =
+      google_protobuf_Any_value(typed_config);
+  auto* upstream_tls_context =
+      envoy_extensions_transport_sockets_tls_v3_UpstreamTlsContext_parse(
+          encoded_upstream_tls_context.data, encoded_upstream_tls_context.size,
+          context.arena);
+  if (upstream_tls_context == nullptr) {
+    return absl::InvalidArgumentError("Can't decode upstream tls context.");
+  }
+  auto* common_tls_context_proto =
+      envoy_extensions_transport_sockets_tls_v3_UpstreamTlsContext_common_tls_context(
+          upstream_tls_context);
+  CommonTlsContext common_tls_context;
+  if (common_tls_context_proto != nullptr) {
+    auto common_context =
+        CommonTlsContext::Parse(context, common_tls_context_proto);
+    if (!common_context.ok()) {
+      return absl::InvalidArgumentError(
+          absl::StrCat("Error parsing UpstreamTlsContext: ",
+                       common_context.status().message()));
     }
+    common_tls_context = std::move(*common_context);
   }
   if (common_tls_context.certificate_validation_context
           .ca_certificate_provider_instance.instance_name.empty()) {
@@ -245,42 +247,45 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
     absl::Status status = CdsLogicalDnsParse(cluster, &cds_update);
     if (!status.ok()) errors.emplace_back(status.message());
   } else {
-    if (!envoy_config_cluster_v3_Cluster_has_cluster_type(cluster)) {
+    const auto* custom_cluster_type =
+        envoy_config_cluster_v3_Cluster_cluster_type(cluster);
+    if (custom_cluster_type == nullptr) {
       errors.push_back("DiscoveryType is not valid.");
     } else {
-      const envoy_config_cluster_v3_Cluster_CustomClusterType*
-          custom_cluster_type =
-              envoy_config_cluster_v3_Cluster_cluster_type(cluster);
-      upb_StringView type_name =
-          envoy_config_cluster_v3_Cluster_CustomClusterType_name(
+      const auto* typed_config =
+          envoy_config_cluster_v3_Cluster_CustomClusterType_typed_config(
               custom_cluster_type);
-      if (UpbStringToAbsl(type_name) != "envoy.clusters.aggregate") {
-        errors.emplace_back("DiscoveryType is not valid.");
+      if (typed_config == nullptr) {
+        errors.push_back("cluster_type.typed_config not set");
       } else {
-        cds_update.cluster_type = XdsClusterResource::ClusterType::AGGREGATE;
-        // Retrieve aggregate clusters.
-        const google_protobuf_Any* typed_config =
-            envoy_config_cluster_v3_Cluster_CustomClusterType_typed_config(
-                custom_cluster_type);
-        const upb_StringView aggregate_cluster_config_upb_stringview =
-            google_protobuf_Any_value(typed_config);
-        const envoy_extensions_clusters_aggregate_v3_ClusterConfig*
-            aggregate_cluster_config =
-                envoy_extensions_clusters_aggregate_v3_ClusterConfig_parse(
-                    aggregate_cluster_config_upb_stringview.data,
-                    aggregate_cluster_config_upb_stringview.size,
-                    context.arena);
-        if (aggregate_cluster_config == nullptr) {
-          errors.emplace_back("Can't parse aggregate cluster.");
+        absl::string_view type_url = absl::StripPrefix(
+            UpbStringToAbsl(google_protobuf_Any_type_url(typed_config)),
+            "type.googleapis.com/");
+        if (type_url !=
+            "envoy.extensions.clusters.aggregate.v3.ClusterConfig") {
+          errors.push_back(
+              absl::StrCat("unknown cluster_type extension: ", type_url));
         } else {
-          size_t size;
-          const upb_StringView* clusters =
-              envoy_extensions_clusters_aggregate_v3_ClusterConfig_clusters(
-                  aggregate_cluster_config, &size);
-          for (size_t i = 0; i < size; ++i) {
-            const upb_StringView cluster = clusters[i];
-            cds_update.prioritized_cluster_names.emplace_back(
-                UpbStringToStdString(cluster));
+          cds_update.cluster_type = XdsClusterResource::ClusterType::AGGREGATE;
+          // Retrieve aggregate clusters.
+          const upb_StringView aggregate_cluster_config_upb_stringview =
+              google_protobuf_Any_value(typed_config);
+          const auto* aggregate_cluster_config =
+              envoy_extensions_clusters_aggregate_v3_ClusterConfig_parse(
+                  aggregate_cluster_config_upb_stringview.data,
+                  aggregate_cluster_config_upb_stringview.size, context.arena);
+          if (aggregate_cluster_config == nullptr) {
+            errors.emplace_back("Can't parse aggregate cluster.");
+          } else {
+            size_t size;
+            const upb_StringView* clusters =
+                envoy_extensions_clusters_aggregate_v3_ClusterConfig_clusters(
+                    aggregate_cluster_config, &size);
+            for (size_t i = 0; i < size; ++i) {
+              const upb_StringView cluster = clusters[i];
+              cds_update.prioritized_cluster_names.emplace_back(
+                  UpbStringToStdString(cluster));
+            }
           }
         }
       }
@@ -353,7 +358,8 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
     if (!envoy_config_core_v3_ConfigSource_has_self(lrs_server)) {
       errors.emplace_back("LRS ConfigSource is not self.");
     }
-    cds_update.lrs_load_reporting_server.emplace(context.server);
+    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
   // Thresholds messages, where each message specifies the parameters for a
@@ -506,38 +512,40 @@ void MaybeLogCluster(const XdsResourceType::DecodeContext& context,
 
 }  // namespace
 
-absl::StatusOr<XdsResourceType::DecodeResult> XdsClusterResourceType::Decode(
+XdsResourceType::DecodeResult XdsClusterResourceType::Decode(
     const XdsResourceType::DecodeContext& context,
     absl::string_view serialized_resource, bool is_v2) const {
+  DecodeResult result;
   // Parse serialized proto.
   auto* resource = envoy_config_cluster_v3_Cluster_parse(
       serialized_resource.data(), serialized_resource.size(), context.arena);
   if (resource == nullptr) {
-    return absl::InvalidArgumentError("Can't parse Cluster resource.");
+    result.resource =
+        absl::InvalidArgumentError("Can't parse Cluster resource.");
+    return result;
   }
   MaybeLogCluster(context, resource);
   // Validate resource.
-  DecodeResult result;
   result.name =
       UpbStringToStdString(envoy_config_cluster_v3_Cluster_name(resource));
   auto cds_resource = CdsResourceParse(context, resource, is_v2);
   if (!cds_resource.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_ERROR, "[xds_client %p] invalid Cluster %s: %s",
-              context.client, result.name.c_str(),
+              context.client, result.name->c_str(),
               cds_resource.status().ToString().c_str());
     }
     result.resource = cds_resource.status();
   } 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());
     }
     auto resource = absl::make_unique<ResourceDataSubclass>();
     resource->resource = std::move(*cds_resource);
     result.resource = std::move(resource);
   }
-  return std::move(result);
+  return result;
 }
 
 }  // namespace grpc_core