grpc 1.31.1 → 1.32.0.pre1

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

@@ -35,13 +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/filters/client_channel/xds/xds_api.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)
 
@@ -57,7 +58,7 @@ constexpr char kXdsRouting[] = "xds_routing_experimental";
 class XdsRoutingLbConfig : public LoadBalancingPolicy::Config {
  public:
   struct Route {
-    XdsApi::RdsUpdate::RdsRoute::Matchers matchers;
+    XdsApi::Route::Matchers matchers;
     std::string action;
   };
   using RouteTable = std::vector<Route>;
@@ -111,7 +112,7 @@ class XdsRoutingLb : public LoadBalancingPolicy {
   class RoutePicker : public SubchannelPicker {
    public:
     struct Route {
-      const XdsApi::RdsUpdate::RdsRoute::Matchers* matchers;
+      const XdsApi::Route::Matchers* matchers;
       RefCountedPtr<ChildPickerWrapper> picker;
     };
 
@@ -127,7 +128,7 @@ class XdsRoutingLb : public LoadBalancingPolicy {
    private:
     RouteTable route_table_;
     // Take a reference to config so that we can use
-    // XdsApi::RdsUpdate::RdsRoute::Matchers from it.
+    // XdsApi::Route::Matchers from it.
     RefCountedPtr<XdsRoutingLbConfig> config_;
   };
 
@@ -165,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,
@@ -220,18 +222,14 @@ class XdsRoutingLb : public LoadBalancingPolicy {
 // XdsRoutingLb::RoutePicker
 //
 
-bool PathMatch(
-    const absl::string_view& path,
-    const XdsApi::RdsUpdate::RdsRoute::Matchers::PathMatcher& path_matcher) {
+bool PathMatch(const absl::string_view& path,
+               const XdsApi::Route::Matchers::PathMatcher& path_matcher) {
   switch (path_matcher.type) {
-    case XdsApi::RdsUpdate::RdsRoute::Matchers::PathMatcher::PathMatcherType::
-        PREFIX:
+    case XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PREFIX:
       return absl::StartsWith(path, path_matcher.string_matcher);
-    case XdsApi::RdsUpdate::RdsRoute::Matchers::PathMatcher::PathMatcherType::
-        PATH:
+    case XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PATH:
       return path == path_matcher.string_matcher;
-    case XdsApi::RdsUpdate::RdsRoute::Matchers::PathMatcher::PathMatcherType::
-        REGEX:
+    case XdsApi::Route::Matchers::PathMatcher::PathMatcherType::REGEX:
       return RE2::FullMatch(path.data(), *path_matcher.regex_matcher);
     default:
       return false;
@@ -260,7 +258,7 @@ absl::optional<absl::string_view> GetMetadataValue(
 }
 
 bool HeaderMatchHelper(
-    const XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher& header_matcher,
+    const XdsApi::Route::Matchers::HeaderMatcher& header_matcher,
     LoadBalancingPolicy::MetadataInterface* initial_metadata) {
   std::string concatenated_value;
   absl::optional<absl::string_view> value;
@@ -277,8 +275,8 @@ bool HeaderMatchHelper(
                              &concatenated_value);
   }
   if (!value.has_value()) {
-    if (header_matcher.type == XdsApi::RdsUpdate::RdsRoute::Matchers::
-                                   HeaderMatcher::HeaderMatcherType::PRESENT) {
+    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
@@ -287,25 +285,20 @@ bool HeaderMatchHelper(
     }
   }
   switch (header_matcher.type) {
-    case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
-        HeaderMatcherType::EXACT:
+    case XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::EXACT:
       return value.value() == header_matcher.string_matcher;
-    case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
-        HeaderMatcherType::REGEX:
+    case XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::REGEX:
       return RE2::FullMatch(value.value().data(), *header_matcher.regex_match);
-    case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
-        HeaderMatcherType::RANGE:
+    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::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
-        HeaderMatcherType::PREFIX:
+    case XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::PREFIX:
       return absl::StartsWith(value.value(), header_matcher.string_matcher);
-    case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
-        HeaderMatcherType::SUFFIX:
+    case XdsApi::Route::Matchers::HeaderMatcher::HeaderMatcherType::SUFFIX:
       return absl::EndsWith(value.value(), header_matcher.string_matcher);
     default:
       return false;
@@ -313,8 +306,7 @@ bool HeaderMatchHelper(
 }
 
 bool HeadersMatch(
-    const std::vector<XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher>&
-        header_matchers,
+    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);
@@ -465,6 +457,7 @@ 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;
@@ -494,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));
 }
 
 //
@@ -655,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.
@@ -857,8 +855,8 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
             "field:prefix error: should be string"));
       } else {
         path_matcher_seen = true;
-        route->matchers.path_matcher.type = XdsApi::RdsUpdate::RdsRoute::
-            Matchers::PathMatcher::PathMatcherType::PREFIX;
+        route->matchers.path_matcher.type =
+            XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PREFIX;
         route->matchers.path_matcher.string_matcher = it->second.string_value();
       }
     }
@@ -873,8 +871,8 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:path error: should be string"));
         } else {
-          route->matchers.path_matcher.type = XdsApi::RdsUpdate::RdsRoute::
-              Matchers::PathMatcher::PathMatcherType::PATH;
+          route->matchers.path_matcher.type =
+              XdsApi::Route::Matchers::PathMatcher::PathMatcherType::PATH;
           route->matchers.path_matcher.string_matcher =
               it->second.string_value();
         }
@@ -891,8 +889,8 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:regex error: should be string"));
         } else {
-          route->matchers.path_matcher.type = XdsApi::RdsUpdate::RdsRoute::
-              Matchers::PathMatcher::PathMatcherType::REGEX;
+          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());
         }
