grpc 1.63.0 → 1.69.0

data/src/core/{ext/xds/xds_route_config.cc → xds/grpc/xds_route_config_parser.cc}

@@ -14,10 +14,10 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/xds/xds_route_config.h"
+#include "src/core/xds/grpc/xds_route_config_parser.h"
 
+#include <grpc/status.h>
+#include <grpc/support/port_platform.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -29,6 +29,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -51,31 +53,29 @@
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 #include "re2/re2.h"
-#include "upb/base/string_view.h"
-#include "upb/message/map.h"
-#include "upb/text/encode.h"
-
-#include <grpc/status.h>
-#include <grpc/support/log.h>
-
-#include "src/core/ext/xds/upb_utils.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_routing.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/env.h"
-#include "src/core/lib/gprpp/match.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_writer.h"
-#include "src/core/lib/matchers/matchers.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/util/env.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_writer.h"
+#include "src/core/util/match.h"
+#include "src/core/util/matchers.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/string.h"
+#include "src/core/util/time.h"
+#include "src/core/util/upb_utils.h"
+#include "src/core/xds/grpc/xds_cluster_specifier_plugin.h"
+#include "src/core/xds/grpc/xds_common_types.h"
+#include "src/core/xds/grpc/xds_common_types_parser.h"
+#include "src/core/xds/grpc/xds_http_filter.h"
+#include "src/core/xds/grpc/xds_http_filter_registry.h"
+#include "src/core/xds/grpc/xds_routing.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
+#include "upb/base/string_view.h"
+#include "upb/message/map.h"
+#include "upb/text/encode.h"
 
 namespace grpc_core {
 
@@ -88,253 +88,19 @@ bool XdsRlsEnabled() {
   return parse_succeeded && parsed_value;
 }
 
-//
-// XdsRouteConfigResource::RetryPolicy
-//
-
-std::string XdsRouteConfigResource::RetryPolicy::RetryBackOff::ToString()
-    const {
-  std::vector<std::string> contents;
-  contents.push_back(
-      absl::StrCat("RetryBackOff Base: ", base_interval.ToString()));
-  contents.push_back(
-      absl::StrCat("RetryBackOff max: ", max_interval.ToString()));
-  return absl::StrJoin(contents, ",");
-}
-
-std::string XdsRouteConfigResource::RetryPolicy::ToString() const {
-  std::vector<std::string> contents;
-  contents.push_back(absl::StrFormat("num_retries=%d", num_retries));
-  contents.push_back(retry_back_off.ToString());
-  return absl::StrCat("{", absl::StrJoin(contents, ","), "}");
-}
-
-//
-// XdsRouteConfigResource::Route::Matchers
-//
-
-std::string XdsRouteConfigResource::Route::Matchers::ToString() const {
-  std::vector<std::string> contents;
-  contents.push_back(
-      absl::StrFormat("PathMatcher{%s}", path_matcher.ToString()));
-  for (const HeaderMatcher& header_matcher : header_matchers) {
-    contents.push_back(header_matcher.ToString());
-  }
-  if (fraction_per_million.has_value()) {
-    contents.push_back(absl::StrFormat("Fraction Per Million %d",
-                                       fraction_per_million.value()));
-  }
-  return absl::StrJoin(contents, "\n");
-}
-
-//
-// XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header
-//
-
-XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header::Header(
-    const Header& other)
-    : header_name(other.header_name),
-      regex_substitution(other.regex_substitution) {
-  if (other.regex != nullptr) {
-    regex =
-        std::make_unique<RE2>(other.regex->pattern(), other.regex->options());
-  }
-}
-
-XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header&
-XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header::operator=(
-    const Header& other) {
-  header_name = other.header_name;
-  if (other.regex != nullptr) {
-    regex =
-        std::make_unique<RE2>(other.regex->pattern(), other.regex->options());
-  }
-  regex_substitution = other.regex_substitution;
-  return *this;
-}
-
-XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header::Header(
-    Header&& other) noexcept
-    : header_name(std::move(other.header_name)),
-      regex(std::move(other.regex)),
-      regex_substitution(std::move(other.regex_substitution)) {}
-
-XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header&
-XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header::operator=(
-    Header&& other) noexcept {
-  header_name = std::move(other.header_name);
-  regex = std::move(other.regex);
-  regex_substitution = std::move(other.regex_substitution);
-  return *this;
-}
-
-bool XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header::operator==(
-    const Header& other) const {
-  if (header_name != other.header_name) return false;
-  if (regex == nullptr) {
-    if (other.regex != nullptr) return false;
-  } else {
-    if (other.regex == nullptr) return false;
-    if (regex->pattern() != other.regex->pattern()) return false;
-  }
-  return regex_substitution == other.regex_substitution;
-}
-
-std::string
-XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header::ToString()
-    const {
-  return absl::StrCat("Header ", header_name, "/",
-                      (regex == nullptr) ? "" : regex->pattern(), "/",
-                      regex_substitution);
-}
-
-//
-// XdsRouteConfigResource::Route::RouteAction::HashPolicy
-//
-
-std::string XdsRouteConfigResource::Route::RouteAction::HashPolicy::ToString()
-    const {
-  std::string type = Match(
-      policy, [](const Header& header) { return header.ToString(); },
-      [](const ChannelId&) -> std::string { return "ChannelId"; });
-  return absl::StrCat("{", type, ", terminal=", terminal ? "true" : "false",
-                      "}");
-}
-
-//
-// XdsRouteConfigResource::Route::RouteAction::ClusterWeight
-//
-
-std::string
-XdsRouteConfigResource::Route::RouteAction::ClusterWeight::ToString() const {
-  std::vector<std::string> contents;
-  contents.push_back(absl::StrCat("cluster=", name));
-  contents.push_back(absl::StrCat("weight=", weight));
-  if (!typed_per_filter_config.empty()) {
-    std::vector<std::string> parts;
-    for (const auto& p : typed_per_filter_config) {
-      const std::string& key = p.first;
-      const auto& config = p.second;
-      parts.push_back(absl::StrCat(key, "=", config.ToString()));
-    }
-    contents.push_back(absl::StrCat("typed_per_filter_config={",
-                                    absl::StrJoin(parts, ", "), "}"));
-  }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
-}
-
-//
-// XdsRouteConfigResource::Route::RouteAction
-//
-
-std::string XdsRouteConfigResource::Route::RouteAction::ToString() const {
-  std::vector<std::string> contents;
-  contents.reserve(hash_policies.size());
-  for (const HashPolicy& hash_policy : hash_policies) {
-    contents.push_back(absl::StrCat("hash_policy=", hash_policy.ToString()));
-  }
-  if (retry_policy.has_value()) {
-    contents.push_back(absl::StrCat("retry_policy=", retry_policy->ToString()));
-  }
-  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());
-  }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
-}
-
-//
-// XdsRouteConfigResource::Route
-//
-
-std::string XdsRouteConfigResource::Route::ToString() const {
-  std::vector<std::string> contents;
-  contents.push_back(matchers.ToString());
-  auto* route_action =
-      absl::get_if<XdsRouteConfigResource::Route::RouteAction>(&action);
-  if (route_action != nullptr) {
-    contents.push_back(absl::StrCat("route=", route_action->ToString()));
-  } else if (absl::holds_alternative<
-                 XdsRouteConfigResource::Route::NonForwardingAction>(action)) {
-    contents.push_back("non_forwarding_action={}");
-  } else {
-    contents.push_back("unknown_action={}");
-  }
-  if (!typed_per_filter_config.empty()) {
-    contents.push_back("typed_per_filter_config={");
-    for (const auto& p : typed_per_filter_config) {
-      const std::string& name = p.first;
-      const auto& config = p.second;
-      contents.push_back(absl::StrCat("  ", name, "=", config.ToString()));
-    }
-    contents.push_back("}");
-  }
-  return absl::StrJoin(contents, "\n");
-}
-
-//
-// XdsRouteConfigResource::Route
-//
-
-std::string XdsRouteConfigResource::VirtualHost::ToString() const {
-  std::vector<std::string> parts;
-  parts.push_back(
-      absl::StrCat("vhost={\n"
-                   "  domains=[",
-                   absl::StrJoin(domains, ", "),
-                   "]\n"
-                   "  routes=[\n"));
-  for (const XdsRouteConfigResource::Route& route : routes) {
-    parts.push_back("    {\n");
-    parts.push_back(route.ToString());
-    parts.push_back("\n    }\n");
-  }
-  parts.push_back("  ]\n");
-  parts.push_back("  typed_per_filter_config={\n");
-  for (const auto& p : typed_per_filter_config) {
-    const std::string& name = p.first;
-    const auto& config = p.second;
-    parts.push_back(absl::StrCat("    ", name, "=", config.ToString(), "\n"));
-  }
-  parts.push_back("  }\n");
-  parts.push_back("}\n");
-  return absl::StrJoin(parts, "");
+// TODO(roth): Remove this once the feature passes interop tests.
+bool XdsAuthorityRewriteEnabled() {
+  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE");
+  if (!value.has_value()) return false;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
 }
 
 //
-// XdsRouteConfigResource
+// XdsRouteConfigResourceParse()
 //
 
-std::string XdsRouteConfigResource::ToString() const {
-  std::vector<std::string> parts;
-  parts.reserve(virtual_hosts.size());
-  for (const VirtualHost& vhost : virtual_hosts) {
-    parts.push_back(vhost.ToString());
-  }
-  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 {
 
 XdsRouteConfigResource::ClusterSpecifierPluginMap ClusterSpecifierPluginParse(
@@ -417,12 +183,9 @@ XdsRouteConfigResource::ClusterSpecifierPluginMap ClusterSpecifierPluginParse(
 
 absl::optional<StringMatcher> RoutePathMatchParse(
     const envoy_config_route_v3_RouteMatch* match, ValidationErrors* errors) {
-  bool case_sensitive = true;
-  auto* case_sensitive_ptr =
-      envoy_config_route_v3_RouteMatch_case_sensitive(match);
-  if (case_sensitive_ptr != nullptr) {
-    case_sensitive = google_protobuf_BoolValue_value(case_sensitive_ptr);
-  }
+  bool case_sensitive =
+      ParseBoolValue(envoy_config_route_v3_RouteMatch_case_sensitive(match),
+                     /*default_value=*/true);
   StringMatcher::Type type;
   std::string match_string;
   if (envoy_config_route_v3_RouteMatch_has_prefix(match)) {
@@ -465,7 +228,7 @@ absl::optional<StringMatcher> RoutePathMatchParse(
   } else if (envoy_config_route_v3_RouteMatch_has_safe_regex(match)) {
     const envoy_type_matcher_v3_RegexMatcher* regex_matcher =
         envoy_config_route_v3_RouteMatch_safe_regex(match);
-    GPR_ASSERT(regex_matcher != nullptr);
+    CHECK_NE(regex_matcher, nullptr);
     type = StringMatcher::Type::kSafeRegex;
     match_string = UpbStringToStdString(
         envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
@@ -493,7 +256,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
     ValidationErrors::ScopedField field(errors,
                                         absl::StrCat(".headers[", i, "]"));
     const envoy_config_route_v3_HeaderMatcher* header = headers[i];
-    GPR_ASSERT(header != nullptr);
+    CHECK_NE(header, nullptr);
     const std::string name =
         UpbStringToStdString(envoy_config_route_v3_HeaderMatcher_name(header));
     HeaderMatcher::Type type;
@@ -522,7 +285,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
                    header)) {
       const envoy_type_matcher_v3_RegexMatcher* regex_matcher =
           envoy_config_route_v3_HeaderMatcher_safe_regex_match(header);
-      GPR_ASSERT(regex_matcher != nullptr);
+      CHECK_NE(regex_matcher, nullptr);
       type = HeaderMatcher::Type::kSafeRegex;
       match_string = UpbStringToStdString(
           envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
@@ -530,7 +293,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
       type = HeaderMatcher::Type::kRange;
       const envoy_type_v3_Int64Range* range_matcher =
           envoy_config_route_v3_HeaderMatcher_range_match(header);
-      GPR_ASSERT(range_matcher != nullptr);
+      CHECK_NE(range_matcher, nullptr);
       range_start = envoy_type_v3_Int64Range_start(range_matcher);
       range_end = envoy_type_v3_Int64Range_end(range_matcher);
     } else if (envoy_config_route_v3_HeaderMatcher_has_present_match(header)) {
@@ -540,7 +303,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
       ValidationErrors::ScopedField field(errors, ".string_match");
       const auto* matcher =
           envoy_config_route_v3_HeaderMatcher_string_match(header);
-      GPR_ASSERT(matcher != nullptr);
+      CHECK_NE(matcher, nullptr);
       if (envoy_type_matcher_v3_StringMatcher_has_exact(matcher)) {
         type = HeaderMatcher::Type::kExact;
         match_string = UpbStringToStdString(
@@ -561,7 +324,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
         type = HeaderMatcher::Type::kSafeRegex;
         const auto* regex_matcher =
             envoy_type_matcher_v3_StringMatcher_safe_regex(matcher);
-        GPR_ASSERT(regex_matcher != nullptr);
+        CHECK_NE(regex_matcher, nullptr);
         match_string = UpbStringToStdString(
             envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
       } else {
@@ -676,7 +439,7 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
     }
     absl::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
         filter_impl->GenerateFilterConfigOverride(
-            context, std::move(*extension_to_use), errors);
+            key, context, std::move(*extension_to_use), errors);
     if (filter_config.has_value()) {
       typed_per_filter_config[std::string(key)] = std::move(*filter_config);
     }
@@ -704,24 +467,18 @@ XdsRouteConfigResource::RetryPolicy RetryPolicyParse(
     } else if (code == "unavailable") {
       retry_policy.retry_on.Add(GRPC_STATUS_UNAVAILABLE);
     } else {
-      if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
-        gpr_log(GPR_INFO, "Unsupported retry_on policy %s.",
-                std::string(code).c_str());
+      if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+        LOG(INFO) << "Unsupported retry_on policy " << code;
       }
     }
   }
-  const google_protobuf_UInt32Value* num_retries =
-      envoy_config_route_v3_RetryPolicy_num_retries(retry_policy_proto);
-  if (num_retries != nullptr) {
-    uint32_t num_retries_value = google_protobuf_UInt32Value_value(num_retries);
-    if (num_retries_value == 0) {
-      ValidationErrors::ScopedField field(errors, ".num_retries");
-      errors->AddError("must be greater than 0");
-    } else {
-      retry_policy.num_retries = num_retries_value;
-    }
-  } else {
-    retry_policy.num_retries = 1;
+  retry_policy.num_retries =
+      ParseUInt32Value(
+          envoy_config_route_v3_RetryPolicy_num_retries(retry_policy_proto))
+          .value_or(1);
+  if (retry_policy.num_retries == 0) {
+    ValidationErrors::ScopedField field(errors, ".num_retries");
+    errors->AddError("must be greater than 0");
   }
   const envoy_config_route_v3_RetryPolicy_RetryBackOff* backoff =
       envoy_config_route_v3_RetryPolicy_retry_back_off(retry_policy_proto);
@@ -869,6 +626,13 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
     ValidationErrors::ScopedField field(errors, ".retry_policy");
     route_action.retry_policy = RetryPolicyParse(context, retry_policy, errors);
   }
+  // Host rewrite field.
+  if (XdsAuthorityRewriteEnabled() &&
+      DownCast<const GrpcXdsServer&>(context.server).TrustedXdsServer()) {
+    route_action.auto_host_rewrite =
+        ParseBoolValue(envoy_config_route_v3_RouteAction_auto_host_rewrite(
+            route_action_proto));
+  }
   // Parse cluster specifier, which is one of several options.
   if (envoy_config_route_v3_RouteAction_has_cluster(route_action_proto)) {
     // Cluster name.
@@ -887,7 +651,7 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
     ValidationErrors::ScopedField field(errors, ".weighted_clusters");
     const envoy_config_route_v3_WeightedCluster* weighted_clusters_proto =
         envoy_config_route_v3_RouteAction_weighted_clusters(route_action_proto);
-    GPR_ASSERT(weighted_clusters_proto != nullptr);
+    CHECK_NE(weighted_clusters_proto, nullptr);
     std::vector<XdsRouteConfigResource::Route::RouteAction::ClusterWeight>
         action_weighted_clusters;
     uint64_t total_weight = 0;
@@ -921,14 +685,14 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
         errors->AddError("must be non-empty");
       }
       // weight
-      const google_protobuf_UInt32Value* weight_proto =
+      auto weight = ParseUInt32Value(
           envoy_config_route_v3_WeightedCluster_ClusterWeight_weight(
-              cluster_proto);
-      if (weight_proto == nullptr) {
+              cluster_proto));
+      if (!weight.has_value()) {
         ValidationErrors::ScopedField field(errors, ".weight");
         errors->AddError("field not present");
       } else {
-        cluster.weight = google_protobuf_UInt32Value_value(weight_proto);
+        cluster.weight = *weight;
         if (cluster.weight == 0) continue;
         total_weight += cluster.weight;
       }
@@ -1046,7 +810,7 @@ absl::optional<XdsRouteConfigResource::Route> ParseRoute(
 
 }  // namespace
 
-std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResource::Parse(
+std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResourceParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RouteConfiguration* route_config,
     ValidationErrors* errors) {
@@ -1143,15 +907,14 @@ namespace {
 void MaybeLogRouteConfiguration(
     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)) {
+  if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer) && ABSL_VLOG_IS_ON(2)) {
     const upb_MessageDef* msg_type =
         envoy_config_route_v3_RouteConfiguration_getmsgdef(context.symtab);
     char buf[10240];
     upb_TextEncode(reinterpret_cast<const upb_Message*>(route_config), msg_type,
                    nullptr, 0, buf, sizeof(buf));
-    gpr_log(GPR_DEBUG, "[xds_client %p] RouteConfiguration: %s", context.client,
-            buf);
+    VLOG(2) << "[xds_client " << context.client
+            << "] RouteConfiguration: " << buf;
   }
 }
 
@@ -1174,21 +937,22 @@ XdsResourceType::DecodeResult XdsRouteConfigResourceType::Decode(
   result.name = UpbStringToStdString(
       envoy_config_route_v3_RouteConfiguration_name(resource));
   ValidationErrors errors;
-  auto rds_update = XdsRouteConfigResource::Parse(context, resource, &errors);
+  auto rds_update = XdsRouteConfigResourceParse(context, resource, &errors);
   if (!errors.ok()) {
     absl::Status status =
         errors.status(absl::StatusCode::kInvalidArgument,
                       "errors validating RouteConfiguration resource");
-    if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
-      gpr_log(GPR_ERROR, "[xds_client %p] invalid RouteConfiguration %s: %s",
-              context.client, result.name->c_str(), status.ToString().c_str());
+    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+      LOG(ERROR) << "[xds_client " << context.client
+                 << "] invalid RouteConfiguration " << *result.name << ": "
+                 << status;
     }
     result.resource = std::move(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(),
-              rds_update->ToString().c_str());
+    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+      LOG(INFO) << "[xds_client " << context.client
+                << "] parsed RouteConfiguration " << *result.name << ": "
+                << rds_update->ToString();
     }
     result.resource = std::move(rds_update);
   }

data/src/core/xds/grpc/xds_route_config_parser.h

@@ -0,0 +1,77 @@
+//
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTE_CONFIG_PARSER_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTE_CONFIG_PARSER_H
+
+#include <grpc/support/port_platform.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+#include "envoy/config/route/v3/route.upb.h"
+#include "envoy/config/route/v3/route.upbdefs.h"
+#include "re2/re2.h"
+#include "src/core/lib/channel/status_util.h"
+#include "src/core/util/time.h"
+#include "src/core/util/validation_errors.h"
+#include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/grpc/xds_cluster_specifier_plugin.h"
+#include "src/core/xds/grpc/xds_http_filter.h"
+#include "src/core/xds/grpc/xds_route_config.h"
+#include "src/core/xds/xds_client/xds_client.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
+#include "src/core/xds/xds_client/xds_resource_type_impl.h"
+#include "upb/reflection/def.h"
+
+namespace grpc_core {
+
+std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResourceParse(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_route_v3_RouteConfiguration* route_config,
+    ValidationErrors* errors);
+
+class XdsRouteConfigResourceType final
+    : public XdsResourceTypeImpl<XdsRouteConfigResourceType,
+                                 XdsRouteConfigResource> {
+ public:
+  absl::string_view type_url() const override {
+    return "envoy.config.route.v3.RouteConfiguration";
+  }
+
+  DecodeResult Decode(const XdsResourceType::DecodeContext& context,
+                      absl::string_view serialized_resource) const override;
+
+  void InitUpbSymtab(XdsClient* xds_client,
+                     upb_DefPool* symtab) const override {
+    envoy_config_route_v3_RouteConfiguration_getmsgdef(symtab);
+    const auto& cluster_specifier_plugin_registry =
+        static_cast<const GrpcXdsBootstrap&>(xds_client->bootstrap())
+            .cluster_specifier_plugin_registry();
+    cluster_specifier_plugin_registry.PopulateSymtab(symtab);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTE_CONFIG_PARSER_H