grpc 1.45.0 → 1.46.3

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

@@ -365,23 +365,23 @@ grpc_error_handle CommonTlsContext::Parse(
                                        &errors);
 }
 
-grpc_error_handle ExtractHttpFilterTypeName(const XdsEncodingContext& context,
-                                            const google_protobuf_Any* any,
-                                            absl::string_view* filter_type) {
-  *filter_type = UpbStringToAbsl(google_protobuf_Any_type_url(any));
-  if (*filter_type == "type.googleapis.com/xds.type.v3.TypedStruct" ||
-      *filter_type == "type.googleapis.com/udpa.type.v1.TypedStruct") {
+grpc_error_handle ExtractExtensionTypeName(const XdsEncodingContext& context,
+                                           const google_protobuf_Any* any,
+                                           absl::string_view* extension_type) {
+  *extension_type = UpbStringToAbsl(google_protobuf_Any_type_url(any));
+  if (*extension_type == "type.googleapis.com/xds.type.v3.TypedStruct" ||
+      *extension_type == "type.googleapis.com/udpa.type.v1.TypedStruct") {
     upb_StringView any_value = google_protobuf_Any_value(any);
     const auto* typed_struct = xds_type_v3_TypedStruct_parse(
         any_value.data, any_value.size, context.arena);
     if (typed_struct == nullptr) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "could not parse TypedStruct from filter config");
+          "could not parse TypedStruct from extension");
     }
-    *filter_type =
+    *extension_type =
         UpbStringToAbsl(xds_type_v3_TypedStruct_type_url(typed_struct));
   }
-  *filter_type = absl::StripPrefix(*filter_type, "type.googleapis.com/");
+  *extension_type = absl::StripPrefix(*extension_type, "type.googleapis.com/");
   return GRPC_ERROR_NONE;
 }
 

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

@@ -86,9 +86,9 @@ struct CommonTlsContext {
       CommonTlsContext* common_tls_context);
 };
 
-grpc_error_handle ExtractHttpFilterTypeName(const XdsEncodingContext& context,
-                                            const google_protobuf_Any* any,
-                                            absl::string_view* filter_type);
+grpc_error_handle ExtractExtensionTypeName(const XdsEncodingContext& context,
+                                           const google_protobuf_Any* any,
+                                           absl::string_view* extension_type);
 
 }  // namespace grpc_core
 

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

