grpc 1.30.1 → 1.32.0.pre1

data/src/core/ext/filters/client_channel/lb_policy/xds/cds.cc

@@ -24,11 +24,12 @@
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
-#include "src/core/ext/filters/client_channel/xds/xds_client.h"
+#include "src/core/ext/xds/xds_client.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/transport/error_utils.h"
 
 namespace grpc_core {
 
@@ -79,7 +80,7 @@ class CdsLb : public LoadBalancingPolicy {
     explicit Helper(RefCountedPtr<CdsLb> parent) : parent_(std::move(parent)) {}
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
         const grpc_channel_args& args) override;
-    void UpdateState(grpc_connectivity_state state,
+    void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      std::unique_ptr<SubchannelPicker> picker) override;
     void RequestReresolution() override;
     void AddTraceEvent(TraceSeverity severity,
@@ -209,7 +210,7 @@ void CdsLb::ClusterWatcher::OnError(grpc_error* error) {
   // we keep running with the data we had previously.
   if (parent_->child_policy_ == nullptr) {
     parent_->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE,
+        GRPC_CHANNEL_TRANSIENT_FAILURE, grpc_error_to_absl_status(error),
         absl::make_unique<TransientFailurePicker>(error));
   } else {
     GRPC_ERROR_UNREF(error);
@@ -221,13 +222,15 @@ void CdsLb::ClusterWatcher::OnResourceDoesNotExist() {
           "[cdslb %p] CDS resource for %s does not exist -- reporting "
           "TRANSIENT_FAILURE",
           parent_.get(), parent_->config_->cluster().c_str());
+  grpc_error* error = grpc_error_set_int(
+      GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrCat("CDS resource \"", parent_->config_->cluster(),
+                       "\" does not exist")
+              .c_str()),
+      GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
   parent_->channel_control_helper()->UpdateState(
-      GRPC_CHANNEL_TRANSIENT_FAILURE,
-      absl::make_unique<TransientFailurePicker>(
-          GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-              absl::StrCat("CDS resource \"", parent_->config_->cluster(),
-                           "\" does not exist")
-                  .c_str())));
+      GRPC_CHANNEL_TRANSIENT_FAILURE, grpc_error_to_absl_status(error),
+      absl::make_unique<TransientFailurePicker>(error));
   parent_->MaybeDestroyChildPolicyLocked();
 }
 
@@ -242,13 +245,16 @@ RefCountedPtr<SubchannelInterface> CdsLb::Helper::CreateSubchannel(
 }
 
 void CdsLb::Helper::UpdateState(grpc_connectivity_state state,
+                                const absl::Status& status,
                                 std::unique_ptr<SubchannelPicker> picker) {
   if (parent_->shutting_down_ || parent_->child_policy_ == nullptr) return;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
-    gpr_log(GPR_INFO, "[cdslb %p] state updated by child: %s", this,
-            ConnectivityStateName(state));
+    gpr_log(GPR_INFO,
+            "[cdslb %p] state updated by child: %s message_state: (%s)", this,
+            ConnectivityStateName(state), status.ToString().c_str());
   }
