grpc 1.47.0 → 1.49.0.pre1

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

@@ -16,38 +16,64 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/xds/xds_route_config.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
 #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/str_split.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.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"
-#include "envoy/config/route/v3/route_components.upbdefs.h"
 #include "envoy/type/matcher/v3/regex.upb.h"
-#include "envoy/type/matcher/v3/string.upb.h"
 #include "envoy/type/v3/percent.upb.h"
 #include "envoy/type/v3/range.upb.h"
 #include "google/protobuf/any.upb.h"
+#include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "re2/re2.h"
+#include "upb/def.h"
 #include "upb/text_encode.h"
 #include "upb/upb.h"
-#include "upb/upb.hpp"
+
+#include <grpc/status.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
 
 #include "src/core/ext/xds/upb_utils.h"
-#include "src/core/ext/xds/xds_api.h"
+#include "src/core/ext/xds/xds_bootstrap.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.h"
+#include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/ext/xds/xds_routing.h"
+#include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/match.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/matchers/matchers.h"
 
 namespace grpc_core {
 
@@ -224,19 +250,23 @@ std::string XdsRouteConfigResource::Route::RouteAction::ToString() const {
   if (retry_policy.has_value()) {
     contents.push_back(absl::StrCat("retry_policy=", retry_policy->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)));
-  }
+  Match(
+      action,
+      [&contents](const ClusterName& cluster_name) {
+        contents.push_back(
+            absl::StrFormat("Cluster name: %s", cluster_name.cluster_name));
+      },
+      [&contents](const std::vector<ClusterWeight>& weighted_clusters) {
+        for (const ClusterWeight& cluster_weight : weighted_clusters) {
+          contents.push_back(cluster_weight.ToString());
+        }
+      },
+      [&contents](
+          const ClusterSpecifierPluginName& cluster_specifier_plugin_name) {
+        contents.push_back(absl::StrFormat(
+            "Cluster specifier plugin name: %s",
+            cluster_specifier_plugin_name.cluster_specifier_plugin_name));
+      });
   if (max_stream_duration.has_value()) {
     contents.push_back(max_stream_duration->ToString());
   }
@@ -310,10 +340,12 @@ std::string XdsRouteConfigResource::ToString() const {
 
 namespace {
 
-grpc_error_handle ClusterSpecifierPluginParse(
-    const XdsEncodingContext& context,
-    const envoy_config_route_v3_RouteConfiguration* route_config,
-    XdsRouteConfigResource* rds_update) {
+absl::StatusOr<XdsRouteConfigResource::ClusterSpecifierPluginMap>
+ClusterSpecifierPluginParse(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_route_v3_RouteConfiguration* route_config) {
+  XdsRouteConfigResource::ClusterSpecifierPluginMap
+      cluster_specifier_plugin_map;
   size_t num_cluster_specifier_plugins;
   const envoy_config_route_v3_ClusterSpecifierPlugin* const*
       cluster_specifier_plugin =
@@ -325,50 +357,45 @@ grpc_error_handle ClusterSpecifierPluginParse(
             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(
+    if (cluster_specifier_plugin_map.find(name) !=
+        cluster_specifier_plugin_map.end()) {
+      return absl::InvalidArgumentError(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(
+      return absl::InvalidArgumentError(
           "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;
+    auto plugin_type = ExtractExtensionTypeName(context, any);
+    if (!plugin_type.ok()) return plugin_type.status();
     bool is_optional = envoy_config_route_v3_ClusterSpecifierPlugin_is_optional(
         cluster_specifier_plugin[i]);
     const XdsClusterSpecifierPluginImpl* cluster_specifier_plugin_impl =
-        XdsClusterSpecifierPluginRegistry::GetPluginForType(plugin_type);
+        XdsClusterSpecifierPluginRegistry::GetPluginForType(plugin_type->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));
+        return absl::InvalidArgumentError(absl::StrCat(
+            "Unknown ClusterSpecifierPlugin type ", plugin_type->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());
-      }
+      if (!config.ok()) return config.status();
       lb_policy_config = std::move(*config);
     }
-    rds_update->cluster_specifier_plugin_map[std::move(name)] =
-        std::move(lb_policy_config);
+    cluster_specifier_plugin_map[std::move(name)] = std::move(lb_policy_config);
   }
-  return GRPC_ERROR_NONE;
+  return cluster_specifier_plugin_map;
 }
 
-grpc_error_handle RoutePathMatchParse(
-    const envoy_config_route_v3_RouteMatch* match,
-    XdsRouteConfigResource::Route* route, bool* ignore_route) {
+absl::Status RoutePathMatchParse(const envoy_config_route_v3_RouteMatch* match,
+                                 XdsRouteConfigResource::Route* route,
+                                 bool* ignore_route) {
   auto* case_sensitive_ptr =
       envoy_config_route_v3_RouteMatch_case_sensitive(match);
   bool case_sensitive = true;
@@ -387,18 +414,18 @@ grpc_error_handle RoutePathMatchParse(
         // Prefix which does not start with a / will never match anything, so
         // ignore this route.
         *ignore_route = true;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       std::vector<absl::string_view> prefix_elements =
           absl::StrSplit(prefix.substr(1), absl::MaxSplits('/', 2));
       if (prefix_elements.size() > 2) {
         // Prefix cannot have more than 2 slashes.
         *ignore_route = true;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       } else if (prefix_elements.size() == 2 && prefix_elements[0].empty()) {
         // Prefix contains empty string between the 2 slashes
         *ignore_route = true;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
     }
     type = StringMatcher::Type::kPrefix;
@@ -409,13 +436,13 @@ grpc_error_handle RoutePathMatchParse(
     if (path.empty()) {
       // Path that is empty will never match anything, so ignore this route.
       *ignore_route = true;
-      return GRPC_ERROR_NONE;
+      return absl::OkStatus();
     }
     if (path[0] != '/') {
       // Path which does not start with a / will never match anything, so
       // ignore this route.
       *ignore_route = true;
-      return GRPC_ERROR_NONE;
+      return absl::OkStatus();
     }
     std::vector<absl::string_view> path_elements =
         absl::StrSplit(path.substr(1), absl::MaxSplits('/', 2));
@@ -423,17 +450,17 @@ grpc_error_handle RoutePathMatchParse(
       // Path not in the required format of /service/method will never match
       // anything, so ignore this route.
       *ignore_route = true;
-      return GRPC_ERROR_NONE;
+      return absl::OkStatus();
     } else if (path_elements[0].empty()) {
       // Path contains empty service name will never match anything, so ignore
       // this route.
       *ignore_route = true;
-      return GRPC_ERROR_NONE;
+      return absl::OkStatus();
     } else if (path_elements[1].empty()) {
       // Path contains empty method name will never match anything, so ignore
       // this route.
       *ignore_route = true;
-      return GRPC_ERROR_NONE;
+      return absl::OkStatus();
     }
     type = StringMatcher::Type::kExact;
     match_string = std::string(path);
@@ -445,20 +472,20 @@ grpc_error_handle RoutePathMatchParse(
     match_string = UpbStringToStdString(
         envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
   } else {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    return absl::InvalidArgumentError(
         "Invalid route path specifier specified.");
   }
   absl::StatusOr<StringMatcher> string_matcher =
       StringMatcher::Create(type, match_string, case_sensitive);
   if (!string_matcher.ok()) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    return absl::InvalidArgumentError(
         absl::StrCat("path matcher: ", string_matcher.status().message()));
   }
   route->matchers.path_matcher = std::move(string_matcher.value());
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
-grpc_error_handle RouteHeaderMatchersParse(
+absl::Status RouteHeaderMatchersParse(
     const envoy_config_route_v3_RouteMatch* match,
     XdsRouteConfigResource::Route* route) {
   size_t size;
@@ -507,7 +534,7 @@ grpc_error_handle RouteHeaderMatchersParse(
       match_string = UpbStringToStdString(
           envoy_config_route_v3_HeaderMatcher_contains_match(header));
     } else {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return absl::InvalidArgumentError(
           "Invalid route header matcher specified.");
     }
     bool invert_match =
@@ -516,16 +543,16 @@ grpc_error_handle RouteHeaderMatchersParse(
         HeaderMatcher::Create(name, type, match_string, range_start, range_end,
                               present_match, invert_match);
     if (!header_matcher.ok()) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      return absl::InvalidArgumentError(
           absl::StrCat("header matcher: ", header_matcher.status().message()));
     }
     route->matchers.header_matchers.emplace_back(
         std::move(header_matcher.value()));
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
-grpc_error_handle RouteRuntimeFractionParse(
+absl::Status RouteRuntimeFractionParse(
     const envoy_config_route_v3_RouteMatch* match,
     XdsRouteConfigResource::Route* route) {
   const envoy_config_core_v3_RuntimeFractionalPercent* runtime_fraction =
@@ -550,8 +577,7 @@ grpc_error_handle RouteRuntimeFractionParse(
         case envoy_type_v3_FractionalPercent_MILLION:
           break;
         default:
-          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "Unknown denominator type");
+          return absl::InvalidArgumentError("Unknown denominator type");
       }
       route->matchers.fraction_per_million = numerator;
     }
@@ -560,26 +586,27 @@ grpc_error_handle RouteRuntimeFractionParse(
 }
 
 template <typename ParentType, typename EntryType>
-grpc_error_handle ParseTypedPerFilterConfig(
-    const XdsEncodingContext& context, const ParentType* parent,
+absl::StatusOr<XdsRouteConfigResource::TypedPerFilterConfig>
+ParseTypedPerFilterConfig(
+    const XdsResourceType::DecodeContext& context, const ParentType* parent,
     const EntryType* (*entry_func)(const ParentType*, size_t*),
     upb_StringView (*key_func)(const EntryType*),
-    const google_protobuf_Any* (*value_func)(const EntryType*),
-    XdsRouteConfigResource::TypedPerFilterConfig* typed_per_filter_config) {
+    const google_protobuf_Any* (*value_func)(const EntryType*)) {
+  XdsRouteConfigResource::TypedPerFilterConfig typed_per_filter_config;
   size_t filter_it = kUpb_Map_Begin;
   while (true) {
     const auto* filter_entry = entry_func(parent, &filter_it);
     if (filter_entry == nullptr) break;
     absl::string_view key = UpbStringToAbsl(key_func(filter_entry));
     if (key.empty()) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("empty filter name in map");
+      return absl::InvalidArgumentError("empty filter name in map");
     }
     const google_protobuf_Any* any = value_func(filter_entry);
     GPR_ASSERT(any != nullptr);
     absl::string_view filter_type =
         UpbStringToAbsl(google_protobuf_Any_type_url(any));
     if (filter_type.empty()) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      return absl::InvalidArgumentError(
           absl::StrCat("no filter config specified for filter name ", key));
     }
     bool is_optional = false;
@@ -589,7 +616,7 @@ grpc_error_handle ParseTypedPerFilterConfig(
       const auto* filter_config = envoy_config_route_v3_FilterConfig_parse(
           any_value.data, any_value.size, context.arena);
       if (filter_config == nullptr) {
-        return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        return absl::InvalidArgumentError(
             absl::StrCat("could not parse FilterConfig wrapper for ", key));
       }
       is_optional =
@@ -597,38 +624,37 @@ grpc_error_handle ParseTypedPerFilterConfig(
       any = envoy_config_route_v3_FilterConfig_config(filter_config);
       if (any == nullptr) {
         if (is_optional) continue;
-        return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        return absl::InvalidArgumentError(
             absl::StrCat("no filter config specified for filter name ", key));
       }
     }
-    grpc_error_handle error =
-        ExtractExtensionTypeName(context, any, &filter_type);
-    if (error != GRPC_ERROR_NONE) return error;
+    auto type = ExtractExtensionTypeName(context, any);
+    if (!type.ok()) return type.status();
     const XdsHttpFilterImpl* filter_impl =
-        XdsHttpFilterRegistry::GetFilterForType(filter_type);
+        XdsHttpFilterRegistry::GetFilterForType(type->type);
     if (filter_impl == nullptr) {
       if (is_optional) continue;
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
-          absl::StrCat("no filter registered for config type ", filter_type));
+      return absl::InvalidArgumentError(
+          absl::StrCat("no filter registered for config type ", type->type));
     }
     absl::StatusOr<XdsHttpFilterImpl::FilterConfig> filter_config =
         filter_impl->GenerateFilterConfigOverride(
             google_protobuf_Any_value(any), context.arena);
     if (!filter_config.ok()) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-          "filter config for type ", filter_type,
-          " failed to parse: ", StatusToString(filter_config.status())));
+      return absl::InvalidArgumentError(
+          absl::StrCat("filter config for type ", type->type,
+                       " failed to parse: ", filter_config.status().message()));
     }
-    (*typed_per_filter_config)[std::string(key)] = std::move(*filter_config);
+    typed_per_filter_config[std::string(key)] = std::move(*filter_config);
   }
-  return GRPC_ERROR_NONE;
+  return typed_per_filter_config;
 }
 
-grpc_error_handle RetryPolicyParse(
-    const XdsEncodingContext& context,
+absl::Status RetryPolicyParse(
+    const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RetryPolicy* retry_policy,
     absl::optional<XdsRouteConfigResource::RetryPolicy>* retry) {
-  std::vector<grpc_error_handle> errors;
+  std::vector<std::string> errors;
   XdsRouteConfigResource::RetryPolicy retry_to_return;
   auto retry_on = UpbStringToStdString(
       envoy_config_route_v3_RetryPolicy_retry_on(retry_policy));
@@ -656,8 +682,8 @@ grpc_error_handle RetryPolicyParse(
   if (num_retries != nullptr) {
     uint32_t num_retries_value = google_protobuf_UInt32Value_value(num_retries);
     if (num_retries_value == 0) {
-      errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "RouteAction RetryPolicy num_retries set to invalid value 0."));
+      errors.emplace_back(
+          "RouteAction RetryPolicy num_retries set to invalid value 0.");
     } else {
       retry_to_return.num_retries = num_retries_value;
     }
@@ -670,8 +696,8 @@ grpc_error_handle RetryPolicyParse(
     const google_protobuf_Duration* base_interval =
         envoy_config_route_v3_RetryPolicy_RetryBackOff_base_interval(backoff);
     if (base_interval == nullptr) {
-      errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "RouteAction RetryPolicy RetryBackoff missing base interval."));
+      errors.emplace_back(
+          "RouteAction RetryPolicy RetryBackoff missing base interval.");
     } else {
       retry_to_return.retry_back_off.base_interval =
           ParseDuration(base_interval);
@@ -690,22 +716,23 @@ grpc_error_handle RetryPolicyParse(
     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;
-    return GRPC_ERROR_NONE;
-  } else {
-    return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing retry policy",
-                                         &errors);
+  // Return result.
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "Errors parsing retry policy: [", absl::StrJoin(errors, "; "), "]"));
   }
+  *retry = retry_to_return;
+  return absl::OkStatus();
 }
 
-grpc_error_handle RouteActionParse(
-    const XdsEncodingContext& context,
+absl::StatusOr<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
+    const XdsResourceType::DecodeContext& 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) {
+    bool* ignore_route) {
+  XdsRouteConfigResource::Route::RouteAction 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.
@@ -713,12 +740,11 @@ grpc_error_handle RouteActionParse(
     std::string cluster_name = UpbStringToStdString(
         envoy_config_route_v3_RouteAction_cluster(route_action));
     if (cluster_name.empty()) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return absl::InvalidArgumentError(
           "RouteAction cluster contains empty cluster name.");
     }
-    route->action
-        .emplace<XdsRouteConfigResource::Route::RouteAction::kClusterIndex>(
-            std::move(cluster_name));
+    route.action = XdsRouteConfigResource::Route::RouteAction::ClusterName{
+        std::move(cluster_name)};
   } else if (envoy_config_route_v3_RouteAction_has_weighted_clusters(
                  route_action)) {
     std::vector<XdsRouteConfigResource::Route::RouteAction::ClusterWeight>
@@ -744,7 +770,7 @@ grpc_error_handle RouteActionParse(
           envoy_config_route_v3_WeightedCluster_ClusterWeight_name(
               cluster_weight));
       if (cluster.name.empty()) {
-        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        return absl::InvalidArgumentError(
             "RouteAction weighted_cluster cluster contains empty cluster "
             "name.");
       }
@@ -752,34 +778,36 @@ grpc_error_handle RouteActionParse(
           envoy_config_route_v3_WeightedCluster_ClusterWeight_weight(
               cluster_weight);
       if (weight == nullptr) {
-        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        return absl::InvalidArgumentError(
             "RouteAction weighted_cluster cluster missing weight");
       }
       cluster.weight = google_protobuf_UInt32Value_value(weight);
       if (cluster.weight == 0) continue;
       sum_of_weights += cluster.weight;
-      if (context.use_v3) {
-        grpc_error_handle error = ParseTypedPerFilterConfig<
+      if (context.server.ShouldUseV3()) {
+        auto typed_per_filter_config = ParseTypedPerFilterConfig<
             envoy_config_route_v3_WeightedCluster_ClusterWeight,
             envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry>(
             context, cluster_weight,
             envoy_config_route_v3_WeightedCluster_ClusterWeight_typed_per_filter_config_next,
             envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_key,
-            envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_value,
-            &cluster.typed_per_filter_config);
-        if (error != GRPC_ERROR_NONE) return error;
+            envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_value);
+        if (!typed_per_filter_config.ok()) {
+          return typed_per_filter_config.status();
+        }
+        cluster.typed_per_filter_config = std::move(*typed_per_filter_config);
       }
       action_weighted_clusters.emplace_back(std::move(cluster));
     }
     if (total_weight != sum_of_weights) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return absl::InvalidArgumentError(
           "RouteAction weighted_cluster has incorrect total weight");
     }
     if (action_weighted_clusters.empty()) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return absl::InvalidArgumentError(
           "RouteAction weighted_cluster has no valid clusters specified.");
     }
-    route->action = std::move(action_weighted_clusters);
+    route.action = std::move(action_weighted_clusters);
   } else if (XdsRlsEnabled() &&
              envoy_config_route_v3_RouteAction_has_cluster_specifier_plugin(
                  route_action)) {
@@ -787,20 +815,20 @@ grpc_error_handle RouteActionParse(
         envoy_config_route_v3_RouteAction_cluster_specifier_plugin(
             route_action));
     if (plugin_name.empty()) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return absl::InvalidArgumentError(
           "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(
+      return absl::InvalidArgumentError(
           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));
+    route.action =
+        XdsRouteConfigResource::Route::RouteAction::ClusterSpecifierPluginName{
+            std::move(plugin_name)};
   } else {
     // No cluster or weighted_clusters or plugin found in RouteAction, ignore
     // this route.
@@ -820,7 +848,7 @@ grpc_error_handle RouteActionParse(
                 max_stream_duration);
       }
       if (duration != nullptr) {
-        route->max_stream_duration = ParseDuration(duration);
+        route.max_stream_duration = ParseDuration(duration);
       }
     }
   }
@@ -898,31 +926,35 @@ grpc_error_handle RouteActionParse(
               "RouteAction HashPolicy contains unsupported policy specifier.");
       continue;
     }
-    route->hash_policies.emplace_back(std::move(policy));
+    route.hash_policies.emplace_back(std::move(policy));
   }
   // Get retry policy
   const envoy_config_route_v3_RetryPolicy* retry_policy =
       envoy_config_route_v3_RouteAction_retry_policy(route_action);
   if (retry_policy != nullptr) {
     absl::optional<XdsRouteConfigResource::RetryPolicy> retry;
-    grpc_error_handle error = RetryPolicyParse(context, retry_policy, &retry);
-    if (error != GRPC_ERROR_NONE) return error;
-    route->retry_policy = retry;
+    absl::Status status = RetryPolicyParse(context, retry_policy, &retry);
+    if (!status.ok()) return status;
+    route.retry_policy = retry;
   }
-  return GRPC_ERROR_NONE;
+  return route;
 }
 
 }  // namespace
 
