grpc 1.53.0 → 1.59.2

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

@@ -29,14 +29,15 @@
 #include "absl/types/variant.h"
 #include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.upb.h"
+#include "envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.upb.h"
 #include "envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.upb.h"
 #include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 
+#include <grpc/support/json.h>
+
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
@@ -53,7 +54,7 @@ class RoundRobinLbPolicyConfigFactory
       const XdsResourceType::DecodeContext& /*context*/,
       absl::string_view /*configuration*/, ValidationErrors* /*errors*/,
       int /*recursion_depth*/) override {
-    return Json::Object{{"round_robin", Json::Object()}};
+    return Json::Object{{"round_robin", Json::FromObject({})}};
   }
 
   absl::string_view type() override { return Type(); }
@@ -86,7 +87,7 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
             resource);
     if (enable_oob_load_report != nullptr &&
         google_protobuf_BoolValue_value(enable_oob_load_report)) {
-      config["enableOobLoadReport"] = true;
+      config["enableOobLoadReport"] = Json::FromBool(true);
     }
     // oob_reporting_period
     auto* duration_proto =
@@ -95,7 +96,7 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
     if (duration_proto != nullptr) {
       ValidationErrors::ScopedField field(errors, ".oob_reporting_period");
       Duration duration = ParseDuration(duration_proto, errors);
-      config["oobReportingPeriod"] = duration.ToJsonString();
+      config["oobReportingPeriod"] = Json::FromString(duration.ToJsonString());
     }
     // blackout_period
     duration_proto =
@@ -104,7 +105,7 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
     if (duration_proto != nullptr) {
       ValidationErrors::ScopedField field(errors, ".blackout_period");
       Duration duration = ParseDuration(duration_proto, errors);
-      config["blackoutPeriod"] = duration.ToJsonString();
+      config["blackoutPeriod"] = Json::FromString(duration.ToJsonString());
     }
     // weight_update_period
     duration_proto =
@@ -113,7 +114,7 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
     if (duration_proto != nullptr) {
       ValidationErrors::ScopedField field(errors, ".weight_update_period");
       Duration duration = ParseDuration(duration_proto, errors);
-      config["weightUpdatePeriod"] = duration.ToJsonString();
+      config["weightUpdatePeriod"] = Json::FromString(duration.ToJsonString());
     }
     // weight_expiration_period
     duration_proto =
@@ -122,10 +123,24 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
     if (duration_proto != nullptr) {
       ValidationErrors::ScopedField field(errors, ".weight_expiration_period");
       Duration duration = ParseDuration(duration_proto, errors);
-      config["weightExpirationPeriod"] = duration.ToJsonString();
+      config["weightExpirationPeriod"] =
+          Json::FromString(duration.ToJsonString());
+    }
+    // error_utilization_penalty
+    auto* error_utilization_penalty =
+        envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_error_utilization_penalty(
+            resource);
+    if (error_utilization_penalty != nullptr) {
+      ValidationErrors::ScopedField field(errors, ".error_utilization_penalty");
+      const float value =
+          google_protobuf_FloatValue_value(error_utilization_penalty);
+      if (value < 0.0) {
+        errors->AddError("value must be non-negative");
+      }
+      config["errorUtilizationPenalty"] = Json::FromNumber(value);
     }
     return Json::Object{
-        {"weighted_round_robin_experimental", std::move(config)}};
+        {"weighted_round_robin", Json::FromObject(std::move(config))}};
   }
 
   absl::string_view type() override { return Type(); }
@@ -187,10 +202,10 @@ class RingHashLbPolicyConfigFactory
     }
     return Json::Object{
         {"ring_hash_experimental",
-         Json::Object{
-             {"minRingSize", min_ring_size},
-             {"maxRingSize", max_ring_size},
-         }},
+         Json::FromObject({
+             {"minRingSize", Json::FromNumber(min_ring_size)},
+             {"maxRingSize", Json::FromNumber(max_ring_size)},
+         })},
     };
   }
 
@@ -228,7 +243,8 @@ class WrrLocalityLbPolicyConfigFactory
         context, endpoint_picking_policy, errors, recursion_depth + 1);
     return Json::Object{
         {"xds_wrr_locality_experimental",
-         Json::Object{{"childPolicy", std::move(child_policy)}}}};
+         Json::FromObject(
+             {{"childPolicy", Json::FromArray(std::move(child_policy))}})}};
   }
 
   absl::string_view type() override { return Type(); }