-  parent_->channel_control_helper()->UpdateState(state, std::move(picker));
+  parent_->channel_control_helper()->UpdateState(state, status,
+                                                 std::move(picker));
 }
 
 void CdsLb::Helper::RequestReresolution() {

data/src/core/ext/filters/client_channel/lb_policy/xds/eds.cc

@@ -32,14 +32,15 @@
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/ext/filters/client_channel/xds/xds_channel_args.h"
-#include "src/core/ext/filters/client_channel/xds/xds_client.h"
-#include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
+#include "src/core/ext/xds/xds_channel_args.h"
+#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 #define GRPC_EDS_DEFAULT_FALLBACK_TIMEOUT 10000
@@ -133,7 +134,7 @@ class EdsLb : public LoadBalancingPolicy {
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
         const grpc_channel_args& args) override;
-    void UpdateState(grpc_connectivity_state state,
+    void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      std::unique_ptr<SubchannelPicker> picker) override;
     // This is a no-op, because we get the addresses from the xds
     // client, which is a watch-based API.
@@ -214,6 +215,7 @@ class EdsLb : public LoadBalancingPolicy {
 
   // The latest state and picker returned from the child policy.
   grpc_connectivity_state child_state_;
+  absl::Status child_status_;
   RefCountedPtr<ChildPickerWrapper> child_picker_;
 };
 
@@ -265,16 +267,21 @@ RefCountedPtr<SubchannelInterface> EdsLb::Helper::CreateSubchannel(
 }
 
 void EdsLb::Helper::UpdateState(grpc_connectivity_state state,
+                                const absl::Status& status,
                                 std::unique_ptr<SubchannelPicker> picker) {
   if (eds_policy_->shutting_down_ || eds_policy_->child_policy_ == nullptr) {
     return;
   }
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_eds_trace)) {
-    gpr_log(GPR_INFO, "[edslb %p] child policy updated state=%s picker=%p",
-            eds_policy_.get(), ConnectivityStateName(state), picker.get());
+    gpr_log(GPR_INFO,
+            "[edslb %p] child policy updated state=%s (%s) "
+            "picker=%p",
+            eds_policy_.get(), ConnectivityStateName(state),
+            status.ToString().c_str(), picker.get());
   }
   // Save the state and picker.
   eds_policy_->child_state_ = state;
+  eds_policy_->child_status_ = status;
   eds_policy_->child_picker_ =
       MakeRefCounted<ChildPickerWrapper>(std::move(picker));
   // Wrap the picker in a DropPicker and pass it up.
@@ -339,7 +346,7 @@ class EdsLb::EndpointWatcher : public XdsClient::EndpointWatcherInterface {
     // we keep running with the data we had previously.
     if (eds_policy_->child_policy_ == nullptr) {
       eds_policy_->channel_control_helper()->UpdateState(
-          GRPC_CHANNEL_TRANSIENT_FAILURE,
+          GRPC_CHANNEL_TRANSIENT_FAILURE, grpc_error_to_absl_status(error),
           absl::make_unique<TransientFailurePicker>(error));
     } else {
       GRPC_ERROR_UNREF(error);
@@ -351,11 +358,12 @@ class EdsLb::EndpointWatcher : public XdsClient::EndpointWatcherInterface {
         GPR_ERROR,
         "[edslb %p] EDS resource does not exist -- reporting TRANSIENT_FAILURE",
         eds_policy_.get());
+    grpc_error* error = grpc_error_set_int(
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("EDS resource does not exist"),
+        GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
     eds_policy_->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE,
-        absl::make_unique<TransientFailurePicker>(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "EDS resource does not exist")));
+        GRPC_CHANNEL_TRANSIENT_FAILURE, grpc_error_to_absl_status(error),
+        absl::make_unique<TransientFailurePicker>(error));
     eds_policy_->MaybeDestroyChildPolicyLocked();
   }
 
@@ -688,7 +696,7 @@ EdsLb::CreateChildPolicyConfigLocked() {
             error),
         GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_INTERNAL);
     channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE,
+        GRPC_CHANNEL_TRANSIENT_FAILURE, grpc_error_to_absl_status(error),
         absl::make_unique<TransientFailurePicker>(error));
     return nullptr;
   }