-grpc_error_handle XdsRouteConfigResource::Parse(
-    const XdsEncodingContext& context,
-    const envoy_config_route_v3_RouteConfiguration* route_config,
-    XdsRouteConfigResource* rds_update) {
+absl::StatusOr<XdsRouteConfigResource> XdsRouteConfigResource::Parse(
+    const XdsResourceType::DecodeContext& 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;
+    auto cluster_specifier_plugin_map =
+        ClusterSpecifierPluginParse(context, route_config);
+    if (!cluster_specifier_plugin_map.ok()) {
+      return cluster_specifier_plugin_map.status();
+    }
+    rds_update.cluster_specifier_plugin_map =
+        std::move(*cluster_specifier_plugin_map);
   }
   // Get the virtual hosts.
   size_t num_virtual_hosts;
@@ -930,9 +962,9 @@ grpc_error_handle XdsRouteConfigResource::Parse(
       envoy_config_route_v3_RouteConfiguration_virtual_hosts(
           route_config, &num_virtual_hosts);
   for (size_t i = 0; i < num_virtual_hosts; ++i) {
-    rds_update->virtual_hosts.emplace_back();
+    rds_update.virtual_hosts.emplace_back();
     XdsRouteConfigResource::VirtualHost& vhost =
-        rds_update->virtual_hosts.back();
+        rds_update.virtual_hosts.back();
     // Parse domains.
     size_t domain_size;
     upb_StringView const* domains = envoy_config_route_v3_VirtualHost_domains(
@@ -940,25 +972,27 @@ grpc_error_handle XdsRouteConfigResource::Parse(
     for (size_t j = 0; j < domain_size; ++j) {
       std::string domain_pattern = UpbStringToStdString(domains[j]);
       if (!XdsRouting::IsValidDomainPattern(domain_pattern)) {
-        return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        return absl::InvalidArgumentError(
             absl::StrCat("Invalid domain pattern \"", domain_pattern, "\"."));
       }
       vhost.domains.emplace_back(std::move(domain_pattern));
     }
     if (vhost.domains.empty()) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("VirtualHost has no domains");
+      return absl::InvalidArgumentError("VirtualHost has no domains");
     }
     // Parse typed_per_filter_config.
-    if (context.use_v3) {
-      grpc_error_handle error = ParseTypedPerFilterConfig<
+    if (context.server.ShouldUseV3()) {
+      auto typed_per_filter_config = ParseTypedPerFilterConfig<
           envoy_config_route_v3_VirtualHost,
           envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry>(
           context, virtual_hosts[i],
           envoy_config_route_v3_VirtualHost_typed_per_filter_config_next,
           envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_key,
-          envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_value,
-          &vhost.typed_per_filter_config);
-      if (error != GRPC_ERROR_NONE) return error;
+          envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_value);
+      if (!typed_per_filter_config.ok()) {
+        return typed_per_filter_config.status();
+      }
+      vhost.typed_per_filter_config = std::move(*typed_per_filter_config);
     }
     // Parse retry policy.
     absl::optional<XdsRouteConfigResource::RetryPolicy>
@@ -966,22 +1000,21 @@ grpc_error_handle XdsRouteConfigResource::Parse(
     const envoy_config_route_v3_RetryPolicy* retry_policy =
         envoy_config_route_v3_VirtualHost_retry_policy(virtual_hosts[i]);
     if (retry_policy != nullptr) {
-      grpc_error_handle error =
+      absl::Status status =
           RetryPolicyParse(context, retry_policy, &virtual_host_retry_policy);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!status.ok()) return status;
     }
     // Parse routes.
     size_t num_routes;
     const envoy_config_route_v3_Route* const* routes =
         envoy_config_route_v3_VirtualHost_routes(virtual_hosts[i], &num_routes);
     if (num_routes < 1) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "No route found in the virtual host.");
+      return absl::InvalidArgumentError("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) {
+    for (auto& plugin : rds_update.cluster_specifier_plugin_map) {
       cluster_specifier_plugins.emplace(plugin.first);
     }
     // Loop over the whole list of routes
@@ -989,7 +1022,7 @@ grpc_error_handle XdsRouteConfigResource::Parse(
       const envoy_config_route_v3_RouteMatch* match =
           envoy_config_route_v3_Route_match(routes[j]);
       if (match == nullptr) {
-        return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Match can't be null.");
+        return absl::InvalidArgumentError("Match can't be null.");
       }
       size_t query_parameters_size;
       static_cast<void>(envoy_config_route_v3_RouteMatch_query_parameters(
@@ -999,64 +1032,63 @@ grpc_error_handle XdsRouteConfigResource::Parse(
       }
       XdsRouteConfigResource::Route route;
       bool ignore_route = false;
-      grpc_error_handle error =
-          RoutePathMatchParse(match, &route, &ignore_route);
-      if (error != GRPC_ERROR_NONE) return error;
+      absl::Status status = RoutePathMatchParse(match, &route, &ignore_route);
+      if (!status.ok()) return status;
       if (ignore_route) continue;
-      error = RouteHeaderMatchersParse(match, &route);
-      if (error != GRPC_ERROR_NONE) return error;
-      error = RouteRuntimeFractionParse(match, &route);
-      if (error != GRPC_ERROR_NONE) return error;
+      status = RouteHeaderMatchersParse(match, &route);
+      if (!status.ok()) return status;
+      status = RouteRuntimeFractionParse(match, &route);
+      if (!status.ok()) return status;
       if (envoy_config_route_v3_Route_has_route(routes[j])) {
         route.action.emplace<XdsRouteConfigResource::Route::RouteAction>();
-        auto& route_action =
-            absl::get<XdsRouteConfigResource::Route::RouteAction>(route.action);
-        error = RouteActionParse(context, routes[j],
-                                 rds_update->cluster_specifier_plugin_map,
-                                 &route_action, &ignore_route);
-        if (error != GRPC_ERROR_NONE) return error;
+        auto route_action = RouteActionParse(
+            context, routes[j], rds_update.cluster_specifier_plugin_map,
+            &ignore_route);
+        if (!route_action.ok()) return route_action.status();
         if (ignore_route) continue;
-        if (route_action.retry_policy == absl::nullopt &&
+        if (route_action->retry_policy == absl::nullopt &&
             retry_policy != nullptr) {
-          route_action.retry_policy = virtual_host_retry_policy;
+          route_action->retry_policy = virtual_host_retry_policy;
         }
         // Mark off plugins used in route action.
-        std::string* cluster_specifier_action =
+        auto* cluster_specifier_action =
             absl::get_if<XdsRouteConfigResource::Route::RouteAction::
-                             kClusterSpecifierPluginIndex>(
-                &route_action.action);
+                             ClusterSpecifierPluginName>(&route_action->action);
         if (cluster_specifier_action != nullptr) {
-          cluster_specifier_plugins.erase(*cluster_specifier_action);
+          cluster_specifier_plugins.erase(
+              cluster_specifier_action->cluster_specifier_plugin_name);
         }
+        route.action = std::move(*route_action);
       } else if (envoy_config_route_v3_Route_has_non_forwarding_action(
                      routes[j])) {
         route.action
             .emplace<XdsRouteConfigResource::Route::NonForwardingAction>();
       }
-      if (context.use_v3) {
-        grpc_error_handle error = ParseTypedPerFilterConfig<
+      if (context.server.ShouldUseV3()) {
+        auto typed_per_filter_config = ParseTypedPerFilterConfig<
             envoy_config_route_v3_Route,
             envoy_config_route_v3_Route_TypedPerFilterConfigEntry>(
             context, routes[j],
             envoy_config_route_v3_Route_typed_per_filter_config_next,
             envoy_config_route_v3_Route_TypedPerFilterConfigEntry_key,
-            envoy_config_route_v3_Route_TypedPerFilterConfigEntry_value,
-            &route.typed_per_filter_config);
-        if (error != GRPC_ERROR_NONE) return error;
+            envoy_config_route_v3_Route_TypedPerFilterConfigEntry_value);
+        if (!typed_per_filter_config.ok()) {
+          return typed_per_filter_config.status();
+        }
+        route.typed_per_filter_config = std::move(*typed_per_filter_config);
       }
       vhost.routes.emplace_back(std::move(route));
     }
     if (vhost.routes.empty()) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No valid routes specified.");
+      return absl::InvalidArgumentError("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));
+      rds_update.cluster_specifier_plugin_map.erase(std::string(unused_plugin));
     }
   }
-  return GRPC_ERROR_NONE;
+  return rds_update;
 }
 
 //
@@ -1066,7 +1098,7 @@ grpc_error_handle XdsRouteConfigResource::Parse(
 namespace {
 
 void MaybeLogRouteConfiguration(
-    const XdsEncodingContext& context,
+    const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RouteConfiguration* route_config) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
@@ -1082,9 +1114,9 @@ void MaybeLogRouteConfiguration(
 }  // namespace
 
 absl::StatusOr<XdsResourceType::DecodeResult>
-XdsRouteConfigResourceType::Decode(const XdsEncodingContext& context,
-                                   absl::string_view serialized_resource,
-                                   bool /*is_v2*/) const {
+XdsRouteConfigResourceType::Decode(
+    const XdsResourceType::DecodeContext& context,
+    absl::string_view serialized_resource, bool /*is_v2*/) const {
   // Parse serialized proto.
   auto* resource = envoy_config_route_v3_RouteConfiguration_parse(
       serialized_resource.data(), serialized_resource.size(), context.arena);
@@ -1097,24 +1129,23 @@ XdsRouteConfigResourceType::Decode(const XdsEncodingContext& context,
   DecodeResult result;
   result.name = UpbStringToStdString(
       envoy_config_route_v3_RouteConfiguration_name(resource));
-  auto route_config_data = absl::make_unique<ResourceDataSubclass>();
-  grpc_error_handle error = XdsRouteConfigResource::Parse(
-      context, resource, &route_config_data->resource);
-  if (error != GRPC_ERROR_NONE) {
-    std::string error_str = grpc_error_std_string(error);
-    GRPC_ERROR_UNREF(error);
+  auto rds_update = XdsRouteConfigResource::Parse(context, resource);
+  if (!rds_update.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_ERROR, "[xds_client %p] invalid RouteConfiguration %s: %s",
-              context.client, result.name.c_str(), error_str.c_str());
+              context.client, result.name.c_str(),
+              rds_update.status().ToString().c_str());
     }
-    result.resource = absl::InvalidArgumentError(error_str);
+    result.resource = rds_update.status();
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed RouteConfiguration %s: %s",
               context.client, result.name.c_str(),
-              route_config_data->resource.ToString().c_str());
+              rds_update->ToString().c_str());
     }
-    result.resource = std::move(route_config_data);
+    auto resource = absl::make_unique<ResourceDataSubclass>();
+    resource->resource = std::move(*rds_update);
+    result.resource = std::move(resource);
   }
   return std::move(result);
 }