@@ -239,25 +255,44 @@ class WrrLocalityLbPolicyConfigFactory
   }
 };
 
+class PickFirstLbPolicyConfigFactory
+    : public XdsLbPolicyRegistry::ConfigFactory {
+ public:
+  Json::Object ConvertXdsLbPolicyConfig(
+      const XdsLbPolicyRegistry* /*registry*/,
+      const XdsResourceType::DecodeContext& context,
+      absl::string_view configuration, ValidationErrors* errors,
+      int /*recursion_depth*/) override {
+    const auto* resource =
+        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_parse(
+            configuration.data(), configuration.size(), context.arena);
+    if (resource == nullptr) {
+      errors->AddError("can't decode PickFirst LB policy config");
+      return {};
+    }
+    bool shuffle_address_list =
+        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_shuffle_address_list(
+            resource);
+    return Json::Object{
+        {"pick_first",
+         Json::FromObject({
+             {"shuffleAddressList", Json::FromBool(shuffle_address_list)},
+         })}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.pick_first.v3.PickFirst";
+  }
+};
+
 }  // namespace
 
 //
 // XdsLbPolicyRegistry
 //
 
-namespace {
-
-// TODO(roth): Remove this when interop tests pass.
-bool XdsWrrLbEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_WRR_LB");
-  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;
-}
-
-}  // namespace
-
 XdsLbPolicyRegistry::XdsLbPolicyRegistry() {
   policy_config_factories_.emplace(
       RingHashLbPolicyConfigFactory::Type(),
@@ -265,14 +300,15 @@ XdsLbPolicyRegistry::XdsLbPolicyRegistry() {
   policy_config_factories_.emplace(
       RoundRobinLbPolicyConfigFactory::Type(),
       std::make_unique<RoundRobinLbPolicyConfigFactory>());
-  if (XdsWrrLbEnabled()) {
-    policy_config_factories_.emplace(
-        ClientSideWeightedRoundRobinLbPolicyConfigFactory::Type(),
-        std::make_unique<ClientSideWeightedRoundRobinLbPolicyConfigFactory>());
-  }
+  policy_config_factories_.emplace(
+      ClientSideWeightedRoundRobinLbPolicyConfigFactory::Type(),
+      std::make_unique<ClientSideWeightedRoundRobinLbPolicyConfigFactory>());
   policy_config_factories_.emplace(
       WrrLocalityLbPolicyConfigFactory::Type(),
       std::make_unique<WrrLocalityLbPolicyConfigFactory>());
+  policy_config_factories_.emplace(
+      PickFirstLbPolicyConfigFactory::Type(),
+      std::make_unique<PickFirstLbPolicyConfigFactory>());
 }
 
 Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
@@ -311,8 +347,9 @@ Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
     if (serialized_value != nullptr) {
       auto config_factory_it = policy_config_factories_.find(extension->type);
       if (config_factory_it != policy_config_factories_.end()) {
-        return Json::Array{config_factory_it->second->ConvertXdsLbPolicyConfig(
-            this, context, *serialized_value, errors, recursion_depth)};
+        return Json::Array{Json::FromObject(
+            config_factory_it->second->ConvertXdsLbPolicyConfig(
+                this, context, *serialized_value, errors, recursion_depth))};
       }
     }
     // Check for custom LB policy type.
@@ -321,7 +358,7 @@ Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
         CoreConfiguration::Get().lb_policy_registry().LoadBalancingPolicyExists(
             extension->type, nullptr)) {
       return Json::Array{
-          Json::Object{{std::string(extension->type), std::move(*json)}}};
+          Json::FromObject({{std::string(extension->type), std::move(*json)}})};
     }
     // Unsupported type.  Continue to next entry.
   }

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

@@ -37,6 +37,7 @@
 #include "envoy/config/listener/v3/listener.upb.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/config/listener/v3/listener_components.upb.h"
+#include "envoy/config/rbac/v3/rbac.upb.h"
 #include "envoy/config/route/v3/route.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
@@ -44,8 +45,8 @@
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "upb/text_encode.h"
-#include "upb/upb.h"
+#include "upb/base/string_view.h"
+#include "upb/text/encode.h"
 
 #include <grpc/support/log.h>
 