@@ -769,13 +777,13 @@ void EdsLb::MaybeUpdateDropPickerLocked() {
   // If we're dropping all calls, report READY, regardless of what (or
   // whether) the child has reported.
   if (drop_config_ != nullptr && drop_config_->drop_all()) {
-    channel_control_helper()->UpdateState(GRPC_CHANNEL_READY,
+    channel_control_helper()->UpdateState(GRPC_CHANNEL_READY, absl::Status(),
                                           absl::make_unique<DropPicker>(this));
     return;
   }
   // Update only if we have a child picker.
   if (child_picker_ != nullptr) {
-    channel_control_helper()->UpdateState(child_state_,
+    channel_control_helper()->UpdateState(child_state_, child_status_,
                                           absl::make_unique<DropPicker>(this));
   }
 }

data/src/core/ext/filters/client_channel/lb_policy/xds/lrs.cc

@@ -22,8 +22,8 @@
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/ext/filters/client_channel/xds/xds_client.h"
-#include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
+#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -120,7 +120,7 @@ class LrsLb : public LoadBalancingPolicy {
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
         const grpc_channel_args& args) override;
-    void UpdateState(grpc_connectivity_state state,
+    void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      std::unique_ptr<SubchannelPicker> picker) override;
     void RequestReresolution() override;
     void AddTraceEvent(TraceSeverity severity,
@@ -157,6 +157,7 @@ class LrsLb : public LoadBalancingPolicy {
 
   // Latest state and picker reported by the child policy.
   grpc_connectivity_state state_ = GRPC_CHANNEL_IDLE;
+  absl::Status status_;
   RefCountedPtr<RefCountedPicker> picker_;
 };
 
@@ -266,10 +267,14 @@ void LrsLb::MaybeUpdatePickerLocked() {
     auto lrs_picker =
         absl::make_unique<LoadReportingPicker>(picker_, locality_stats_);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_lrs_trace)) {
-      gpr_log(GPR_INFO, "[lrs_lb %p] updating connectivity: state=%s picker=%p",
-              this, ConnectivityStateName(state_), lrs_picker.get());
+      gpr_log(
+          GPR_INFO,
+          "[lrs_lb %p] updating connectivity: state=%s status=(%s) picker=%p",
+          this, ConnectivityStateName(state_), status_.ToString().c_str(),
+          lrs_picker.get());
     }
-    channel_control_helper()->UpdateState(state_, std::move(lrs_picker));
+    channel_control_helper()->UpdateState(state_, status_,
+                                          std::move(lrs_picker));
   }
 }
 
@@ -325,15 +330,19 @@ RefCountedPtr<SubchannelInterface> LrsLb::Helper::CreateSubchannel(
 }
 
 void LrsLb::Helper::UpdateState(grpc_connectivity_state state,
+                                const absl::Status& status,
                                 std::unique_ptr<SubchannelPicker> picker) {
   if (lrs_policy_->shutting_down_) return;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_lrs_trace)) {
-    gpr_log(GPR_INFO,
-            "[lrs_lb %p] child connectivity state update: state=%s picker=%p",
-            lrs_policy_.get(), ConnectivityStateName(state), picker.get());
+    gpr_log(
+        GPR_INFO,
+        "[lrs_lb %p] child connectivity state update: state=%s (%s) picker=%p",
+        lrs_policy_.get(), ConnectivityStateName(state),
+        status.ToString().c_str(), picker.get());
   }
   // Save the state and picker.
   lrs_policy_->state_ = state;
+  lrs_policy_->status_ = status;
   lrs_policy_->picker_ = MakeRefCounted<RefCountedPicker>(std::move(picker));
   // Wrap the picker and return it to the channel.
   lrs_policy_->MaybeUpdatePickerLocked();

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_routing.cc

@@ -20,9 +20,14 @@
 #include <limits.h>
 #include <string.h>
 
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
+#include "re2/re2.h"
 
 #include <grpc/grpc.h>
 
@@ -30,12 +35,14 @@
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
+#include "src/core/ext/xds/xds_api.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/transport/error_utils.h"
 
 #define GRPC_XDS_ROUTING_CHILD_RETENTION_INTERVAL_MS (15 * 60 * 1000)
 
