grpc 1.30.2 → 1.31.0.pre1

data/src/core/ext/filters/client_channel/xds/xds_api.cc

@@ -23,9 +23,12 @@
 #include <cstdlib>
 
 #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 "upb/upb.hpp"
+
 #include <grpc/impl/codegen/log.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
@@ -52,7 +55,9 @@
 #include "envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.upb.h"
 #include "envoy/config/listener/v2/api_listener.upb.h"
 #include "envoy/service/load_stats/v2/lrs.upb.h"
+#include "envoy/type/matcher/regex.upb.h"
 #include "envoy/type/percent.upb.h"
+#include "envoy/type/range.upb.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/struct.upb.h"
@@ -129,23 +134,98 @@ const char* XdsApi::kCdsTypeUrl = "type.googleapis.com/envoy.api.v2.Cluster";
 const char* XdsApi::kEdsTypeUrl =
     "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment";
 
-namespace {
+std::string XdsApi::RdsUpdate::RdsRoute::Matchers::PathMatcher::ToString()
+    const {
+  std::string path_type_string;
+  switch (type) {
+    case PathMatcherType::PATH:
+      path_type_string = "path match";
+      break;
+    case PathMatcherType::PREFIX:
+      path_type_string = "prefix match";
+      break;
+    case PathMatcherType::REGEX:
+      path_type_string = "regex match";
+      break;
+    default:
+      break;
+  }
+  return absl::StrFormat("Path %s:/%s/", path_type_string,
+                         type == PathMatcherType::REGEX
+                             ? regex_matcher->pattern()
+                             : string_matcher);
+}
 
-bool XdsRoutingEnabled() {
-  char* value = gpr_getenv("GRPC_XDS_EXPERIMENTAL_ROUTING");
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value, &parsed_value);
-  gpr_free(value);
-  return parse_succeeded && parsed_value;
+std::string XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::ToString()
+    const {
+  switch (type) {
+    case HeaderMatcherType::EXACT:
+      return absl::StrFormat("Header exact match:%s %s:%s",
+                             invert_match ? " not" : "", name, string_matcher);
+    case HeaderMatcherType::REGEX:
+      return absl::StrFormat("Header regex match:%s %s:%s",
+                             invert_match ? " not" : "", name,
+                             regex_match->pattern());
+    case HeaderMatcherType::RANGE:
+      return absl::StrFormat("Header range match:%s %s:[%d, %d)",
+                             invert_match ? " not" : "", name, range_start,
+                             range_end);
+    case HeaderMatcherType::PRESENT:
+      return absl::StrFormat("Header present match:%s %s:%s",
+                             invert_match ? " not" : "", name,
+                             present_match ? "true" : "false");
+    case HeaderMatcherType::PREFIX:
+      return absl::StrFormat("Header prefix match:%s %s:%s",
+                             invert_match ? " not" : "", name, string_matcher);
+    case HeaderMatcherType::SUFFIX:
+      return absl::StrFormat("Header suffix match:%s %s:%s",
+                             invert_match ? " not" : "", name, string_matcher);
+    default:
+      return "";
+  }
 }
 
-}  // namespace
+std::string XdsApi::RdsUpdate::RdsRoute::Matchers::ToString() const {
+  std::vector<std::string> contents;
+  contents.push_back(path_matcher.ToString());
+  for (const auto& header_it : header_matchers) {
+    contents.push_back(header_it.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");
+}
+
+std::string XdsApi::RdsUpdate::RdsRoute::ClusterWeight::ToString() const {
+  return absl::StrFormat("{cluster=%s, weight=%d}", name, weight);
+}
+
+std::string XdsApi::RdsUpdate::RdsRoute::ToString() const {
+  std::vector<std::string> contents;
+  contents.push_back(matchers.ToString());
+  if (!cluster_name.empty()) {
+    contents.push_back(absl::StrFormat("Cluster name: %s", cluster_name));
+  }
+  for (const auto& weighted_it : weighted_clusters) {
+    contents.push_back(weighted_it.ToString());
+  }
+  return absl::StrJoin(contents, "\n");
+}
+
+std::string XdsApi::RdsUpdate::ToString() const {
+  std::vector<std::string> contents;
+  for (const auto& route_it : routes) {
+    contents.push_back(route_it.ToString());
+  }
+  return absl::StrJoin(contents, ",\n");
+}
 
 XdsApi::XdsApi(XdsClient* client, TraceFlag* tracer,
                const XdsBootstrap::Node* node)
     : client_(client),
       tracer_(tracer),
-      xds_routing_enabled_(XdsRoutingEnabled()),
       node_(node),
       build_version_(absl::StrCat("gRPC C-core ", GPR_PLATFORM_STRING, " ",
                                   grpc_version_string())),
@@ -167,13 +247,10 @@ void PopulateListValue(upb_arena* arena, google_protobuf_ListValue* list_value,
 void PopulateMetadata(upb_arena* arena, google_protobuf_Struct* metadata_pb,
                       const Json::Object& metadata) {
   for (const auto& p : metadata) {
-    google_protobuf_Struct_FieldsEntry* field =
-        google_protobuf_Struct_add_fields(metadata_pb, arena);
-    google_protobuf_Struct_FieldsEntry_set_key(
-        field, upb_strview_makez(p.first.c_str()));
-    google_protobuf_Value* value =
-        google_protobuf_Struct_FieldsEntry_mutable_value(field, arena);
+    google_protobuf_Value* value = google_protobuf_Value_new(arena);
     PopulateMetadataValue(arena, value, p.second);
+    google_protobuf_Struct_fields_set(
+        metadata_pb, upb_strview_makez(p.first.c_str()), value, arena);
   }
 }
 
@@ -234,14 +311,12 @@ void PopulateNode(upb_arena* arena, const XdsBootstrap::Node* node,
     if (!server_name.empty()) {
       google_protobuf_Struct* metadata =
           envoy_api_v2_core_Node_mutable_metadata(node_msg, arena);
-      google_protobuf_Struct_FieldsEntry* field =
-          google_protobuf_Struct_add_fields(metadata, arena);
-      google_protobuf_Struct_FieldsEntry_set_key(
-          field, upb_strview_makez("PROXYLESS_CLIENT_HOSTNAME"));
-      google_protobuf_Value* value =
-          google_protobuf_Struct_FieldsEntry_mutable_value(field, arena);
+      google_protobuf_Value* value = google_protobuf_Value_new(arena);
       google_protobuf_Value_set_string_value(
           value, upb_strview_make(server_name.data(), server_name.size()));
+      google_protobuf_Struct_fields_set(
+          metadata, upb_strview_makez("PROXYLESS_CLIENT_HOSTNAME"), value,
+          arena);
     }
     if (!node->locality_region.empty() || !node->locality_zone.empty() ||
         !node->locality_subzone.empty()) {
@@ -328,18 +403,18 @@ void AddNodeLogFields(const envoy_api_v2_core_Node* node,
       envoy_api_v2_core_Node_metadata(node);
   if (metadata != nullptr) {
     fields->emplace_back("  metadata {");
-    size_t num_entries;
-    const google_protobuf_Struct_FieldsEntry* const* entries =
-        google_protobuf_Struct_fields(metadata, &num_entries);
-    for (size_t i = 0; i < num_entries; ++i) {
+    size_t entry_idx = UPB_MAP_BEGIN;
+    while (true) {
+      const google_protobuf_Struct_FieldsEntry* entry =
+          google_protobuf_Struct_fields_next(metadata, &entry_idx);
+      if (entry == nullptr) break;
       fields->emplace_back("    field {");
       // key
-      AddStringField("      key",
-                     google_protobuf_Struct_FieldsEntry_key(entries[i]),
+      AddStringField("      key", google_protobuf_Struct_FieldsEntry_key(entry),
                      fields);
       // value
       const google_protobuf_Value* value =
-          google_protobuf_Struct_FieldsEntry_value(entries[i]);
+          google_protobuf_Struct_FieldsEntry_value(entry);
       if (value != nullptr) {
         std::string value_str;
         if (google_protobuf_Value_has_string_value(value)) {
@@ -918,8 +993,198 @@ MatchType DomainPatternMatchType(const std::string& domain_pattern) {
   return INVALID_MATCH;
 }
 
+grpc_error* RoutePathMatchParse(const envoy_api_v2_route_RouteMatch* match,
+                                XdsApi::RdsUpdate::RdsRoute* rds_route,
+                                bool* ignore_route) {
+  if (envoy_api_v2_route_RouteMatch_has_prefix(match)) {
+    upb_strview prefix = envoy_api_v2_route_RouteMatch_prefix(match);
+    // Empty prefix "" is accepted.
+    if (prefix.size > 0) {
+      // Prefix "/" is accepted.
+      if (prefix.data[0] != '/') {
+        // Prefix which does not start with a / will never match anything, so
+        // ignore this route.
+        *ignore_route = true;
+        return GRPC_ERROR_NONE;
+      }
+      std::vector<absl::string_view> prefix_elements =
+          absl::StrSplit(absl::string_view(prefix.data, prefix.size).substr(1),
+                         absl::MaxSplits('/', 2));
+      if (prefix_elements.size() > 2) {
+        // Prefix cannot have more than 2 slashes.
+        *ignore_route = true;
+        return GRPC_ERROR_NONE;
+      } 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;
+      }
+    }
+    rds_route->matchers.path_matcher.type = XdsApi::RdsUpdate::RdsRoute::
+        Matchers::PathMatcher::PathMatcherType::PREFIX;
+    rds_route->matchers.path_matcher.string_matcher =
+        UpbStringToStdString(prefix);
+  } else if (envoy_api_v2_route_RouteMatch_has_path(match)) {
+    upb_strview path = envoy_api_v2_route_RouteMatch_path(match);
+    if (path.size == 0) {
+      // Path that is empty will never match anything, so ignore this route.
+      *ignore_route = true;
+      return GRPC_ERROR_NONE;
+    }
+    if (path.data[0] != '/') {
+      // Path which does not start with a / will never match anything, so
+      // ignore this route.
+      *ignore_route = true;
+      return GRPC_ERROR_NONE;
+    }
+    std::vector<absl::string_view> path_elements =
+        absl::StrSplit(absl::string_view(path.data, path.size).substr(1),
+                       absl::MaxSplits('/', 2));
+    if (path_elements.size() != 2) {
+      // Path not in the required format of /service/method will never match
+      // anything, so ignore this route.
+      *ignore_route = true;
+      return GRPC_ERROR_NONE;
+    } 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;
+    } 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;
+    }
+    rds_route->matchers.path_matcher.type = XdsApi::RdsUpdate::RdsRoute::
+        Matchers::PathMatcher::PathMatcherType::PATH;
+    rds_route->matchers.path_matcher.string_matcher =
+        UpbStringToStdString(path);
+  } else if (envoy_api_v2_route_RouteMatch_has_safe_regex(match)) {
+    const envoy_type_matcher_RegexMatcher* regex_matcher =
+        envoy_api_v2_route_RouteMatch_safe_regex(match);
+    GPR_ASSERT(regex_matcher != nullptr);
+    const std::string matcher = UpbStringToStdString(
+        envoy_type_matcher_RegexMatcher_regex(regex_matcher));
+    std::unique_ptr<RE2> regex = absl::make_unique<RE2>(matcher);
+    if (!regex->ok()) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "Invalid regex string specified in path matcher.");
+    }
+    rds_route->matchers.path_matcher.type = XdsApi::RdsUpdate::RdsRoute::
+        Matchers::PathMatcher::PathMatcherType::REGEX;
+    rds_route->matchers.path_matcher.regex_matcher = std::move(regex);
+  } else {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Invalid route path specifier specified.");
+  }
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error* RouteHeaderMatchersParse(const envoy_api_v2_route_RouteMatch* match,
+                                     XdsApi::RdsUpdate::RdsRoute* rds_route) {
+  size_t size;
+  const envoy_api_v2_route_HeaderMatcher* const* headers =
+      envoy_api_v2_route_RouteMatch_headers(match, &size);
+  for (size_t i = 0; i < size; ++i) {
+    const envoy_api_v2_route_HeaderMatcher* header = headers[i];
+    XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher header_matcher;
+    header_matcher.name =
+        UpbStringToStdString(envoy_api_v2_route_HeaderMatcher_name(header));
+    if (envoy_api_v2_route_HeaderMatcher_has_exact_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::EXACT;
+      header_matcher.string_matcher = UpbStringToStdString(
+          envoy_api_v2_route_HeaderMatcher_exact_match(header));
+    } else if (envoy_api_v2_route_HeaderMatcher_has_safe_regex_match(header)) {
+      const envoy_type_matcher_RegexMatcher* regex_matcher =
+          envoy_api_v2_route_HeaderMatcher_safe_regex_match(header);
+      GPR_ASSERT(regex_matcher != nullptr);
+      const std::string matcher = UpbStringToStdString(
+          envoy_type_matcher_RegexMatcher_regex(regex_matcher));
+      std::unique_ptr<RE2> regex = absl::make_unique<RE2>(matcher);
+      if (!regex->ok()) {
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "Invalid regex string specified in header matcher.");
+      }
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::REGEX;
+      header_matcher.regex_match = std::move(regex);
+    } else if (envoy_api_v2_route_HeaderMatcher_has_range_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::RANGE;
+      const envoy_type_Int64Range* range_matcher =
+          envoy_api_v2_route_HeaderMatcher_range_match(header);
+      header_matcher.range_start = envoy_type_Int64Range_start(range_matcher);
+      header_matcher.range_end = envoy_type_Int64Range_end(range_matcher);
+      if (header_matcher.range_end < header_matcher.range_start) {
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "Invalid range header matcher specifier specified: end "
+            "cannot be smaller than start.");
+      }
+    } else if (envoy_api_v2_route_HeaderMatcher_has_present_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::PRESENT;
+      header_matcher.present_match =
+          envoy_api_v2_route_HeaderMatcher_present_match(header);
+    } else if (envoy_api_v2_route_HeaderMatcher_has_prefix_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::PREFIX;
+      header_matcher.string_matcher = UpbStringToStdString(
+          envoy_api_v2_route_HeaderMatcher_prefix_match(header));
+    } else if (envoy_api_v2_route_HeaderMatcher_has_suffix_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::SUFFIX;
+      header_matcher.string_matcher = UpbStringToStdString(
+          envoy_api_v2_route_HeaderMatcher_suffix_match(header));
+    } else {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "Invalid route header matcher specified.");
+    }
+    header_matcher.invert_match =
+        envoy_api_v2_route_HeaderMatcher_invert_match(header);
+    rds_route->matchers.header_matchers.emplace_back(std::move(header_matcher));
+  }
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error* RouteRuntimeFractionParse(
+    const envoy_api_v2_route_RouteMatch* match,
+    XdsApi::RdsUpdate::RdsRoute* rds_route) {
+  const envoy_api_v2_core_RuntimeFractionalPercent* runtime_fraction =
+      envoy_api_v2_route_RouteMatch_runtime_fraction(match);
+  if (runtime_fraction != nullptr) {
+    const envoy_type_FractionalPercent* fraction =
+        envoy_api_v2_core_RuntimeFractionalPercent_default_value(
+            runtime_fraction);
+    if (fraction != nullptr) {
+      uint32_t numerator = envoy_type_FractionalPercent_numerator(fraction);
+      const auto denominator =
+          static_cast<envoy_type_FractionalPercent_DenominatorType>(
+              envoy_type_FractionalPercent_denominator(fraction));
+      // Normalize to million.
+      switch (denominator) {
+        case envoy_type_FractionalPercent_HUNDRED:
+          numerator *= 10000;
+          break;
+        case envoy_type_FractionalPercent_TEN_THOUSAND:
+          numerator *= 100;
+          break;
+        case envoy_type_FractionalPercent_MILLION:
+          break;
+        default:
+          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "Unknown denominator type");
+      }
+      rds_route->matchers.fraction_per_million = numerator;
+    }
+  }
+  return GRPC_ERROR_NONE;
+}
+
 grpc_error* RouteActionParse(const envoy_api_v2_route_Route* route,
-                             XdsApi::RdsUpdate::RdsRoute* rds_route) {
+                             XdsApi::RdsUpdate::RdsRoute* rds_route,
+                             bool* ignore_route) {
   if (!envoy_api_v2_route_Route_has_route(route)) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "No RouteAction found in route.");
@@ -982,8 +1247,9 @@ grpc_error* RouteActionParse(const envoy_api_v2_route_Route* route,
           "RouteAction weighted_cluster has no valid clusters specified.");
     }
   } else {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "No cluster or weighted_clusters found in RouteAction.");
+    // No cluster or weighted_clusters found in RouteAction, ignore this route.
+    *ignore_route = true;
+    return GRPC_ERROR_NONE;
   }
   return GRPC_ERROR_NONE;
 }
@@ -991,8 +1257,7 @@ grpc_error* RouteActionParse(const envoy_api_v2_route_Route* route,
 grpc_error* RouteConfigParse(
     XdsClient* client, TraceFlag* tracer,
     const envoy_api_v2_RouteConfiguration* route_config,
-    const std::string& expected_server_name, const bool xds_routing_enabled,
-    XdsApi::RdsUpdate* rds_update) {
+    const std::string& expected_server_name, XdsApi::RdsUpdate* rds_update) {
   MaybeLogRouteConfiguration(client, tracer, route_config);
   // Get the virtual hosts.
   size_t size;
@@ -1052,93 +1317,36 @@ grpc_error* RouteConfigParse(
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "No route found in the virtual host.");
   }
-  // If xds_routing is not configured, only look at the last one in the route
-  // list (the default route)
-  if (!xds_routing_enabled) {
-    const envoy_api_v2_route_Route* route = routes[size - 1];
-    const envoy_api_v2_route_RouteMatch* match =
-        envoy_api_v2_route_Route_match(route);
-    XdsApi::RdsUpdate::RdsRoute rds_route;
-    // if xds routing is not enabled, we must be working on the default route;
-    // in this case, we must have an empty or single slash prefix.
-    if (!envoy_api_v2_route_RouteMatch_has_prefix(match)) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "No prefix field found in Default RouteMatch.");
-    }
-    const upb_strview prefix = envoy_api_v2_route_RouteMatch_prefix(match);
-    if (!upb_strview_eql(prefix, upb_strview_makez("")) &&
-        !upb_strview_eql(prefix, upb_strview_makez("/"))) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "Default route must have empty prefix.");
-    }
-    grpc_error* error = RouteActionParse(route, &rds_route);
-    if (error != GRPC_ERROR_NONE) return error;
-    rds_update->routes.emplace_back(std::move(rds_route));
-    return GRPC_ERROR_NONE;
-  }
   // Loop over the whole list of routes
   for (size_t i = 0; i < size; ++i) {
     const envoy_api_v2_route_Route* route = routes[i];
     const envoy_api_v2_route_RouteMatch* match =
         envoy_api_v2_route_Route_match(route);
-    XdsApi::RdsUpdate::RdsRoute rds_route;
-    if (envoy_api_v2_route_RouteMatch_has_prefix(match)) {
-      upb_strview prefix = envoy_api_v2_route_RouteMatch_prefix(match);
-      // Empty prefix "" is accepted.
-      if (prefix.size > 0) {
-        // Prefix "/" is accepted.
-        if (prefix.data[0] != '/') {
-          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "Prefix does not start with a /");
-        }
-        if (prefix.size > 1) {
-          std::vector<absl::string_view> prefix_elements = absl::StrSplit(
-              absl::string_view(prefix.data, prefix.size).substr(1),
-              absl::MaxSplits('/', 1));
-          if (prefix_elements.size() != 2) {
-            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "Prefix not in the required format of /service/");
-          } else if (!prefix_elements[1].empty()) {
-            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "Prefix does not end with a /");
-          } else if (prefix_elements[0].empty()) {
-            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "Prefix contains empty service name");
-          }
-          rds_route.service = std::string(prefix_elements[0]);
-        }
-      }
-    } else if (envoy_api_v2_route_RouteMatch_has_path(match)) {
-      upb_strview path = envoy_api_v2_route_RouteMatch_path(match);
-      if (path.size == 0) {
-        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "Path if set cannot be empty");
-      }
-      if (path.data[0] != '/') {
-        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "Path does not start with a /");
-      }
-      std::vector<absl::string_view> path_elements = absl::StrSplit(
-          absl::string_view(path.data, path.size).substr(1), '/');
-      if (path_elements.size() != 2) {
-        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "Path not in the required format of /service/method");
-      } else if (path_elements[0].empty()) {
-        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "Path contains empty service name");
-      } else if (path_elements[1].empty()) {
-        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "Path contains empty method name");
-      }
-      rds_route.service = std::string(path_elements[0]);
-      rds_route.method = std::string(path_elements[1]);
-    } else {
-      // Path specifier types will be supported, ignore but not reject until
-      // they are implemented.
+    size_t query_parameters_size;
+    static_cast<void>(envoy_api_v2_route_RouteMatch_query_parameters(
+        match, &query_parameters_size));
+    if (query_parameters_size > 0) {
       continue;
     }
-    grpc_error* error = RouteActionParse(route, &rds_route);
+    XdsApi::RdsUpdate::RdsRoute rds_route;
+    bool ignore_route = false;
+    grpc_error* error = RoutePathMatchParse(match, &rds_route, &ignore_route);
     if (error != GRPC_ERROR_NONE) return error;
+    if (ignore_route) continue;
+    error = RouteHeaderMatchersParse(match, &rds_route);
+    if (error != GRPC_ERROR_NONE) return error;
+    error = RouteRuntimeFractionParse(match, &rds_route);
+    if (error != GRPC_ERROR_NONE) return error;
+    error = RouteActionParse(route, &rds_route, &ignore_route);
+    if (error != GRPC_ERROR_NONE) return error;
+    if (ignore_route) continue;
+    const google_protobuf_BoolValue* case_sensitive =
+        envoy_api_v2_route_RouteMatch_case_sensitive(match);
+    if (case_sensitive != nullptr &&
+        !google_protobuf_BoolValue_value(case_sensitive)) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "case_sensitive if set must be set to true.");
+    }
     rds_update->routes.emplace_back(std::move(rds_route));
   }
   if (rds_update->routes.empty()) {
@@ -1150,7 +1358,6 @@ grpc_error* RouteConfigParse(
 grpc_error* LdsResponseParse(XdsClient* client, TraceFlag* tracer,
                              const envoy_api_v2_DiscoveryResponse* response,
                              const std::string& expected_server_name,
-                             const bool xds_routing_enabled,
                              absl::optional<XdsApi::LdsUpdate>* lds_update,
                              upb_arena* arena) {
   // Get the resources from the response.
@@ -1196,9 +1403,8 @@ grpc_error* LdsResponseParse(XdsClient* client, TraceFlag* tracer,
           envoy_config_filter_network_http_connection_manager_v2_HttpConnectionManager_route_config(
               http_connection_manager);
       XdsApi::RdsUpdate rds_update;
-      grpc_error* error =
-          RouteConfigParse(client, tracer, route_config, expected_server_name,
-                           xds_routing_enabled, &rds_update);
+      grpc_error* error = RouteConfigParse(client, tracer, route_config,
+                                           expected_server_name, &rds_update);
       if (error != GRPC_ERROR_NONE) return error;
       lds_update->emplace();
       (*lds_update)->rds_update.emplace(std::move(rds_update));
@@ -1240,7 +1446,6 @@ grpc_error* RdsResponseParse(
     const envoy_api_v2_DiscoveryResponse* response,
     const std::string& expected_server_name,
     const std::set<absl::string_view>& expected_route_configuration_names,
-    const bool xds_routing_enabled,
     absl::optional<XdsApi::RdsUpdate>* rds_update, upb_arena* arena) {
   // Get the resources from the response.
   size_t size;
@@ -1272,9 +1477,8 @@ grpc_error* RdsResponseParse(
     }
     // Parse the route_config.
     XdsApi::RdsUpdate local_rds_update;
-    grpc_error* error =
-        RouteConfigParse(client, tracer, route_config, expected_server_name,
-                         xds_routing_enabled, &local_rds_update);
+    grpc_error* error = RouteConfigParse(
+        client, tracer, route_config, expected_server_name, &local_rds_update);
     if (error != GRPC_ERROR_NONE) return error;
     rds_update->emplace(std::move(local_rds_update));
     return GRPC_ERROR_NONE;
@@ -1586,11 +1790,11 @@ grpc_error* XdsApi::ParseAdsResponse(
   // Parse the response according to the resource type.
   if (*type_url == kLdsTypeUrl) {
     return LdsResponseParse(client_, tracer_, response, expected_server_name,
-                            xds_routing_enabled_, lds_update, arena.ptr());
+                            lds_update, arena.ptr());
   } else if (*type_url == kRdsTypeUrl) {
     return RdsResponseParse(client_, tracer_, response, expected_server_name,
-                            expected_route_configuration_names,
-                            xds_routing_enabled_, rds_update, arena.ptr());
+                            expected_route_configuration_names, rds_update,
+                            arena.ptr());
   } else if (*type_url == kCdsTypeUrl) {
     return CdsResponseParse(client_, tracer_, response, expected_cluster_names,
                             cds_update_map, arena.ptr());