@@ -73,8 +74,8 @@ std::string XdsListenerResource::HttpConnectionManager::ToString() const {
       [](const std::string& rds_name) {
         return absl::StrCat("rds_name=", rds_name);
       },
-      [](const XdsRouteConfigResource& route_config) {
-        return absl::StrCat("route_config=", route_config.ToString());
+      [](const std::shared_ptr<const XdsRouteConfigResource>& route_config) {
+        return absl::StrCat("route_config=", route_config->ToString());
       }));
   contents.push_back(absl::StrCat("http_max_stream_duration=",
                                   http_max_stream_duration.ToString()));
@@ -489,20 +490,24 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
   return http_connection_manager;
 }
 
-absl::StatusOr<XdsListenerResource> LdsResourceParseClient(
+absl::StatusOr<std::shared_ptr<const XdsListenerResource>>
+LdsResourceParseClient(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_listener_v3_ApiListener* api_listener) {
-  XdsListenerResource lds_update;
+  auto lds_update = std::make_shared<XdsListenerResource>();
   ValidationErrors errors;
   ValidationErrors::ScopedField field(&errors, "api_listener.api_listener");
   auto* api_listener_field =
       envoy_config_listener_v3_ApiListener_api_listener(api_listener);
   auto extension = ExtractXdsExtension(context, api_listener_field, &errors);
   if (extension.has_value()) {
-    lds_update.listener = HttpConnectionManagerParse(
+    lds_update->listener = HttpConnectionManagerParse(
         /*is_client=*/true, context, std::move(*extension), &errors);
   }
-  if (!errors.ok()) return errors.status("errors validating ApiListener");
+  if (!errors.ok()) {
+    return errors.status(absl::StatusCode::kInvalidArgument,
+                         "errors validating ApiListener");
+  }
   return std::move(lds_update);
 }
 
@@ -987,9 +992,9 @@ XdsListenerResource::FilterChainMap BuildFilterChainMap(
   return BuildFromInternalFilterChainMap(&internal_filter_chain_map);
 }
 
-absl::StatusOr<XdsListenerResource> LdsResourceParseServer(
-    const XdsResourceType::DecodeContext& context,
-    const envoy_config_listener_v3_Listener* listener) {
+absl::StatusOr<std::shared_ptr<const XdsListenerResource>>
+LdsResourceParseServer(const XdsResourceType::DecodeContext& context,
+                       const envoy_config_listener_v3_Listener* listener) {
   ValidationErrors errors;
   XdsListenerResource::TcpListener tcp_listener;
   // address
@@ -1046,13 +1051,16 @@ absl::StatusOr<XdsListenerResource> LdsResourceParseServer(
     }
   }
   // Return result.
-  if (!errors.ok()) return errors.status("errors validating server Listener");
-  XdsListenerResource lds_update;
-  lds_update.listener = std::move(tcp_listener);
+  if (!errors.ok()) {
+    return errors.status(absl::StatusCode::kInvalidArgument,
+                         "errors validating server Listener");
+  }
+  auto lds_update = std::make_shared<XdsListenerResource>();
+  lds_update->listener = std::move(tcp_listener);
   return lds_update;
 }
 
-absl::StatusOr<XdsListenerResource> LdsResourceParse(
+absl::StatusOr<std::shared_ptr<const XdsListenerResource>> LdsResourceParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_listener_v3_Listener* listener) {
   // Check whether it's a client or server listener.
@@ -1120,10 +1128,9 @@ XdsResourceType::DecodeResult XdsListenerResourceType::Decode(
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed Listener %s: %s",
               context.client, result.name->c_str(),
-              listener->ToString().c_str());
+              (*listener)->ToString().c_str());
     }
-    result.resource =
-        std::make_unique<XdsListenerResource>(std::move(*listener));
+    result.resource = std::move(*listener);
   }
   return result;
 }

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

@@ -34,7 +34,7 @@
 #include "absl/types/variant.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
