grpc 1.44.0.pre2 → 1.46.3

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) {
@@ -484,10 +563,10 @@ template <typename ParentType, typename EntryType>
 grpc_error_handle ParseTypedPerFilterConfig(
     const XdsEncodingContext& context, const ParentType* parent,
     const EntryType* (*entry_func)(const ParentType*, size_t*),
-    upb_strview (*key_func)(const EntryType*),
+    upb_StringView (*key_func)(const EntryType*),
     const google_protobuf_Any* (*value_func)(const EntryType*),
     XdsRouteConfigResource::TypedPerFilterConfig* typed_per_filter_config) {
-  size_t filter_it = UPB_MAP_BEGIN;
+  size_t filter_it = kUpb_Map_Begin;
   while (true) {
     const auto* filter_entry = entry_func(parent, &filter_it);
     if (filter_entry == nullptr) break;
@@ -506,7 +585,7 @@ grpc_error_handle ParseTypedPerFilterConfig(
     bool is_optional = false;
     if (filter_type ==
         "type.googleapis.com/envoy.config.route.v3.FilterConfig") {
-      upb_strview any_value = google_protobuf_Any_value(any);
+      upb_StringView any_value = google_protobuf_Any_value(any);
       const auto* filter_config = envoy_config_route_v3_FilterConfig_parse(
           any_value.data, any_value.size, context.arena);
       if (filter_config == nullptr) {
@@ -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);
@@ -595,29 +674,21 @@ grpc_error_handle RetryPolicyParse(
           "RouteAction RetryPolicy RetryBackoff missing base interval."));
     } else {
       retry_to_return.retry_back_off.base_interval =
-          Duration::Parse(base_interval);
+          ParseDuration(base_interval);
     }
     const google_protobuf_Duration* max_interval =
         envoy_config_route_v3_RetryPolicy_RetryBackOff_max_interval(backoff);
     Duration max;
     if (max_interval != nullptr) {
-      max = Duration::Parse(max_interval);
+      max = ParseDuration(max_interval);
     } else {
-      // if max interval is not set, it is 10x the base, if the value in nanos
-      // can yield another second, adjust the value in seconds accordingly.
-      max.seconds = retry_to_return.retry_back_off.base_interval.seconds * 10;
-      max.nanos = retry_to_return.retry_back_off.base_interval.nanos * 10;
-      if (max.nanos > 1000000000) {
-        max.seconds += max.nanos / 1000000000;
-        max.nanos = max.nanos % 1000000000;
-      }
+      // if max interval is not set, it is 10x the base.
+      max = 10 * retry_to_return.retry_back_off.base_interval;
     }
     retry_to_return.retry_back_off.max_interval = max;
   } else {
-    retry_to_return.retry_back_off.base_interval.seconds = 0;
-    retry_to_return.retry_back_off.base_interval.nanos = 25000000;
-    retry_to_return.retry_back_off.max_interval.seconds = 0;
-    retry_to_return.retry_back_off.max_interval.nanos = 250000000;
+    retry_to_return.retry_back_off.base_interval = Duration::Milliseconds(25);
+    retry_to_return.retry_back_off.max_interval = Duration::Milliseconds(250);
   }
   if (errors.empty()) {
     *retry = retry_to_return;
@@ -631,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;
@@ -690,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) {
@@ -718,7 +820,7 @@ grpc_error_handle RouteActionParse(
                 max_stream_duration);
       }
       if (duration != nullptr) {
-        route->max_stream_duration = Duration::Parse(duration);
+        route->max_stream_duration = ParseDuration(duration);
       }
     }
   }
@@ -816,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 =
@@ -827,7 +935,7 @@ grpc_error_handle XdsRouteConfigResource::Parse(
         rds_update->virtual_hosts.back();
     // Parse domains.
     size_t domain_size;
-    upb_strview const* domains = envoy_config_route_v3_VirtualHost_domains(
+    upb_StringView const* domains = envoy_config_route_v3_VirtualHost_domains(
         virtual_hosts[i], &domain_size);
     for (size_t j = 0; j < domain_size; ++j) {
       std::string domain_pattern = UpbStringToStdString(domains[j]);
@@ -870,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 =
@@ -897,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
@@ -926,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;
 }
@@ -941,10 +1070,10 @@ void MaybeLogRouteConfiguration(
     const envoy_config_route_v3_RouteConfiguration* route_config) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-    const upb_msgdef* msg_type =
+    const upb_MessageDef* msg_type =
         envoy_config_route_v3_RouteConfiguration_getmsgdef(context.symtab);
     char buf[10240];
-    upb_text_encode(route_config, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(route_config, msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] RouteConfiguration: %s", context.client,
             buf);
   }

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;
 
@@ -205,8 +207,9 @@ class XdsRouteConfigResourceType
                                       absl::string_view serialized_resource,
                                       bool /*is_v2*/) const override;
 
-  void InitUpbSymtab(upb_symtab* symtab) const override {
+  void InitUpbSymtab(upb_DefPool* symtab) const override {
     envoy_config_route_v3_RouteConfiguration_getmsgdef(symtab);
+    XdsClusterSpecifierPluginRegistry::PopulateSymtab(symtab);
   }
 };
 

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

@@ -70,7 +70,7 @@ bool DomainMatch(MatchType match_type, absl::string_view domain_pattern_in,
 
 MatchType DomainPatternMatchType(absl::string_view domain_pattern) {
   if (domain_pattern.empty()) return INVALID_MATCH;
-  if (domain_pattern.find('*') == std::string::npos) return EXACT_MATCH;
+  if (!absl::StrContains(domain_pattern, '*')) return EXACT_MATCH;
   if (domain_pattern == "*") return UNIVERSE_MATCH;
   if (domain_pattern[0] == '*') return SUFFIX_MATCH;
   if (domain_pattern[domain_pattern.size() - 1] == '*') return PREFIX_MATCH;

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

@@ -37,7 +37,8 @@
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 #include "src/core/lib/security/credentials/xds/xds_credentials.h"
-#include "src/core/lib/slice/slice_utils.h"
+#include "src/core/lib/service_config/service_config_impl.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -99,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;
 
@@ -194,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_;
@@ -232,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 {
@@ -369,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_;
@@ -397,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(); }
 
@@ -509,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(
@@ -777,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_);
@@ -786,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;
       }
     }
   }
@@ -799,7 +797,6 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::OnError(
   if (listener_watcher != nullptr) {
     listener_watcher->PendingFilterChainMatchManagerReady(this);
   }
-  GRPC_ERROR_UNREF(error);
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
@@ -1050,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()) {
@@ -1121,7 +1119,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
             "}");
         grpc_error_handle error = GRPC_ERROR_NONE;
         config_selector_route.method_config =
-            ServiceConfig::Create(result.args, json.c_str(), &error);
+            ServiceConfigImpl::Create(result.args, json.c_str(), &error);
         GPR_ASSERT(error == GRPC_ERROR_NONE);
       }
       grpc_channel_args_destroy(result.args);
@@ -1257,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;
   }