@@ -50,12 +57,8 @@ constexpr char kXdsRouting[] = "xds_routing_experimental";
 // Config for xds_routing LB policy.
 class XdsRoutingLbConfig : public LoadBalancingPolicy::Config {
  public:
-  struct Matcher {
-    std::string service;
-    std::string method;
-  };
   struct Route {
-    Matcher matcher;
+    XdsApi::Route::Matchers matchers;
     std::string action;
   };
   using RouteTable = std::vector<Route>;
@@ -109,20 +112,24 @@ class XdsRoutingLb : public LoadBalancingPolicy {
   class RoutePicker : public SubchannelPicker {
    public:
     struct Route {
-      XdsRoutingLbConfig::Matcher matcher;
+      const XdsApi::Route::Matchers* matchers;
       RefCountedPtr<ChildPickerWrapper> picker;
     };
 
     // Maintains an ordered xds route table as provided by RDS response.
     using RouteTable = std::vector<Route>;
 
-    explicit RoutePicker(RouteTable route_table)
-        : route_table_(std::move(route_table)) {}
+    RoutePicker(RouteTable route_table,
+                RefCountedPtr<XdsRoutingLbConfig> config)
+        : route_table_(std::move(route_table)), config_(std::move(config)) {}
 
     PickResult Pick(PickArgs args) override;
 
    private:
     RouteTable route_table_;
+    // Take a reference to config so that we can use
+    // XdsApi::Route::Matchers from it.
+    RefCountedPtr<XdsRoutingLbConfig> config_;
   };
 
   // Each XdsRoutingChild holds a ref to its parent XdsRoutingLb.
@@ -159,6 +166,7 @@ class XdsRoutingLb : public LoadBalancingPolicy {
       RefCountedPtr<SubchannelInterface> CreateSubchannel(
           const grpc_channel_args& args) override;
       void UpdateState(grpc_connectivity_state state,
+                       const absl::Status& status,
                        std::unique_ptr<SubchannelPicker> picker) override;
       void RequestReresolution() override;
       void AddTraceEvent(TraceSeverity severity,
@@ -179,7 +187,7 @@ class XdsRoutingLb : public LoadBalancingPolicy {
     RefCountedPtr<XdsRoutingLb> xds_routing_policy_;
 
     // Points to the corresponding key in XdsRoutingLb::actions_.
-    const std::string& name_;
+    const std::string name_;
 
     OrphanablePtr<LoadBalancingPolicy> child_policy_;
 
@@ -214,26 +222,121 @@ class XdsRoutingLb : public LoadBalancingPolicy {
 // XdsRoutingLb::RoutePicker
 //
 
-XdsRoutingLb::PickResult XdsRoutingLb::RoutePicker::Pick(PickArgs args) {
-  absl::string_view path;
-  // TODO(roth): Using const auto& here trigger a warning in a macos or windows
-  // build:
-  //*(args.initial_metadata) is returning values not references.
-  for (const auto p : *(args.initial_metadata)) {
-    if (p.first == ":path") {
-      path = p.second;
-      break;
+bool PathMatch(const absl::string_view& path,
+               const XdsApi::Route::Matchers::PathMatcher& path_matcher) {
+  switch (path_matcher.type) {
+    case XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PREFIX:
+      return absl::StartsWith(path, path_matcher.string_matcher);
+    case XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PATH:
+      return path == path_matcher.string_matcher;
+    case XdsApi::Route::Matchers::PathMatcher::PathMatcherType::REGEX:
+      return RE2::FullMatch(path.data(), *path_matcher.regex_matcher);
+    default:
+      return false;
+  }
+}
+
+absl::optional<absl::string_view> GetMetadataValue(
+    const std::string& key,
+    LoadBalancingPolicy::MetadataInterface* initial_metadata,
+    std::string* concatenated_value) {
+  // Find all values for the specified key.
+  GPR_DEBUG_ASSERT(initial_metadata != nullptr);
+  absl::InlinedVector<absl::string_view, 1> values;
+  for (const auto p : *initial_metadata) {
+    if (p.first == key) values.push_back(p.second);
+  }
+  // If none found, no match.
+  if (values.empty()) return absl::nullopt;
+  // If exactly one found, return it as-is.
+  if (values.size() == 1) return values.front();
+  // If more than one found, concatenate the values, using
+  // *concatenated_values as a temporary holding place for the
+  // concatenated string.
+  *concatenated_value = absl::StrJoin(values, ",");
+  return *concatenated_value;
+}
+
+bool HeaderMatchHelper(
+    const XdsApi::Route::Matchers::HeaderMatcher& header_matcher,
+    LoadBalancingPolicy::MetadataInterface* initial_metadata) {
+  std::string concatenated_value;
+  absl::optional<absl::string_view> value;
+  // Note: If we ever allow binary headers here, we still need to
+  // special-case ignore "grpc-tags-bin" and "grpc-trace-bin", since
+  // they are not visible to the LB policy in grpc-go.
+  if (absl::EndsWith(header_matcher.name, "-bin") ||
+      header_matcher.name == "grpc-previous-rpc-attempts") {
+    value = absl::nullopt;
+  } else if (header_matcher.name == "content-type") {
+    value = "application/grpc";
+  } else {
+    value = GetMetadataValue(header_matcher.name, initial_metadata,
+                             &concatenated_value);
+  }
+  if (!value.has_value()) {
+    if (header_matcher.type ==
+        XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::PRESENT) {
+      return !header_matcher.present_match;
+    } else {
+      // For all other header matcher types, we need the header value to
+      // exist to consider matches.
+      return false;
     }
   }
-  std::vector<absl::string_view> path_elements =
-      absl::StrSplit(path.substr(1), '/');
+  switch (header_matcher.type) {
+    case XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::EXACT:
+      return value.value() == header_matcher.string_matcher;
+    case XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::REGEX:
+      return RE2::FullMatch(value.value().data(), *header_matcher.regex_match);
+    case XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::RANGE:
+      int64_t int_value;
+      if (!absl::SimpleAtoi(value.value(), &int_value)) {
+        return false;
+      }
+      return int_value >= header_matcher.range_start &&
+             int_value < header_matcher.range_end;
+    case XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::PREFIX:
+      return absl::StartsWith(value.value(), header_matcher.string_matcher);
+    case XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::SUFFIX:
+      return absl::EndsWith(value.value(), header_matcher.string_matcher);
+    default:
+      return false;
+  }
+}
+
+bool HeadersMatch(
+    const std::vector<XdsApi::Route::Matchers::HeaderMatcher>& header_matchers,
+    LoadBalancingPolicy::MetadataInterface* initial_metadata) {
+  for (const auto& header_matcher : header_matchers) {
+    bool match = HeaderMatchHelper(header_matcher, initial_metadata);
+    if (header_matcher.invert_match) match = !match;
+    if (!match) return false;
+  }
+  return true;
+}
+
+bool UnderFraction(const uint32_t fraction_per_million) {
+  // Generate a random number in [0, 1000000).
+  const uint32_t random_number = rand() % 1000000;
+  return random_number < fraction_per_million;
+}
+
+XdsRoutingLb::PickResult XdsRoutingLb::RoutePicker::Pick(PickArgs args) {
   for (const Route& route : route_table_) {
-    if ((path_elements[0] == route.matcher.service &&
-         (path_elements[1] == route.matcher.method ||
-          route.matcher.method.empty())) ||
-        (route.matcher.service.empty() && route.matcher.method.empty())) {
-      return route.picker->Pick(args);
+    // Path matching.
+    if (!PathMatch(args.path, route.matchers->path_matcher)) continue;
+    // Header Matching.
+    if (!HeadersMatch(route.matchers->header_matchers, args.initial_metadata)) {
+      continue;
+    }
+    // Match fraction check
+    if (route.matchers->fraction_per_million.has_value() &&
+        !UnderFraction(route.matchers->fraction_per_million.value())) {
+      continue;
     }
+    // Found a match
+    return route.picker->Pick(args);
   }
   PickResult result;
   result.type = PickResult::PICK_FAILED;
@@ -294,9 +397,10 @@ void XdsRoutingLb::UpdateLocked(UpdateArgs args) {
     const RefCountedPtr<LoadBalancingPolicy::Config>& config = p.second;
     auto it = actions_.find(name);
     if (it == actions_.end()) {
-      it = actions_.emplace(std::make_pair(name, nullptr)).first;
-      it->second = MakeOrphanable<XdsRoutingChild>(
-          Ref(DEBUG_LOCATION, "XdsRoutingChild"), it->first);
+      it = actions_
+               .emplace(name, MakeOrphanable<XdsRoutingChild>(
+                                  Ref(DEBUG_LOCATION, "XdsRoutingChild"), name))
+               .first;
     }
     it->second->UpdateLocked(config, args.addresses, args.args);
   }
@@ -353,12 +457,13 @@ void XdsRoutingLb::UpdateStateLocked() {
             ConnectivityStateName(connectivity_state));
   }
   std::unique_ptr<SubchannelPicker> picker;
+  absl::Status status;
   switch (connectivity_state) {
     case GRPC_CHANNEL_READY: {
       RoutePicker::RouteTable route_table;
       for (const auto& config_route : config_->route_table()) {
         RoutePicker::Route route;
-        route.matcher = config_route.matcher;
+        route.matchers = &config_route.matchers;
         route.picker = actions_[config_route.action]->picker_wrapper();
         if (route.picker == nullptr) {
           if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_routing_lb_trace)) {
@@ -373,7 +478,7 @@ void XdsRoutingLb::UpdateStateLocked() {
         }
         route_table.push_back(std::move(route));
       }
-      picker = absl::make_unique<RoutePicker>(std::move(route_table));
+      picker = absl::make_unique<RoutePicker>(std::move(route_table), config_);
       break;
     }
     case GRPC_CHANNEL_CONNECTING:
@@ -382,12 +487,15 @@ void XdsRoutingLb::UpdateStateLocked() {
           absl::make_unique<QueuePicker>(Ref(DEBUG_LOCATION, "QueuePicker"));
       break;
     default:
-      picker = absl::make_unique<TransientFailurePicker>(grpc_error_set_int(
+      grpc_error* error = grpc_error_set_int(
           GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "TRANSIENT_FAILURE from XdsRoutingLb"),
-          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
+          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
+      status = grpc_error_to_absl_status(error);
+      picker = absl::make_unique<TransientFailurePicker>(error);
   }
-  channel_control_helper()->UpdateState(connectivity_state, std::move(picker));
+  channel_control_helper()->UpdateState(connectivity_state, status,
+                                        std::move(picker));
 }
 
 //
@@ -543,13 +651,15 @@ XdsRoutingLb::XdsRoutingChild::Helper::CreateSubchannel(
 }
 
 void XdsRoutingLb::XdsRoutingChild::Helper::UpdateState(
-    grpc_connectivity_state state, std::unique_ptr<SubchannelPicker> picker) {
+    grpc_connectivity_state state, const absl::Status& status,
+    std::unique_ptr<SubchannelPicker> picker) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_routing_lb_trace)) {
     gpr_log(GPR_INFO,
-            "[xds_routing_lb %p] child %s: received update: state=%s picker=%p",
+            "[xds_routing_lb %p] child %s: received update: state=%s (%s) "
+            "picker=%p",
             xds_routing_child_->xds_routing_policy_.get(),
             xds_routing_child_->name_.c_str(), ConnectivityStateName(state),
-            picker.get());
+            status.ToString().c_str(), picker.get());
   }
   if (xds_routing_child_->xds_routing_policy_->shutting_down_) return;
   // Cache the picker in the XdsRoutingChild.
@@ -683,12 +793,6 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("no valid routes configured");
       error_list.push_back(error);
     }
-    if (!route_table.back().matcher.service.empty() ||
-        !route_table.back().matcher.method.empty()) {
-      grpc_error* error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "default route must not contain service or method");
-      error_list.push_back(error);
-    }
     if (!actions_to_be_used.empty()) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "some actions were not referenced by any route"));
@@ -731,62 +835,265 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
     return error_list;
   }
 
-  static std::vector<grpc_error*> ParseMethodName(
-      const Json& json, XdsRoutingLbConfig::Matcher* route_config) {
+  static std::vector<grpc_error*> ParseRoute(
+      const Json& json, const XdsRoutingLbConfig::ActionMap& action_map,
+      XdsRoutingLbConfig::Route* route,
+      std::set<std::string /*action_name*/>* actions_to_be_used) {
     std::vector<grpc_error*> error_list;
     if (json.type() != Json::Type::OBJECT) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "value should be of type object"));
       return error_list;
     }
-    // Parse service
-    auto it = json.object_value().find("service");
+    // Parse and ensure one and only one path matcher is set: prefix, path, or
+    // regex.
+    bool path_matcher_seen = false;
+    auto it = json.object_value().find("prefix");
     if (it != json.object_value().end()) {
       if (it->second.type() != Json::Type::STRING) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:service error: should be string"));
+            "field:prefix error: should be string"));
       } else {
-        route_config->service = it->second.string_value();
+        path_matcher_seen = true;
+        route->matchers.path_matcher.type =
+            XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PREFIX;
+        route->matchers.path_matcher.string_matcher = it->second.string_value();
       }
     }