@@ -917,8 +915,8 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
                 "value should be of type object"));
           } else {
             route->matchers.header_matchers.emplace_back();
-            XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher&
-                header_matcher = route->matchers.header_matchers.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(
@@ -952,8 +950,8 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
                 error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                     "field:exact_match error: should be string"));
               } else {
-                header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
-                    HeaderMatcher::HeaderMatcherType::EXACT;
+                header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                    HeaderMatcherType::EXACT;
                 header_matcher.string_matcher =
                     header_it->second.string_value();
               }
@@ -970,8 +968,8 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
                   error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                       "field:regex_match error: should be string"));
                 } else {
-                  header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
-                      HeaderMatcher::HeaderMatcherType::REGEX;
+                  header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                      HeaderMatcherType::REGEX;
                   header_matcher.regex_match =
                       absl::make_unique<RE2>(header_it->second.string_value());
                 }
@@ -1017,8 +1015,8 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
                         "field:end missing"));
                   }
                   if (header_matcher.range_end > header_matcher.range_start) {
-                    header_matcher.type = XdsApi::RdsUpdate::RdsRoute::
-                        Matchers::HeaderMatcher::HeaderMatcherType::RANGE;
+                    header_matcher.type = XdsApi::Route::Matchers::
+                        HeaderMatcher::HeaderMatcherType::RANGE;
                   }
                 }
               }
@@ -1032,12 +1030,12 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
               } else {
                 header_matcher_seen = true;
                 if (header_it->second.type() == Json::Type::JSON_TRUE) {
-                  header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
-                      HeaderMatcher::HeaderMatcherType::PRESENT;
+                  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::RdsUpdate::RdsRoute::Matchers::
-                      HeaderMatcher::HeaderMatcherType::PRESENT;
+                  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(
@@ -1057,8 +1055,8 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
                   error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                       "field:prefix_match error: should be string"));
                 } else {
-                  header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
-                      HeaderMatcher::HeaderMatcherType::PREFIX;
+                  header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                      HeaderMatcherType::PREFIX;
                   header_matcher.string_matcher =
                       header_it->second.string_value();
                 }
@@ -1076,8 +1074,8 @@ class XdsRoutingLbFactory : public LoadBalancingPolicyFactory {
                   error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                       "field:suffix_match error: should be string"));
                 } else {
-                  header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
-                      HeaderMatcher::HeaderMatcherType::SUFFIX;
+                  header_matcher.type = XdsApi::Route::Matchers::HeaderMatcher::
+                      HeaderMatcherType::SUFFIX;
                   header_matcher.string_matcher =
                       header_it->second.string_value();
                 }