@@ -202,7 +202,7 @@ grpc_error_handle LocalityParse(
   std::string region =
       UpbStringToStdString(envoy_config_core_v3_Locality_region(locality));
   std::string zone =
-      UpbStringToStdString(envoy_config_core_v3_Locality_region(locality));
+      UpbStringToStdString(envoy_config_core_v3_Locality_zone(locality));
   std::string sub_zone =
       UpbStringToStdString(envoy_config_core_v3_Locality_sub_zone(locality));
   output_locality->name = MakeRefCounted<XdsLocalityName>(
@@ -285,11 +285,18 @@ grpc_error_handle EdsResourceParse(
     if (locality.lb_weight == 0) continue;
     // Make sure prorities is big enough. Note that they might not
     // arrive in priority order.
-    while (eds_update->priorities.size() < priority + 1) {
-      eds_update->priorities.emplace_back();
+    if (eds_update->priorities.size() < priority + 1) {
+      eds_update->priorities.resize(priority + 1);
+    }
+    auto& locality_map = eds_update->priorities[priority].localities;
+    auto it = locality_map.find(locality.name.get());
+    if (it != locality_map.end()) {
+      errors.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+          "duplicate locality ", locality.name->AsHumanReadableString(),
+          " found in priority ", priority)));
+    } else {
+      locality_map.emplace(locality.name.get(), std::move(locality));
     }
-    eds_update->priorities[priority].localities.emplace(locality.name.get(),
-                                                        std::move(locality));
   }
   for (const auto& priority : eds_update->priorities) {
     if (priority.localities.empty()) {

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

@@ -198,7 +198,7 @@ XdsHttpFaultFilter::GenerateFilterConfigOverride(
 }
 
 const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {
-  return &FaultInjectionFilterVtable;
+  return &FaultInjectionFilter::kFilter;
 }
 
 grpc_channel_args* XdsHttpFaultFilter::ModifyChannelArgs(

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

@@ -332,7 +332,7 @@ grpc_error_handle HttpConnectionManagerParse(
       }
       absl::string_view filter_type;
       grpc_error_handle error =
-          ExtractHttpFilterTypeName(context, any, &filter_type);
+          ExtractExtensionTypeName(context, any, &filter_type);
       if (error != GRPC_ERROR_NONE) return error;
       const XdsHttpFilterImpl* filter_impl =
           XdsHttpFilterRegistry::GetFilterForType(filter_type);

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

@@ -23,6 +23,7 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "envoy/config/core/v3/base.upb.h"
+#include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/config/route/v3/route.upb.h"
 #include "envoy/config/route/v3/route.upbdefs.h"
 #include "envoy/config/route/v3/route_components.upb.h"
@@ -39,12 +40,14 @@
 
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_api.h"
+#include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/ext/xds/xds_routing.h"
 #include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/transport/error_utils.h"
 
 namespace grpc_core {
 
@@ -57,6 +60,15 @@ bool XdsRbacEnabled() {
   return parse_succeeded && parsed_value;
 }
 
+// TODO(donnadionne): Remove once RLS is no longer experimental
+bool XdsRlsEnabled() {
+  char* value = gpr_getenv("GRPC_EXPERIMENTAL_XDS_RLS_LB");
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value, &parsed_value);
+  gpr_free(value);
+  return parse_succeeded && parsed_value;
+}
+
 //
 // XdsRouteConfigResource::RetryPolicy
 //
@@ -212,11 +224,18 @@ std::string XdsRouteConfigResource::Route::RouteAction::ToString() const {
   if (retry_policy.has_value()) {
     contents.push_back(absl::StrCat("retry_policy=", retry_policy->ToString()));
   }
-  if (!cluster_name.empty()) {
-    contents.push_back(absl::StrFormat("Cluster name: %s", cluster_name));
-  }
-  for (const ClusterWeight& cluster_weight : weighted_clusters) {
-    contents.push_back(cluster_weight.ToString());
+  if (action.index() == kClusterIndex) {
+    contents.push_back(
+        absl::StrFormat("Cluster name: %s", absl::get<kClusterIndex>(action)));
+  } else if (action.index() == kWeightedClustersIndex) {
+    auto& action_weighted_clusters = absl::get<kWeightedClustersIndex>(action);
+    for (const ClusterWeight& cluster_weight : action_weighted_clusters) {
+      contents.push_back(cluster_weight.ToString());
+    }
+  } else if (action.index() == kClusterSpecifierPluginIndex) {
+    contents.push_back(
+        absl::StrFormat("Cluster specifier plugin name: %s",
+                        absl::get<kClusterSpecifierPluginIndex>(action)));
   }
   if (max_stream_duration.has_value()) {
     contents.push_back(max_stream_duration->ToString());
@@ -258,35 +277,95 @@ std::string XdsRouteConfigResource::Route::ToString() const {
 //
 
 std::string XdsRouteConfigResource::ToString() const {
-  std::vector<std::string> vhosts;
+  std::vector<std::string> parts;
   for (const VirtualHost& vhost : virtual_hosts) {
-    vhosts.push_back(
+    parts.push_back(
         absl::StrCat("vhost={\n"
                      "  domains=[",
                      absl::StrJoin(vhost.domains, ", "),
                      "]\n"
                      "  routes=[\n"));
     for (const XdsRouteConfigResource::Route& route : vhost.routes) {
-      vhosts.push_back("    {\n");
-      vhosts.push_back(route.ToString());
-      vhosts.push_back("\n    }\n");
+      parts.push_back("    {\n");
+      parts.push_back(route.ToString());
+      parts.push_back("\n    }\n");
     }
-    vhosts.push_back("  ]\n");
-    vhosts.push_back("  typed_per_filter_config={\n");
+    parts.push_back("  ]\n");
+    parts.push_back("  typed_per_filter_config={\n");
     for (const auto& p : vhost.typed_per_filter_config) {
       const std::string& name = p.first;
       const auto& config = p.second;
-      vhosts.push_back(
-          absl::StrCat("    ", name, "=", config.ToString(), "\n"));
+      parts.push_back(absl::StrCat("    ", name, "=", config.ToString(), "\n"));
     }
-    vhosts.push_back("  }\n");
-    vhosts.push_back("]\n");
+    parts.push_back("  }\n");
+    parts.push_back("]\n");
   }
-  return absl::StrJoin(vhosts, "");
+  parts.push_back("cluster_specifier_plugins={\n");
+  for (const auto& it : cluster_specifier_plugin_map) {
+    parts.push_back(absl::StrFormat("%s={%s}\n", it.first, it.second));
+  }
+  parts.push_back("}");
+  return absl::StrJoin(parts, "");
 }
 
 namespace {
 
+grpc_error_handle ClusterSpecifierPluginParse(
+    const XdsEncodingContext& context,
+    const envoy_config_route_v3_RouteConfiguration* route_config,
+    XdsRouteConfigResource* rds_update) {
+  size_t num_cluster_specifier_plugins;
+  const envoy_config_route_v3_ClusterSpecifierPlugin* const*
+      cluster_specifier_plugin =
+          envoy_config_route_v3_RouteConfiguration_cluster_specifier_plugins(
+              route_config, &num_cluster_specifier_plugins);
+  for (size_t i = 0; i < num_cluster_specifier_plugins; ++i) {
+    const envoy_config_core_v3_TypedExtensionConfig* extension =
+        envoy_config_route_v3_ClusterSpecifierPlugin_extension(
+            cluster_specifier_plugin[i]);
+    std::string name = UpbStringToStdString(
+        envoy_config_core_v3_TypedExtensionConfig_name(extension));
+    if (rds_update->cluster_specifier_plugin_map.find(name) !=
+        rds_update->cluster_specifier_plugin_map.end()) {
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+          "Duplicated definition of cluster_specifier_plugin ", name));
+    }
+    const google_protobuf_Any* any =
+        envoy_config_core_v3_TypedExtensionConfig_typed_config(extension);
+    if (any == nullptr) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "Could not obtrain TypedExtensionConfig for plugin config.");
+    }
+    absl::string_view plugin_type;
+    grpc_error_handle error =
+        ExtractExtensionTypeName(context, any, &plugin_type);
+    if (error != GRPC_ERROR_NONE) return error;
+    bool is_optional = envoy_config_route_v3_ClusterSpecifierPlugin_is_optional(
+        cluster_specifier_plugin[i]);
+    const XdsClusterSpecifierPluginImpl* cluster_specifier_plugin_impl =
+        XdsClusterSpecifierPluginRegistry::GetPluginForType(plugin_type);
+    std::string lb_policy_config;
+    if (cluster_specifier_plugin_impl == nullptr) {
+      if (!is_optional) {
+        return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+            absl::StrCat("Unknown ClusterSpecifierPlugin type ", plugin_type));
+      }
+      // Optional plugin, leave lb_policy_config empty.
+    } else {
+      auto config =
+          cluster_specifier_plugin_impl->GenerateLoadBalancingPolicyConfig(
+              google_protobuf_Any_value(any), context.arena, context.symtab);
+      if (!config.ok()) {
+        return absl_status_to_grpc_error(config.status());
+      }
+      lb_policy_config = std::move(*config);
+    }
+    rds_update->cluster_specifier_plugin_map[std::move(name)] =
+        std::move(lb_policy_config);
+  }
+  return GRPC_ERROR_NONE;
+}
+
 grpc_error_handle RoutePathMatchParse(
     const envoy_config_route_v3_RouteMatch* match,
     XdsRouteConfigResource::Route* route, bool* ignore_route) {
@@ -523,7 +602,7 @@ grpc_error_handle ParseTypedPerFilterConfig(
       }
     }
     grpc_error_handle error =
-        ExtractHttpFilterTypeName(context, any, &filter_type);
+        ExtractExtensionTypeName(context, any, &filter_type);
     if (error != GRPC_ERROR_NONE) return error;
     const XdsHttpFilterImpl* filter_impl =
         XdsHttpFilterRegistry::GetFilterForType(filter_type);
@@ -623,19 +702,27 @@ grpc_error_handle RetryPolicyParse(
 grpc_error_handle RouteActionParse(
     const XdsEncodingContext& context,
     const envoy_config_route_v3_Route* route_msg,
+    const std::map<std::string /*cluster_specifier_plugin_name*/,
+                   std::string /*LB policy config*/>&
+        cluster_specifier_plugin_map,
     XdsRouteConfigResource::Route::RouteAction* route, bool* ignore_route) {
   const envoy_config_route_v3_RouteAction* route_action =
       envoy_config_route_v3_Route_route(route_msg);
   // Get the cluster or weighted_clusters in the RouteAction.
   if (envoy_config_route_v3_RouteAction_has_cluster(route_action)) {
-    route->cluster_name = UpbStringToStdString(
+    std::string cluster_name = UpbStringToStdString(
         envoy_config_route_v3_RouteAction_cluster(route_action));
-    if (route->cluster_name.empty()) {
+    if (cluster_name.empty()) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "RouteAction cluster contains empty cluster name.");
     }
+    route->action
+        .emplace<XdsRouteConfigResource::Route::RouteAction::kClusterIndex>(
+            std::move(cluster_name));
   } else if (envoy_config_route_v3_RouteAction_has_weighted_clusters(
                  route_action)) {
+    std::vector<XdsRouteConfigResource::Route::RouteAction::ClusterWeight>
+        action_weighted_clusters;
     const envoy_config_route_v3_WeightedCluster* weighted_cluster =
         envoy_config_route_v3_RouteAction_weighted_clusters(route_action);
     uint32_t total_weight = 100;
@@ -682,18 +769,41 @@ grpc_error_handle RouteActionParse(
             &cluster.typed_per_filter_config);
         if (error != GRPC_ERROR_NONE) return error;
       }
-      route->weighted_clusters.emplace_back(std::move(cluster));
+      action_weighted_clusters.emplace_back(std::move(cluster));
     }
     if (total_weight != sum_of_weights) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "RouteAction weighted_cluster has incorrect total weight");
     }
-    if (route->weighted_clusters.empty()) {
+    if (action_weighted_clusters.empty()) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "RouteAction weighted_cluster has no valid clusters specified.");
     }
+    route->action = std::move(action_weighted_clusters);
+  } else if (XdsRlsEnabled() &&
+             envoy_config_route_v3_RouteAction_has_cluster_specifier_plugin(
+                 route_action)) {
+    std::string plugin_name = UpbStringToStdString(
+        envoy_config_route_v3_RouteAction_cluster_specifier_plugin(
+            route_action));
+    if (plugin_name.empty()) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "RouteAction cluster contains empty cluster specifier plugin name.");
+    }
+    auto it = cluster_specifier_plugin_map.find(plugin_name);
+    if (it == cluster_specifier_plugin_map.end()) {
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrCat("RouteAction cluster contains cluster specifier plugin "
+                       "name not configured: ",
+                       plugin_name));
+    }
+    if (it->second.empty()) *ignore_route = true;
+    route->action.emplace<XdsRouteConfigResource::Route::RouteAction::
+                              kClusterSpecifierPluginIndex>(
+        std::move(plugin_name));
   } else {
-    // No cluster or weighted_clusters found in RouteAction, ignore this route.
+    // No cluster or weighted_clusters or plugin found in RouteAction, ignore
+    // this route.
     *ignore_route = true;
   }
   if (!*ignore_route) {
@@ -808,6 +918,12 @@ grpc_error_handle XdsRouteConfigResource::Parse(
     const XdsEncodingContext& context,
     const envoy_config_route_v3_RouteConfiguration* route_config,
     XdsRouteConfigResource* rds_update) {
+  // Get the cluster spcifier plugins
+  if (XdsRlsEnabled()) {
+    grpc_error_handle error =
+        ClusterSpecifierPluginParse(context, route_config, rds_update);
+    if (error != GRPC_ERROR_NONE) return error;
+  }
   // Get the virtual hosts.
   size_t num_virtual_hosts;
   const envoy_config_route_v3_VirtualHost* const* virtual_hosts =
@@ -862,6 +978,12 @@ grpc_error_handle XdsRouteConfigResource::Parse(
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "No route found in the virtual host.");
     }
+    // Build a set of cluster_specifier_plugin configured to make sure each is
+    // actually referenced by a route action.
+    std::set<absl::string_view> cluster_specifier_plugins;
+    for (auto& plugin : rds_update->cluster_specifier_plugin_map) {
+      cluster_specifier_plugins.emplace(plugin.first);
+    }
     // Loop over the whole list of routes
     for (size_t j = 0; j < num_routes; ++j) {
       const envoy_config_route_v3_RouteMatch* match =
@@ -889,14 +1011,23 @@ grpc_error_handle XdsRouteConfigResource::Parse(
         route.action.emplace<XdsRouteConfigResource::Route::RouteAction>();
         auto& route_action =
             absl::get<XdsRouteConfigResource::Route::RouteAction>(route.action);
-        error =
-            RouteActionParse(context, routes[j], &route_action, &ignore_route);
+        error = RouteActionParse(context, routes[j],
+                                 rds_update->cluster_specifier_plugin_map,
+                                 &route_action, &ignore_route);
         if (error != GRPC_ERROR_NONE) return error;
         if (ignore_route) continue;
         if (route_action.retry_policy == absl::nullopt &&
             retry_policy != nullptr) {
           route_action.retry_policy = virtual_host_retry_policy;
         }
+        // Mark off plugins used in route action.
+        std::string* cluster_specifier_action =
+            absl::get_if<XdsRouteConfigResource::Route::RouteAction::
+                             kClusterSpecifierPluginIndex>(
+                &route_action.action);
+        if (cluster_specifier_action != nullptr) {
+          cluster_specifier_plugins.erase(*cluster_specifier_action);
+        }
       } else if (envoy_config_route_v3_Route_has_non_forwarding_action(
                      routes[j])) {
         route.action
@@ -918,6 +1049,12 @@ grpc_error_handle XdsRouteConfigResource::Parse(
     if (vhost.routes.empty()) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No valid routes specified.");
     }
+    // For plugins not used in route action, delete from the update to prevent
+    // further use.
+    for (auto& unused_plugin : cluster_specifier_plugins) {
+      rds_update->cluster_specifier_plugin_map.erase(
+          std::string(unused_plugin));
+    }
   }
   return GRPC_ERROR_NONE;
 }

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

@@ -30,6 +30,7 @@
 #include "re2/re2.h"
 
 #include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
@@ -67,8 +68,6 @@ struct XdsRouteConfigResource {
     std::string ToString() const;
   };
 
-  // TODO(donnadionne): When we can use absl::variant<>, consider using that
-  // for: PathMatcher, HeaderMatcher, cluster_name and weighted_clusters
   struct Route {
     // Matchers for this route.
     struct Matchers {
@@ -130,10 +129,11 @@ struct XdsRouteConfigResource {
       absl::optional<RetryPolicy> retry_policy;
 
       // Action for this route.
-      // 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.
-      std::string cluster_name;
-      std::vector<ClusterWeight> weighted_clusters;
+      static constexpr size_t kClusterIndex = 0;
+      static constexpr size_t kWeightedClustersIndex = 1;
+      static constexpr size_t kClusterSpecifierPluginIndex = 2;
+      absl::variant<std::string, std::vector<ClusterWeight>, std::string>
+          action;
       // Storing the timeout duration from route action:
       // RouteAction.max_stream_duration.grpc_timeout_header_max or
       // RouteAction.max_stream_duration.max_stream_duration if the former is
@@ -142,9 +142,7 @@ struct XdsRouteConfigResource {
 
       bool operator==(const RouteAction& other) const {
         return hash_policies == other.hash_policies &&
-               retry_policy == other.retry_policy &&
-               cluster_name == other.cluster_name &&
-               weighted_clusters == other.weighted_clusters &&
+               retry_policy == other.retry_policy && action == other.action &&
                max_stream_duration == other.max_stream_duration;
       }
       std::string ToString() const;
@@ -178,9 +176,13 @@ struct XdsRouteConfigResource {
   };
 
   std::vector<VirtualHost> virtual_hosts;
+  std::map<std::string /*cluster_specifier_plugin_name*/,
+           std::string /*LB policy config*/>
+      cluster_specifier_plugin_map;
 
   bool operator==(const XdsRouteConfigResource& other) const {
-    return virtual_hosts == other.virtual_hosts;
+    return virtual_hosts == other.virtual_hosts &&
+           cluster_specifier_plugin_map == other.cluster_specifier_plugin_map;
   }
   std::string ToString() const;
 
@@ -207,6 +209,7 @@ class XdsRouteConfigResourceType
 
   void InitUpbSymtab(upb_DefPool* symtab) const override {
     envoy_config_route_v3_RouteConfiguration_getmsgdef(symtab);
+    XdsClusterSpecifierPluginRegistry::PopulateSymtab(symtab);
   }
 };
 

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

@@ -100,7 +100,7 @@ class XdsServerConfigFetcher::ListenerWatcher
 
   void OnResourceChanged(XdsListenerResource listener) override;
 
-  void OnError(grpc_error_handle error) override;
+  void OnError(absl::Status status) override;
 
   void OnResourceDoesNotExist() override;
 
@@ -195,7 +195,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
   // RDS resources.
   void OnRouteConfigChanged(const std::string& resource_name,
                             XdsRouteConfigResource route_config);
-  void OnError(const std::string& resource_name, grpc_error_handle error);
+  void OnError(const std::string& resource_name, absl::Status status);
   void OnResourceDoesNotExist(const std::string& resource_name);
 
   RefCountedPtr<XdsClient> xds_client_;
@@ -233,8 +233,8 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
                                                       std::move(route_config));
   }
 
-  void OnError(grpc_error_handle error) override {
-    filter_chain_match_manager_->OnError(resource_name_, error);
+  void OnError(absl::Status status) override {
+    filter_chain_match_manager_->OnError(resource_name_, status);
   }
 
   void OnResourceDoesNotExist() override {
@@ -370,7 +370,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
   class RouteConfigWatcher;
 
   void OnRouteConfigChanged(XdsRouteConfigResource rds_update);
-  void OnError(grpc_error_handle error);
+  void OnError(absl::Status status);
   void OnResourceDoesNotExist();
 
   RefCountedPtr<XdsClient> xds_client_;
@@ -398,7 +398,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     parent_->OnRouteConfigChanged(std::move(route_config));
   }
 
-  void OnError(grpc_error_handle error) override { parent_->OnError(error); }
+  void OnError(absl::Status status) override { parent_->OnError(status); }
 
   void OnResourceDoesNotExist() override { parent_->OnResourceDoesNotExist(); }
 
@@ -510,29 +510,26 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
   }
 }
 
-void XdsServerConfigFetcher::ListenerWatcher::OnError(grpc_error_handle error) {
+void XdsServerConfigFetcher::ListenerWatcher::OnError(absl::Status status) {
   MutexLock lock(&mu_);
   if (filter_chain_match_manager_ != nullptr ||
       pending_filter_chain_match_manager_ != nullptr) {
     gpr_log(GPR_ERROR,
             "ListenerWatcher:%p XdsClient reports error: %s for %s; "
             "ignoring in favor of existing resource",
-            this, grpc_error_std_string(error).c_str(),
-            listening_address_.c_str());
+            this, status.ToString().c_str(), listening_address_.c_str());
   } else {
     if (serving_status_notifier_.on_serving_status_update != nullptr) {
       serving_status_notifier_.on_serving_status_update(
           serving_status_notifier_.user_data, listening_address_.c_str(),
-          {GRPC_STATUS_UNAVAILABLE, grpc_error_std_string(error).c_str()});
+          {GRPC_STATUS_UNAVAILABLE, status.ToString().c_str()});
     } else {
       gpr_log(GPR_ERROR,
               "ListenerWatcher:%p error obtaining xDS Listener resource: %s; "
               "not serving on %s",
-              this, grpc_error_std_string(error).c_str(),
-              listening_address_.c_str());
+              this, status.ToString().c_str(), listening_address_.c_str());
     }
   }