-    // Parse method
-    it = json.object_value().find("method");
+    it = json.object_value().find("path");
     if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::STRING) {
+      if (path_matcher_seen) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:method error: should be string"));
+            "field:path error: other path matcher already specified"));
       } else {
-        route_config->method = it->second.string_value();
+        path_matcher_seen = true;
+        if (it->second.type() != Json::Type::STRING) {
+          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "field:path error: should be string"));
+        } else {
+          route->matchers.path_matcher.type =
+              XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PATH;
+          route->matchers.path_matcher.string_matcher =
+              it->second.string_value();
+        }
       }
     }
-    if (route_config->service.empty() && !route_config->method.empty()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "service is empty when method is not"));
+    it = json.object_value().find("regex");
+    if (it != json.object_value().end()) {
+      if (path_matcher_seen) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:regex error: other path matcher already specified"));
+      } else {
+        path_matcher_seen = true;
+        if (it->second.type() != Json::Type::STRING) {
+          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "field:regex error: should be string"));
+        } else {
+          route->matchers.path_matcher.type =
+              XdsApi::Route::Matchers::PathMatcher::PathMatcherType::REGEX;
+          route->matchers.path_matcher.regex_matcher =
+              absl::make_unique<RE2>(it->second.string_value());
+        }
+      }
     }