-#include "upb/def.h"
+#include "upb/reflection/def.h"
 
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
@@ -51,7 +51,8 @@ namespace grpc_core {
 struct XdsListenerResource : public XdsResourceType::ResourceData {
   struct HttpConnectionManager {
     // The RDS resource name or inline RouteConfiguration.
-    absl::variant<std::string, XdsRouteConfigResource> route_config;
+    absl::variant<std::string, std::shared_ptr<const XdsRouteConfigResource>>
+        route_config;
 
     // Storing the Http Connection Manager Common Http Protocol Option
     // max_stream_duration
@@ -70,8 +71,17 @@ struct XdsListenerResource : public XdsResourceType::ResourceData {
     std::vector<HttpFilter> http_filters;
 
     bool operator==(const HttpConnectionManager& other) const {
-      return route_config == other.route_config &&
-             http_max_stream_duration == other.http_max_stream_duration &&
+      if (absl::holds_alternative<std::string>(route_config)) {
+        if (route_config != other.route_config) return false;
+      } else {
+        auto& rc1 = absl::get<std::shared_ptr<const XdsRouteConfigResource>>(
+            route_config);
+        auto* rc2 = absl::get_if<std::shared_ptr<const XdsRouteConfigResource>>(
+            &other.route_config);
+        if (rc2 == nullptr) return false;
+        if (!(*rc1 == **rc2)) return false;
+      }
+      return http_max_stream_duration == other.http_max_stream_duration &&
              http_filters == other.http_filters;
     }
 

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

@@ -24,8 +24,8 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "upb/arena.h"
-#include "upb/def.h"
+#include "upb/mem/arena.h"
+#include "upb/reflection/def.h"
 
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/lib/debug/trace.h"
@@ -61,7 +61,7 @@ class XdsResourceType {
     // non-OK status.
     absl::optional<std::string> name;
     // The parsed and validated resource, or an error status.
-    absl::StatusOr<std::unique_ptr<ResourceData>> resource;
+    absl::StatusOr<std::shared_ptr<const ResourceData>> resource;
   };
 
   virtual ~XdsResourceType() = default;
@@ -79,12 +79,6 @@ class XdsResourceType {
   virtual bool ResourcesEqual(const ResourceData* r1,
                               const ResourceData* r2) const = 0;
 
-  // Returns a copy of resource.
-  // Must be invoked only on resources returned by this object's Decode()
-  // method.
-  virtual std::unique_ptr<ResourceData> CopyResource(
-      const ResourceData* resource) const = 0;
-
   // Indicates whether the resource type requires that all resources must
   // be present in every SotW response from the server.  If true, a
   // response that does not include a previously seen resource will be

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

@@ -19,6 +19,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <utility>
 
 #include "absl/strings/string_view.h"
 
@@ -30,8 +31,8 @@ namespace grpc_core {
 
 // Base class for XdsResourceType implementations.
 // Handles all down-casting logic for a particular resource type struct.
-// ResourceTypeStruct must inherit from XdsResourceType::ResourceData,
-// must be copy-constructible, and must implement operator==().
+// ResourceTypeStruct must inherit from XdsResourceType::ResourceData
+// and must implement operator==().
 template <typename Subclass, typename ResourceTypeStruct>
 class XdsResourceTypeImpl : public XdsResourceType {
  public:
@@ -40,14 +41,17 @@ class XdsResourceTypeImpl : public XdsResourceType {
   // XdsClient watcher that handles down-casting.
   class WatcherInterface : public XdsClient::ResourceWatcherInterface {
    public:
-    virtual void OnResourceChanged(ResourceType listener) = 0;
+    virtual void OnResourceChanged(
+        std::shared_ptr<const ResourceType> resource) = 0;
 
    private:
     // Get result from XdsClient generic watcher interface, perform
     // down-casting, and invoke the caller's OnResourceChanged() method.
     void OnGenericResourceChanged(
-        const XdsResourceType::ResourceData* resource) override {
-      OnResourceChanged(*static_cast<const ResourceType*>(resource));
+        std::shared_ptr<const XdsResourceType::ResourceData> resource)
+        override {
+      OnResourceChanged(
+          std::static_pointer_cast<const ResourceType>(std::move(resource)));
     }
   };
 
@@ -75,12 +79,6 @@ class XdsResourceTypeImpl : public XdsResourceType {
     return *static_cast<const ResourceType*>(r1) ==
            *static_cast<const ResourceType*>(r2);
   }
-
-  std::unique_ptr<ResourceData> CopyResource(
-      const ResourceData* resource) const override {
-    return std::make_unique<ResourceType>(
-        *static_cast<const ResourceType*>(resource));
-  }
 };
 
 }  // namespace grpc_core

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

@@ -45,15 +45,16 @@
 #include "envoy/config/route/v3/route.upbdefs.h"
 #include "envoy/config/route/v3/route_components.upb.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/base/string_view.h"
+#include "upb/collections/map.h"
+#include "upb/text/encode.h"
 
 #include <grpc/status.h>
 #include <grpc/support/log.h>
@@ -73,15 +74,16 @@
 #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/load_balancing/lb_policy_registry.h"
 #include "src/core/lib/matchers/matchers.h"
 
 namespace grpc_core {
 
-// TODO(donnadionne): Remove once RLS is no longer experimental
+// TODO(apolcyn): remove this flag by the 1.58 release
 bool XdsRlsEnabled() {
   auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_RLS_LB");
-  if (!value.has_value()) return false;
+  if (!value.has_value()) return true;
   bool parsed_value;
   bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
   return parse_succeeded && parsed_value;
@@ -347,6 +349,10 @@ XdsRouteConfigResource::ClusterSpecifierPluginMap ClusterSpecifierPluginParse(
     const envoy_config_core_v3_TypedExtensionConfig* typed_extension_config =
         envoy_config_route_v3_ClusterSpecifierPlugin_extension(
             cluster_specifier_plugin[i]);
+    if (typed_extension_config == nullptr) {
+      errors->AddError("field not present");
+      continue;
+    }
     std::string name = UpbStringToStdString(
         envoy_config_core_v3_TypedExtensionConfig_name(typed_extension_config));
     if (cluster_specifier_plugin_map.find(name) !=
@@ -392,7 +398,8 @@ XdsRouteConfigResource::ClusterSpecifierPluginMap ClusterSpecifierPluginParse(
           "ClusterSpecifierPlugin returned invalid LB policy config: ",
           config.status().message()));
     } else {
-      cluster_specifier_plugin_map[std::move(name)] = lb_policy_config.Dump();
+      cluster_specifier_plugin_map[std::move(name)] =
+          JsonDump(lb_policy_config);
     }
   }
   return cluster_specifier_plugin_map;
@@ -484,6 +491,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
     int64_t range_start = 0;
     int64_t range_end = 0;
     bool present_match = false;
+    bool case_sensitive = true;
     if (envoy_config_route_v3_HeaderMatcher_has_exact_match(header)) {
       type = HeaderMatcher::Type::kExact;
       match_string = UpbStringToStdString(
@@ -512,11 +520,46 @@ 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);
       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)) {
       type = HeaderMatcher::Type::kPresent;
       present_match = envoy_config_route_v3_HeaderMatcher_present_match(header);
+    } else if (envoy_config_route_v3_HeaderMatcher_has_string_match(header)) {
+      ValidationErrors::ScopedField field(errors, ".string_match");
+      const auto* matcher =
+          envoy_config_route_v3_HeaderMatcher_string_match(header);
+      GPR_ASSERT(matcher != nullptr);
+      if (envoy_type_matcher_v3_StringMatcher_has_exact(matcher)) {
+        type = HeaderMatcher::Type::kExact;
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_StringMatcher_exact(matcher));
+      } else if (envoy_type_matcher_v3_StringMatcher_has_prefix(matcher)) {
+        type = HeaderMatcher::Type::kPrefix;
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_StringMatcher_prefix(matcher));
+      } else if (envoy_type_matcher_v3_StringMatcher_has_suffix(matcher)) {
+        type = HeaderMatcher::Type::kSuffix;
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_StringMatcher_suffix(matcher));
+      } else if (envoy_type_matcher_v3_StringMatcher_has_contains(matcher)) {
+        type = HeaderMatcher::Type::kContains;
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_StringMatcher_contains(matcher));
+      } else if (envoy_type_matcher_v3_StringMatcher_has_safe_regex(matcher)) {
+        type = HeaderMatcher::Type::kSafeRegex;
+        const auto* regex_matcher =
+            envoy_type_matcher_v3_StringMatcher_safe_regex(matcher);
+        GPR_ASSERT(regex_matcher != nullptr);
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
+      } else {
+        errors->AddError("invalid string matcher");
+        continue;
+      }
+      case_sensitive =
+          !envoy_type_matcher_v3_StringMatcher_ignore_case(matcher);
     } else {
       errors->AddError("invalid header matcher");
       continue;
@@ -525,7 +568,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
         envoy_config_route_v3_HeaderMatcher_invert_match(header);
     absl::StatusOr<HeaderMatcher> header_matcher =
         HeaderMatcher::Create(name, type, match_string, range_start, range_end,
-                              present_match, invert_match);
+                              present_match, invert_match, case_sensitive);
     if (!header_matcher.ok()) {
       errors->AddError(absl::StrCat("cannot create header matcher: ",
                                     header_matcher.status().message()));
@@ -993,20 +1036,20 @@ absl::optional<XdsRouteConfigResource::Route> ParseRoute(
 
 }  // namespace
 
-XdsRouteConfigResource XdsRouteConfigResource::Parse(
+std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResource::Parse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RouteConfiguration* route_config,
     ValidationErrors* errors) {
-  XdsRouteConfigResource rds_update;
+  auto rds_update = std::make_shared<XdsRouteConfigResource>();
   // Get the cluster spcifier plugin map.
   if (XdsRlsEnabled()) {
-    rds_update.cluster_specifier_plugin_map =
+    rds_update->cluster_specifier_plugin_map =
         ClusterSpecifierPluginParse(context, route_config, errors);
   }
   // Build a set of configured cluster_specifier_plugin names to make sure
   // each is actually referenced by a route action.
   std::set<absl::string_view> cluster_specifier_plugins_not_seen;
-  for (auto& plugin : rds_update.cluster_specifier_plugin_map) {
+  for (auto& plugin : rds_update->cluster_specifier_plugin_map) {
     cluster_specifier_plugins_not_seen.emplace(plugin.first);
   }
   // Get the virtual hosts.
@@ -1017,9 +1060,9 @@ XdsRouteConfigResource XdsRouteConfigResource::Parse(
   for (size_t i = 0; i < num_virtual_hosts; ++i) {
     ValidationErrors::ScopedField field(
         errors, absl::StrCat(".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(
@@ -1068,7 +1111,7 @@ XdsRouteConfigResource XdsRouteConfigResource::Parse(
     for (size_t j = 0; j < num_routes; ++j) {
       ValidationErrors::ScopedField field(errors, absl::StrCat("[", j, "]"));
       auto route = ParseRoute(context, routes[j], virtual_host_retry_policy,
-                              rds_update.cluster_specifier_plugin_map,
+                              rds_update->cluster_specifier_plugin_map,
                               &cluster_specifier_plugins_not_seen, errors);
       if (route.has_value()) vhost.routes.emplace_back(std::move(*route));
     }
@@ -1076,7 +1119,7 @@ XdsRouteConfigResource XdsRouteConfigResource::Parse(
   // For cluster specifier plugins that were not used in any route action,
   // delete them from the update, since they will never be used.
   for (auto& unused_plugin : cluster_specifier_plugins_not_seen) {
-    rds_update.cluster_specifier_plugin_map.erase(std::string(unused_plugin));
+    rds_update->cluster_specifier_plugin_map.erase(std::string(unused_plugin));
   }
   return rds_update;
 }
@@ -1123,7 +1166,8 @@ XdsResourceType::DecodeResult XdsRouteConfigResourceType::Decode(
   auto rds_update = XdsRouteConfigResource::Parse(context, resource, &errors);
   if (!errors.ok()) {
     absl::Status status =
-        errors.status("errors validating RouteConfiguration resource");
+        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());
@@ -1133,10 +1177,9 @@ XdsResourceType::DecodeResult XdsRouteConfigResourceType::Decode(
     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());
+              rds_update->ToString().c_str());
     }
-    result.resource =
-        std::make_unique<XdsRouteConfigResource>(std::move(rds_update));
+    result.resource = std::move(rds_update);
   }
   return result;
 }

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

@@ -33,7 +33,7 @@
 #include "envoy/config/route/v3/route.upb.h"
 #include "envoy/config/route/v3/route.upbdefs.h"
 #include "re2/re2.h"
-#include "upb/def.h"
+#include "upb/reflection/def.h"
 
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
@@ -220,7 +220,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
   }
   std::string ToString() const;
 
-  static XdsRouteConfigResource Parse(
+  static std::shared_ptr<const XdsRouteConfigResource> Parse(
       const XdsResourceType::DecodeContext& context,
       const envoy_config_route_v3_RouteConfiguration* route_config,
       ValidationErrors* errors);