-  GRPC_ERROR_UNREF(error);
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::OnFatalError(
@@ -778,7 +775,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::OnError(
-    const std::string& resource_name, grpc_error_handle error) {
+    const std::string& resource_name, absl::Status status) {
   RefCountedPtr<ListenerWatcher> listener_watcher;
   {
     MutexLock lock(&mu_);
@@ -787,11 +784,11 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::OnError(
       if (--rds_resources_yet_to_fetch_ == 0) {
         listener_watcher = std::move(listener_watcher_);
       }
-      state.rds_update = grpc_error_to_absl_status(error);
+      state.rds_update = status;
     } else {
       // Prefer existing good version over current errored version
       if (!state.rds_update->ok()) {
-        state.rds_update = grpc_error_to_absl_status(error);
+        state.rds_update = status;
       }
     }
   }
@@ -800,7 +797,6 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::OnError(
   if (listener_watcher != nullptr) {
     listener_watcher->PendingFilterChainMatchManagerReady(this);
   }
-  GRPC_ERROR_UNREF(error);
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
@@ -1051,7 +1047,8 @@ absl::StatusOr<grpc_channel_args*> XdsServerConfigFetcher::ListenerWatcher::
   // Add XdsCertificateProvider if credentials are xDS.
   grpc_server_credentials* server_creds =
       grpc_find_server_credentials_in_args(args);
-  if (server_creds != nullptr && server_creds->type() == kCredentialsTypeXds) {
+  if (server_creds != nullptr &&
+      server_creds->type() == XdsServerCredentials::Type()) {
     absl::StatusOr<RefCountedPtr<XdsCertificateProvider>> result =
         CreateOrGetXdsCertificateProviderFromFilterChainData(filter_chain);
     if (!result.ok()) {
@@ -1258,15 +1255,13 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    DynamicXdsServerConfigSelectorProvider::OnError(grpc_error_handle error) {
+    DynamicXdsServerConfigSelectorProvider::OnError(absl::Status status) {
   MutexLock lock(&mu_);
   // Prefer existing good update.
   if (resource_.ok()) {
-    GRPC_ERROR_UNREF(error);
     return;
   }
-  resource_ = grpc_error_to_absl_status(error);
-  GRPC_ERROR_UNREF(error);
+  resource_ = status;
   if (watcher_ == nullptr) {
     return;
   }