-    return error_list;
-  }
-
-  static std::vector<grpc_error*> ParseRoute(
-      const Json& json, const XdsRoutingLbConfig::ActionMap& action_map,
-      XdsRoutingLbConfig::Route* route,
-      std::set<std::string /*action_name*/>* actions_to_be_used) {
-    std::vector<grpc_error*> error_list;
-    if (json.type() != Json::Type::OBJECT) {
+    if (!path_matcher_seen) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "value should be of type object"));
-      return error_list;
+          "one path matcher: prefix, path, or regex is required"));
     }
-    // Parse MethodName.
-    auto it = json.object_value().find("methodName");
-    if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:methodName error:required field missing"));
-    } else {
-      std::vector<grpc_error*> method_name_errors =
-          ParseMethodName(it->second, &route->matcher);
-      if (!method_name_errors.empty()) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_VECTOR(
-            "field:methodName", &method_name_errors));
+    // Parse Header Matcher: headers.
+    it = json.object_value().find("headers");
+    if (it != json.object_value().end()) {
+      if (it->second.type() != Json::Type::ARRAY) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:headers error: should be array"));
+      } else {
+        const Json::Array& array = it->second.array_value();
+        for (size_t i = 0; i < array.size(); ++i) {
+          const Json& header_json = array[i];
+          if (header_json.type() != Json::Type::OBJECT) {
+            error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                "value should be of type object"));
+          } else {
+            route->matchers.header_matchers.emplace_back();
+            XdsApi::Route::Matchers::HeaderMatcher& header_matcher =
+                route->matchers.header_matchers.back();
+            auto header_it = header_json.object_value().find("name");
+            if (header_it == header_json.object_value().end()) {
+              error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                  "field:name error:required field missing"));
+            } else {
+              if (header_it->second.type() != Json::Type::STRING) {
+                error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                    "field:name error: should be string"));
+              } else {
+                header_matcher.name = header_it->second.string_value();
+              }
+            }
+            header_it = header_json.object_value().find("invert_match");
+            if (header_it != header_json.object_value().end()) {
+              if (header_it->second.type() == Json::Type::JSON_TRUE) {
+                header_matcher.invert_match = true;
+              } else if (header_it->second.type() == Json::Type::JSON_FALSE) {
+                header_matcher.invert_match = false;
+              } else {
+                error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                    "field:present_match error: should be boolean"));
+              }
+            }
+            // Parse and ensure one and only one header matcher is set per
+            // header matcher.
+            bool header_matcher_seen = false;
+            header_it = header_json.object_value().find("exact_match");
+            if (header_it != header_json.object_value().end()) {
+              header_matcher_seen = true;
+              if (header_it->second.type() != Json::Type::STRING) {
+                error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                    "field:exact_match error: should be string"));
+              } else {
+                header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                    HeaderMatcherType::EXACT;
+                header_matcher.string_matcher =
+                    header_it->second.string_value();
+              }
+            }
+            header_it = header_json.object_value().find("regex_match");
+            if (header_it != header_json.object_value().end()) {
+              if (header_matcher_seen) {
+                error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                    "field:regex_match error: other header matcher already "
+                    "specified"));
+              } else {
+                header_matcher_seen = true;
+                if (header_it->second.type() != Json::Type::STRING) {
+                  error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                      "field:regex_match error: should be string"));
+                } else {
+                  header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                      HeaderMatcherType::REGEX;
+                  header_matcher.regex_match =
+                      absl::make_unique<RE2>(header_it->second.string_value());
+                }
+              }
+            }
+            header_it = header_json.object_value().find("range_match");
+            if (header_it != header_json.object_value().end()) {
+              if (header_matcher_seen) {
+                error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                    "field:range_match error: other header matcher already "
+                    "specified"));
+              } else {
+                header_matcher_seen = true;
+                if (header_it->second.type() != Json::Type::OBJECT) {
+                  error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                      "field:range_match error: should be object"));
+                } else {
+                  auto range_it =
+                      header_it->second.object_value().find("start");
+                  if (range_it != header_it->second.object_value().end()) {
+                    if (range_it->second.type() != Json::Type::NUMBER) {
+                      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                          "field:start error: should be of number"));
+                    } else {
+                      header_matcher.range_start = gpr_parse_nonnegative_int(
+                          range_it->second.string_value().c_str());
+                    }
+                  } else {
+                    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                        "field:start missing"));
+                  }
+                  range_it = header_it->second.object_value().find("end");
+                  if (range_it != header_it->second.object_value().end()) {
+                    if (range_it->second.type() != Json::Type::NUMBER) {
+                      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                          "field:end error: should be of number"));
+                    } else {
+                      header_matcher.range_end = gpr_parse_nonnegative_int(
+                          range_it->second.string_value().c_str());
+                    }
+                  } else {
+                    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                        "field:end missing"));
+                  }
+                  if (header_matcher.range_end > header_matcher.range_start) {
+                    header_matcher.type = XdsApi::Route::Matchers::
+                        HeaderMatcher::HeaderMatcherType::RANGE;
+                  }
+                }
+              }
+            }
+            header_it = header_json.object_value().find("present_match");
+            if (header_it != header_json.object_value().end()) {
+              if (header_matcher_seen) {
+                error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                    "field:present_match error: other header matcher already "
+                    "specified"));
+              } else {
+                header_matcher_seen = true;
+                if (header_it->second.type() == Json::Type::JSON_TRUE) {
+                  header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                      HeaderMatcherType::PRESENT;
+                  header_matcher.present_match = true;
+                } else if (header_it->second.type() == Json::Type::JSON_FALSE) {
+                  header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                      HeaderMatcherType::PRESENT;
+                  header_matcher.present_match = false;
+                } else {
+                  error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                      "field:present_match error: should be boolean"));
+                }
+              }
+            }
+            header_it = header_json.object_value().find("prefix_match");
+            if (header_it != header_json.object_value().end()) {
+              if (header_matcher_seen) {
+                error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                    "field:prefix_match error: other header matcher already "
+                    "specified"));
+              } else {
+                header_matcher_seen = true;
+                if (header_it->second.type() != Json::Type::STRING) {
+                  error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                      "field:prefix_match error: should be string"));
+                } else {
+                  header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                      HeaderMatcherType::PREFIX;
+                  header_matcher.string_matcher =
+                      header_it->second.string_value();
+                }
+              }
+            }
+            header_it = header_json.object_value().find("suffix_match");
+            if (header_it != header_json.object_value().end()) {
+              if (header_matcher_seen) {
+                error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                    "field:suffix_match error: other header matcher already "
+                    "specified"));
+              } else {
+                header_matcher_seen = true;
+                if (header_it->second.type() != Json::Type::STRING) {
+                  error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                      "field:suffix_match error: should be string"));
+                } else {
+                  header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                      HeaderMatcherType::SUFFIX;
+                  header_matcher.string_matcher =
+                      header_it->second.string_value();
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    // Parse Fraction numerator.
+    it = json.object_value().find("match_fraction");
+    if (it != json.object_value().end()) {
+      if (it->second.type() != Json::Type::NUMBER) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:match_fraction error:must be of type number"));
+      } else {
+        route->matchers.fraction_per_million =
+            gpr_parse_nonnegative_int(it->second.string_value().c_str());
       }
     }
     // Parse action.