grpc 1.28.0 → 1.31.0.pre2

data/src/core/ext/filters/client_channel/service_config_parser.h

@@ -0,0 +1,89 @@
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_PARSER_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_PARSER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/container/inlined_vector.h"
+
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/json/json.h"
+
+namespace grpc_core {
+
+// Service config parser registry.
+// See service_config.h for more information.
+class ServiceConfigParser {
+ public:
+  /// This is the base class that all service config parsers MUST use to store
+  /// parsed service config data.
+  class ParsedConfig {
+   public:
+    virtual ~ParsedConfig() = default;
+  };
+
+  /// This is the base class that all service config parsers should derive from.
+  class Parser {
+   public:
+    virtual ~Parser() = default;
+
+    virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
+        const Json& /* json */, grpc_error** error) {
+      // Avoid unused parameter warning on debug-only parameter
+      (void)error;
+      GPR_DEBUG_ASSERT(error != nullptr);
+      return nullptr;
+    }
+
+    virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
+        const Json& /* json */, grpc_error** error) {
+      // Avoid unused parameter warning on debug-only parameter
+      (void)error;
+      GPR_DEBUG_ASSERT(error != nullptr);
+      return nullptr;
+    }
+  };
+
+  static constexpr int kNumPreallocatedParsers = 4;
+  typedef absl::InlinedVector<std::unique_ptr<ParsedConfig>,
+                              kNumPreallocatedParsers>
+      ParsedConfigVector;
+
+  static void Init();
+  static void Shutdown();
+
+  /// Globally register a service config parser. On successful registration, it
+  /// returns the index at which the parser was registered. On failure, -1 is
+  /// returned. Each new service config update will go through all the
+  /// registered parser. Each parser is responsible for reading the service
+  /// config json and returning a parsed config. This parsed config can later be
+  /// retrieved using the same index that was returned at registration time.
+  static size_t RegisterParser(std::unique_ptr<Parser> parser);
+
+  static ParsedConfigVector ParseGlobalParameters(const Json& json,
+                                                  grpc_error** error);
+
+  static ParsedConfigVector ParsePerMethodParameters(const Json& json,
+                                                     grpc_error** error);
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_PARSER_H */

data/src/core/ext/filters/client_channel/subchannel.cc

@@ -362,12 +362,44 @@ class Subchannel::ConnectedSubchannelStateWatcher
   Subchannel* subchannel_;
 };
 
+// Asynchronously notifies the \a watcher of a change in the connectvity state
+// of \a subchannel to the current \a state. Deletes itself when done.
+class Subchannel::AsyncWatcherNotifierLocked {
+ public:
+  AsyncWatcherNotifierLocked(
+      RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher,
+      Subchannel* subchannel, grpc_connectivity_state state)
+      : watcher_(std::move(watcher)) {
+    RefCountedPtr<ConnectedSubchannel> connected_subchannel;
+    if (state == GRPC_CHANNEL_READY) {
+      connected_subchannel = subchannel->connected_subchannel_;
+    }
+    watcher_->PushConnectivityStateChange(
+        {state, std::move(connected_subchannel)});
+    ExecCtx::Run(
+        DEBUG_LOCATION,
+        GRPC_CLOSURE_INIT(&closure_,
+                          [](void* arg, grpc_error* /*error*/) {
+                            auto* self =
+                                static_cast<AsyncWatcherNotifierLocked*>(arg);
+                            self->watcher_->OnConnectivityStateChange();
+                            delete self;
+                          },
+                          this, nullptr),
+        GRPC_ERROR_NONE);
+  }
+
+ private:
+  RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher_;
+  grpc_closure closure_;
+};
+
 //
 // Subchannel::ConnectivityStateWatcherList
 //
 
 void Subchannel::ConnectivityStateWatcherList::AddWatcherLocked(
-    OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
+    RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
   watchers_.insert(std::make_pair(watcher.get(), std::move(watcher)));
 }
 
@@ -379,19 +411,7 @@ void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
 void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
     Subchannel* subchannel, grpc_connectivity_state state) {
   for (const auto& p : watchers_) {
-    RefCountedPtr<ConnectedSubchannel> connected_subchannel;
-    if (state == GRPC_CHANNEL_READY) {
-      connected_subchannel = subchannel->connected_subchannel_;
-    }
-    // TODO(roth): In principle, it seems wrong to send this notification
-    // to the watcher while holding the subchannel's mutex, since it could
-    // lead to a deadlock if the watcher calls back into the subchannel
-    // before returning back to us.  In practice, this doesn't happen,
-    // because the LB policy code that watches subchannels always bounces
-    // the notification into the client_channel control-plane combiner
-    // before processing it.  But if we ever have any other callers here,
-    // we will probably need to change this.
-    p.second->OnConnectivityStateChange(state, std::move(connected_subchannel));
+    new AsyncWatcherNotifierLocked(p.second, subchannel, state);
   }
 }
 
@@ -428,14 +448,9 @@ class Subchannel::HealthWatcherMap::HealthWatcher
 
   void AddWatcherLocked(
       grpc_connectivity_state initial_state,
-      OrphanablePtr<Subchannel::ConnectivityStateWatcherInterface> watcher) {
+      RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher) {
     if (state_ != initial_state) {
-      RefCountedPtr<ConnectedSubchannel> connected_subchannel;
-      if (state_ == GRPC_CHANNEL_READY) {
-        connected_subchannel = subchannel_->connected_subchannel_;
-      }
-      watcher->OnConnectivityStateChange(state_,
-                                         std::move(connected_subchannel));
+      new AsyncWatcherNotifierLocked(watcher, subchannel_, state_);
     }
     watcher_list_.AddWatcherLocked(std::move(watcher));
   }
@@ -503,7 +518,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
 void Subchannel::HealthWatcherMap::AddWatcherLocked(
     Subchannel* subchannel, grpc_connectivity_state initial_state,
     grpc_core::UniquePtr<char> health_check_service_name,
-    OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
+    RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
   // If the health check service name is not already present in the map,
   // add it.
   auto it = map_.find(health_check_service_name.get());
@@ -613,6 +628,21 @@ BackOff::Options ParseArgsForBackoffValues(
 
 }  // namespace
 
+void Subchannel::ConnectivityStateWatcherInterface::PushConnectivityStateChange(
+    ConnectivityStateChange state_change) {
+  MutexLock lock(&mu_);
+  connectivity_state_queue_.push_back(std::move(state_change));
+}
+
+Subchannel::ConnectivityStateWatcherInterface::ConnectivityStateChange
+Subchannel::ConnectivityStateWatcherInterface::PopConnectivityStateChange() {
+  MutexLock lock(&mu_);
+  GPR_ASSERT(!connectivity_state_queue_.empty());
+  ConnectivityStateChange state_change = connectivity_state_queue_.front();
+  connectivity_state_queue_.pop_front();
+  return state_change;
+}
+
 Subchannel::Subchannel(SubchannelKey* key,
                        OrphanablePtr<SubchannelConnector> connector,
                        const grpc_channel_args* args)
@@ -788,7 +818,7 @@ grpc_connectivity_state Subchannel::CheckConnectivityState(
 void Subchannel::WatchConnectivityState(
     grpc_connectivity_state initial_state,
     grpc_core::UniquePtr<char> health_check_service_name,
-    OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
+    RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
   MutexLock lock(&mu_);
   grpc_pollset_set* interested_parties = watcher->interested_parties();
   if (interested_parties != nullptr) {
@@ -796,7 +826,7 @@ void Subchannel::WatchConnectivityState(
   }
   if (health_check_service_name == nullptr) {
     if (state_ != initial_state) {
-      watcher->OnConnectivityStateChange(state_, connected_subchannel_);
+      new AsyncWatcherNotifierLocked(watcher, this, state_);
     }
     watcher_list_.AddWatcherLocked(std::move(watcher));
   } else {
@@ -842,7 +872,7 @@ grpc_arg Subchannel::CreateSubchannelAddressArg(
     const grpc_resolved_address* addr) {
   return grpc_channel_arg_string_create(
       (char*)GRPC_ARG_SUBCHANNEL_ADDRESS,
-      addr->len > 0 ? grpc_sockaddr_to_uri(addr) : gpr_strdup(""));
+      gpr_strdup(addr->len > 0 ? grpc_sockaddr_to_uri(addr).c_str() : ""));
 }
 
 const char* Subchannel::GetUriFromSubchannelAddressArg(

data/src/core/ext/filters/client_channel/subchannel.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <deque>
+
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 #include "src/core/ext/filters/client_channel/connector.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
@@ -176,24 +178,44 @@ class SubchannelCall {
 class Subchannel {
  public:
   class ConnectivityStateWatcherInterface
-      : public InternallyRefCounted<ConnectivityStateWatcherInterface> {
+      : public RefCounted<ConnectivityStateWatcherInterface> {
    public:
+    struct ConnectivityStateChange {
+      grpc_connectivity_state state;
+      RefCountedPtr<ConnectedSubchannel> connected_subchannel;
+    };
+
     virtual ~ConnectivityStateWatcherInterface() = default;
 
     // Will be invoked whenever the subchannel's connectivity state
     // changes.  There will be only one invocation of this method on a
     // given watcher instance at any given time.
-    //
+    // Implementations should call PopConnectivityStateChange to get the next
+    // connectivity state change.
+    virtual void OnConnectivityStateChange() = 0;
+
+    virtual grpc_pollset_set* interested_parties() = 0;
+
+    // Enqueues connectivity state change notifications.
     // When the state changes to READY, connected_subchannel will
     // contain a ref to the connected subchannel.  When it changes from
     // READY to some other state, the implementation must release its
     // ref to the connected subchannel.
-    virtual void OnConnectivityStateChange(
-        grpc_connectivity_state new_state,
-        RefCountedPtr<ConnectedSubchannel> connected_subchannel)  // NOLINT
-        = 0;
+    // TODO(yashkt): This is currently needed to send the state updates in the
+    // right order when asynchronously notifying. This will no longer be
+    // necessary when we have access to EventManager.
+    void PushConnectivityStateChange(ConnectivityStateChange state_change);
 
-    virtual grpc_pollset_set* interested_parties() = 0;
+    // Dequeues connectivity state change notifications.
+    ConnectivityStateChange PopConnectivityStateChange();
+
+   private:
+    // Keeps track of the updates that the watcher instance must be notified of.
+    // TODO(yashkt): This is currently needed to send the state updates in the
+    // right order when asynchronously notifying. This will no longer be
+    // necessary when we have access to EventManager.
+    std::deque<ConnectivityStateChange> connectivity_state_queue_;
+    Mutex mu_;  // protects the queue
   };
 
   // The ctor and dtor are not intended to use directly.
@@ -243,7 +265,7 @@ class Subchannel {
   void WatchConnectivityState(
       grpc_connectivity_state initial_state,
       grpc_core::UniquePtr<char> health_check_service_name,
-      OrphanablePtr<ConnectivityStateWatcherInterface> watcher);
+      RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
 
   // Cancels a connectivity state watch.
   // If the watcher has already been destroyed, this is a no-op.
@@ -280,7 +302,7 @@ class Subchannel {
     ~ConnectivityStateWatcherList() { Clear(); }
 
     void AddWatcherLocked(
-        OrphanablePtr<ConnectivityStateWatcherInterface> watcher);
+        RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
     void RemoveWatcherLocked(ConnectivityStateWatcherInterface* watcher);
 
     // Notifies all watchers in the list about a change to state.
@@ -294,7 +316,7 @@ class Subchannel {
     // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
     // be a set instead of a map.
     std::map<ConnectivityStateWatcherInterface*,
-             OrphanablePtr<ConnectivityStateWatcherInterface>>
+             RefCountedPtr<ConnectivityStateWatcherInterface>>
         watchers_;
   };
 
@@ -312,7 +334,7 @@ class Subchannel {
     void AddWatcherLocked(
         Subchannel* subchannel, grpc_connectivity_state initial_state,
         grpc_core::UniquePtr<char> health_check_service_name,
-        OrphanablePtr<ConnectivityStateWatcherInterface> watcher);
+        RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
     void RemoveWatcherLocked(const char* health_check_service_name,
                              ConnectivityStateWatcherInterface* watcher);
 
@@ -332,6 +354,8 @@ class Subchannel {
 
   class ConnectedSubchannelStateWatcher;
 
+  class AsyncWatcherNotifierLocked;
+
   // Sets the subchannel's connectivity state to \a state.
   void SetConnectivityStateLocked(grpc_connectivity_state state);
 

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

@@ -23,14 +23,20 @@
 #include <cstdlib>
 
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
+
+#include "upb/upb.hpp"
 
 #include <grpc/impl/codegen/log.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/xds/xds_api.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 
@@ -49,7 +55,9 @@
 #include "envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.upb.h"
 #include "envoy/config/listener/v2/api_listener.upb.h"
 #include "envoy/service/load_stats/v2/lrs.upb.h"
+#include "envoy/type/matcher/regex.upb.h"
 #include "envoy/type/percent.upb.h"
+#include "envoy/type/range.upb.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/struct.upb.h"
@@ -126,6 +134,94 @@ const char* XdsApi::kCdsTypeUrl = "type.googleapis.com/envoy.api.v2.Cluster";
 const char* XdsApi::kEdsTypeUrl =
     "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment";
 
+std::string XdsApi::RdsUpdate::RdsRoute::Matchers::PathMatcher::ToString()
+    const {
+  std::string path_type_string;
+  switch (type) {
+    case PathMatcherType::PATH:
+      path_type_string = "path match";
+      break;
+    case PathMatcherType::PREFIX:
+      path_type_string = "prefix match";
+      break;
+    case PathMatcherType::REGEX:
+      path_type_string = "regex match";
+      break;
+    default:
+      break;
+  }
+  return absl::StrFormat("Path %s:/%s/", path_type_string,
+                         type == PathMatcherType::REGEX
+                             ? regex_matcher->pattern()
+                             : string_matcher);
+}
+
+std::string XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::ToString()
+    const {
+  switch (type) {
+    case HeaderMatcherType::EXACT:
+      return absl::StrFormat("Header exact match:%s %s:%s",
+                             invert_match ? " not" : "", name, string_matcher);
+    case HeaderMatcherType::REGEX:
+      return absl::StrFormat("Header regex match:%s %s:%s",
+                             invert_match ? " not" : "", name,
+                             regex_match->pattern());
+    case HeaderMatcherType::RANGE:
+      return absl::StrFormat("Header range match:%s %s:[%d, %d)",
+                             invert_match ? " not" : "", name, range_start,
+                             range_end);
+    case HeaderMatcherType::PRESENT:
+      return absl::StrFormat("Header present match:%s %s:%s",
+                             invert_match ? " not" : "", name,
+                             present_match ? "true" : "false");
+    case HeaderMatcherType::PREFIX:
+      return absl::StrFormat("Header prefix match:%s %s:%s",
+                             invert_match ? " not" : "", name, string_matcher);
+    case HeaderMatcherType::SUFFIX:
+      return absl::StrFormat("Header suffix match:%s %s:%s",
+                             invert_match ? " not" : "", name, string_matcher);
+    default:
+      return "";
+  }
+}
+
+std::string XdsApi::RdsUpdate::RdsRoute::Matchers::ToString() const {
+  std::vector<std::string> contents;
+  contents.push_back(path_matcher.ToString());
+  for (const auto& header_it : header_matchers) {
+    contents.push_back(header_it.ToString());
+  }
+  if (fraction_per_million.has_value()) {
+    contents.push_back(absl::StrFormat("Fraction Per Million %d",
+                                       fraction_per_million.value()));
+  }
+  return absl::StrJoin(contents, "\n");
+}
+
+std::string XdsApi::RdsUpdate::RdsRoute::ClusterWeight::ToString() const {
+  return absl::StrFormat("{cluster=%s, weight=%d}", name, weight);
+}
+
+std::string XdsApi::RdsUpdate::RdsRoute::ToString() const {
+  std::vector<std::string> contents;
+  contents.push_back(matchers.ToString());
+  if (!cluster_name.empty()) {
+    contents.push_back(absl::StrFormat("Cluster name: %s", cluster_name));
+  }
+  for (const auto& weighted_it : weighted_clusters) {
+    contents.push_back(weighted_it.ToString());
+  }
+  return absl::StrJoin(contents, "\n");
+}
+
+std::string XdsApi::RdsUpdate::ToString() const {
+  std::vector<std::string> contents;
+  for (const auto& route_it : routes) {
+    contents.push_back(route_it.ToString());
+  }
+  return absl::StrJoin(contents, ",\n");
+}
+
 XdsApi::XdsApi(XdsClient* client, TraceFlag* tracer,
                const XdsBootstrap::Node* node)
     : client_(client),
@@ -151,13 +247,10 @@ void PopulateListValue(upb_arena* arena, google_protobuf_ListValue* list_value,
 void PopulateMetadata(upb_arena* arena, google_protobuf_Struct* metadata_pb,
                       const Json::Object& metadata) {
   for (const auto& p : metadata) {
-    google_protobuf_Struct_FieldsEntry* field =
-        google_protobuf_Struct_add_fields(metadata_pb, arena);
-    google_protobuf_Struct_FieldsEntry_set_key(
-        field, upb_strview_makez(p.first.c_str()));
-    google_protobuf_Value* value =
-        google_protobuf_Struct_FieldsEntry_mutable_value(field, arena);
+    google_protobuf_Value* value = google_protobuf_Value_new(arena);
     PopulateMetadataValue(arena, value, p.second);
+    google_protobuf_Struct_fields_set(
+        metadata_pb, upb_strview_makez(p.first.c_str()), value, arena);
   }
 }
 
@@ -218,14 +311,12 @@ void PopulateNode(upb_arena* arena, const XdsBootstrap::Node* node,
     if (!server_name.empty()) {
       google_protobuf_Struct* metadata =
           envoy_api_v2_core_Node_mutable_metadata(node_msg, arena);
-      google_protobuf_Struct_FieldsEntry* field =
-          google_protobuf_Struct_add_fields(metadata, arena);
-      google_protobuf_Struct_FieldsEntry_set_key(
-          field, upb_strview_makez("PROXYLESS_CLIENT_HOSTNAME"));
-      google_protobuf_Value* value =
-          google_protobuf_Struct_FieldsEntry_mutable_value(field, arena);
+      google_protobuf_Value* value = google_protobuf_Value_new(arena);
       google_protobuf_Value_set_string_value(
           value, upb_strview_make(server_name.data(), server_name.size()));
+      google_protobuf_Struct_fields_set(
+          metadata, upb_strview_makez("PROXYLESS_CLIENT_HOSTNAME"), value,
+          arena);
     }
     if (!node->locality_region.empty() || !node->locality_zone.empty() ||
         !node->locality_subzone.empty()) {
@@ -257,46 +348,14 @@ void PopulateNode(upb_arena* arena, const XdsBootstrap::Node* node,
       arena);
 }
 
-envoy_api_v2_DiscoveryRequest* CreateDiscoveryRequest(
-    upb_arena* arena, const char* type_url, const std::string& version,
-    const std::string& nonce, grpc_error* error) {
-  // Create a request.
-  envoy_api_v2_DiscoveryRequest* request =
-      envoy_api_v2_DiscoveryRequest_new(arena);
-  // Set type_url.
-  envoy_api_v2_DiscoveryRequest_set_type_url(request,
-                                             upb_strview_makez(type_url));
-  // Set version_info.
-  if (!version.empty()) {
-    envoy_api_v2_DiscoveryRequest_set_version_info(
-        request, upb_strview_makez(version.c_str()));
-  }
-  // Set nonce.
-  if (!nonce.empty()) {
-    envoy_api_v2_DiscoveryRequest_set_response_nonce(
-        request, upb_strview_makez(nonce.c_str()));
-  }
-  // Set error_detail if it's a NACK.
-  if (error != GRPC_ERROR_NONE) {
-    grpc_slice error_description_slice;
-    GPR_ASSERT(grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION,
-                                  &error_description_slice));
-    upb_strview error_description_strview =
-        upb_strview_make(reinterpret_cast<const char*>(
-                             GPR_SLICE_START_PTR(error_description_slice)),
-                         GPR_SLICE_LENGTH(error_description_slice));
-    google_rpc_Status* error_detail =
-        envoy_api_v2_DiscoveryRequest_mutable_error_detail(request, arena);
-    google_rpc_Status_set_message(error_detail, error_description_strview);
-    GRPC_ERROR_UNREF(error);
-  }
-  return request;
-}
-
 inline absl::string_view UpbStringToAbsl(const upb_strview& str) {
   return absl::string_view(str.data, str.size);
 }
 
+inline std::string UpbStringToStdString(const upb_strview& str) {
+  return std::string(str.data, str.size);
+}
+
 inline void AddStringField(const char* name, const upb_strview& value,
                            std::vector<std::string>* fields,
                            bool add_if_empty = false) {
@@ -306,6 +365,15 @@ inline void AddStringField(const char* name, const upb_strview& value,
   }
 }
 
+inline void AddUInt32ValueField(const char* name,
+                                const google_protobuf_UInt32Value* value,
+                                std::vector<std::string>* fields) {
+  if (value != nullptr) {
+    fields->emplace_back(absl::StrCat(
+        name, " { value: ", google_protobuf_UInt32Value_value(value), " }"));
+  }
+}
+
 inline void AddLocalityField(int indent_level,
                              const envoy_api_v2_core_Locality* locality,
                              std::vector<std::string>* fields) {
@@ -335,18 +403,18 @@ void AddNodeLogFields(const envoy_api_v2_core_Node* node,
       envoy_api_v2_core_Node_metadata(node);
   if (metadata != nullptr) {
     fields->emplace_back("  metadata {");
-    size_t num_entries;
-    const google_protobuf_Struct_FieldsEntry* const* entries =
-        google_protobuf_Struct_fields(metadata, &num_entries);
-    for (size_t i = 0; i < num_entries; ++i) {
+    size_t entry_idx = UPB_MAP_BEGIN;
+    while (true) {
+      const google_protobuf_Struct_FieldsEntry* entry =
+          google_protobuf_Struct_fields_next(metadata, &entry_idx);
+      if (entry == nullptr) break;
       fields->emplace_back("    field {");
       // key
-      AddStringField("      key",
-                     google_protobuf_Struct_FieldsEntry_key(entries[i]),
+      AddStringField("      key", google_protobuf_Struct_FieldsEntry_key(entry),
                      fields);
       // value
       const google_protobuf_Value* value =
-          google_protobuf_Struct_FieldsEntry_value(entries[i]);
+          google_protobuf_Struct_FieldsEntry_value(entry);
       if (value != nullptr) {
         std::string value_str;
         if (google_protobuf_Value_has_string_value(value)) {
@@ -459,91 +527,43 @@ grpc_slice SerializeDiscoveryRequest(upb_arena* arena,
 
 }  // namespace
 
-grpc_slice XdsApi::CreateUnsupportedTypeNackRequest(const std::string& type_url,
-                                                    const std::string& nonce,
-                                                    grpc_error* error) {
-  upb::Arena arena;
-  envoy_api_v2_DiscoveryRequest* request = CreateDiscoveryRequest(
-      arena.ptr(), type_url.c_str(), /*version=*/"", nonce, error);
-  MaybeLogDiscoveryRequest(client_, tracer_, request);
-  return SerializeDiscoveryRequest(arena.ptr(), request);
-}
-
-grpc_slice XdsApi::CreateLdsRequest(const std::string& server_name,
-                                    const std::string& version,
-                                    const std::string& nonce, grpc_error* error,
-                                    bool populate_node) {
-  upb::Arena arena;
-  envoy_api_v2_DiscoveryRequest* request =
-      CreateDiscoveryRequest(arena.ptr(), kLdsTypeUrl, version, nonce, error);
-  // Populate node.
-  if (populate_node) {
-    envoy_api_v2_core_Node* node_msg =
-        envoy_api_v2_DiscoveryRequest_mutable_node(request, arena.ptr());
-    PopulateNode(arena.ptr(), node_, build_version_, user_agent_name_, "",
-                 node_msg);
-  }
-  // Add resource_name.
-  envoy_api_v2_DiscoveryRequest_add_resource_names(
-      request, upb_strview_make(server_name.data(), server_name.size()),
-      arena.ptr());
-  MaybeLogDiscoveryRequest(client_, tracer_, request);
-  return SerializeDiscoveryRequest(arena.ptr(), request);
-}
-
-grpc_slice XdsApi::CreateRdsRequest(const std::string& route_config_name,
-                                    const std::string& version,
-                                    const std::string& nonce, grpc_error* error,
-                                    bool populate_node) {
+grpc_slice XdsApi::CreateAdsRequest(
+    const std::string& type_url,
+    const std::set<absl::string_view>& resource_names,
+    const std::string& version, const std::string& nonce, grpc_error* error,
+    bool populate_node) {
   upb::Arena arena;
+  // Create a request.
   envoy_api_v2_DiscoveryRequest* request =
-      CreateDiscoveryRequest(arena.ptr(), kRdsTypeUrl, version, nonce, error);
-  // Populate node.
-  if (populate_node) {
-    envoy_api_v2_core_Node* node_msg =
-        envoy_api_v2_DiscoveryRequest_mutable_node(request, arena.ptr());
-    PopulateNode(arena.ptr(), node_, build_version_, user_agent_name_, "",
-                 node_msg);
+      envoy_api_v2_DiscoveryRequest_new(arena.ptr());
+  // Set type_url.
+  envoy_api_v2_DiscoveryRequest_set_type_url(
+      request, upb_strview_make(type_url.data(), type_url.size()));
+  // Set version_info.
+  if (!version.empty()) {
+    envoy_api_v2_DiscoveryRequest_set_version_info(
+        request, upb_strview_make(version.data(), version.size()));
   }
-  // Add resource_name.
-  envoy_api_v2_DiscoveryRequest_add_resource_names(
-      request,
-      upb_strview_make(route_config_name.data(), route_config_name.size()),
-      arena.ptr());
-  MaybeLogDiscoveryRequest(client_, tracer_, request);
-  return SerializeDiscoveryRequest(arena.ptr(), request);
-}
-
-grpc_slice XdsApi::CreateCdsRequest(const std::set<StringView>& cluster_names,
-                                    const std::string& version,
-                                    const std::string& nonce, grpc_error* error,
-                                    bool populate_node) {
-  upb::Arena arena;
-  envoy_api_v2_DiscoveryRequest* request =
-      CreateDiscoveryRequest(arena.ptr(), kCdsTypeUrl, version, nonce, error);
-  // Populate node.
-  if (populate_node) {
-    envoy_api_v2_core_Node* node_msg =
-        envoy_api_v2_DiscoveryRequest_mutable_node(request, arena.ptr());
-    PopulateNode(arena.ptr(), node_, build_version_, user_agent_name_, "",
-                 node_msg);
+  // Set nonce.
+  if (!nonce.empty()) {
+    envoy_api_v2_DiscoveryRequest_set_response_nonce(
+        request, upb_strview_make(nonce.data(), nonce.size()));
   }
-  // Add resource_names.
-  for (const auto& cluster_name : cluster_names) {
-    envoy_api_v2_DiscoveryRequest_add_resource_names(
-        request, upb_strview_make(cluster_name.data(), cluster_name.size()),
-        arena.ptr());
+  // Set error_detail if it's a NACK.
+  if (error != GRPC_ERROR_NONE) {
+    grpc_slice error_description_slice;
+    GPR_ASSERT(grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION,
+                                  &error_description_slice));
+    upb_strview error_description_strview =
+        upb_strview_make(reinterpret_cast<const char*>(
+                             GPR_SLICE_START_PTR(error_description_slice)),
+                         GPR_SLICE_LENGTH(error_description_slice));
+    google_rpc_Status* error_detail =
+        envoy_api_v2_DiscoveryRequest_mutable_error_detail(request,
+                                                           arena.ptr());
+    google_rpc_Status_set_message(error_detail, error_description_strview);
+    GRPC_ERROR_UNREF(error);
   }
-  MaybeLogDiscoveryRequest(client_, tracer_, request);
-  return SerializeDiscoveryRequest(arena.ptr(), request);
-}
-
-grpc_slice XdsApi::CreateEdsRequest(
-    const std::set<StringView>& eds_service_names, const std::string& version,
-    const std::string& nonce, grpc_error* error, bool populate_node) {
-  upb::Arena arena;
-  envoy_api_v2_DiscoveryRequest* request =
-      CreateDiscoveryRequest(arena.ptr(), kEdsTypeUrl, version, nonce, error);
   // Populate node.
   if (populate_node) {
     envoy_api_v2_core_Node* node_msg =
@@ -552,10 +572,9 @@ grpc_slice XdsApi::CreateEdsRequest(
                  node_msg);
   }
   // Add resource_names.
-  for (const auto& eds_service_name : eds_service_names) {
+  for (const auto& resource_name : resource_names) {
     envoy_api_v2_DiscoveryRequest_add_resource_names(
-        request,
-        upb_strview_make(eds_service_name.data(), eds_service_name.size()),
+        request, upb_strview_make(resource_name.data(), resource_name.size()),
         arena.ptr());
   }
   MaybeLogDiscoveryRequest(client_, tracer_, request);
@@ -678,7 +697,34 @@ void MaybeLogRouteConfiguration(
                 envoy_api_v2_route_RouteAction_cluster_header(action), &fields);
           } else if (envoy_api_v2_route_RouteAction_has_weighted_clusters(
                          action)) {
-            fields.emplace_back("      weighted_clusters: <not printed>");
+            const envoy_api_v2_route_WeightedCluster* weighted_clusters =
+                envoy_api_v2_route_RouteAction_weighted_clusters(action);
+            fields.emplace_back("      weighted_clusters {");
+            size_t num_cluster_weights;
+            const envoy_api_v2_route_WeightedCluster_ClusterWeight* const*
+                cluster_weights = envoy_api_v2_route_WeightedCluster_clusters(
+                    weighted_clusters, &num_cluster_weights);
+            for (size_t i = 0; i < num_cluster_weights; ++i) {
+              const envoy_api_v2_route_WeightedCluster_ClusterWeight*
+                  cluster_weight = cluster_weights[i];
+              fields.emplace_back("        clusters {");
+              AddStringField(
+                  "          name",
+                  envoy_api_v2_route_WeightedCluster_ClusterWeight_name(
+                      cluster_weight),
+                  &fields);
+              AddUInt32ValueField(
+                  "          weight",
+                  envoy_api_v2_route_WeightedCluster_ClusterWeight_weight(
+                      cluster_weight),
+                  &fields);
+              fields.emplace_back("        }");
+            }
+            AddUInt32ValueField("        total_weight",
+                                envoy_api_v2_route_WeightedCluster_total_weight(
+                                    weighted_clusters),
+                                &fields);
+            fields.emplace_back("      }");
           }
           fields.emplace_back("    }");
         } else if (envoy_api_v2_route_Route_has_redirect(route)) {
@@ -839,14 +885,11 @@ void MaybeLogClusterLoadAssignment(
         fields.emplace_back("  }");
       }
       // load_balancing_weight
-      const google_protobuf_UInt32Value* lb_weight =
+      AddUInt32ValueField(
+          "  load_balancing_weight",
           envoy_api_v2_endpoint_LocalityLbEndpoints_load_balancing_weight(
-              locality_endpoint);
-      if (lb_weight != nullptr) {
-        fields.emplace_back(
-            absl::StrCat("  load_balancing_weight { value: ",
-                         google_protobuf_UInt32Value_value(lb_weight), " }"));
-      }
+              locality_endpoint),
+          &fields);
       // priority
       uint32_t priority =
           envoy_api_v2_endpoint_LocalityLbEndpoints_priority(locality_endpoint);
@@ -923,16 +966,18 @@ bool DomainMatch(MatchType match_type, std::string domain_pattern,
   } else if (match_type == SUFFIX_MATCH) {
     // Asterisk must match at least one char.
     if (expected_host_name.size() < domain_pattern.size()) return false;
-    StringView pattern_suffix(domain_pattern.c_str() + 1);
-    StringView host_suffix(expected_host_name.c_str() +
-                           expected_host_name.size() - pattern_suffix.size());
+    absl::string_view pattern_suffix(domain_pattern.c_str() + 1);
+    absl::string_view host_suffix(expected_host_name.c_str() +
+                                  expected_host_name.size() -
+                                  pattern_suffix.size());
     return pattern_suffix == host_suffix;
   } else if (match_type == PREFIX_MATCH) {
     // Asterisk must match at least one char.
     if (expected_host_name.size() < domain_pattern.size()) return false;
-    StringView pattern_prefix(domain_pattern.c_str(),
-                              domain_pattern.size() - 1);
-    StringView host_prefix(expected_host_name.c_str(), pattern_prefix.size());
+    absl::string_view pattern_prefix(domain_pattern.c_str(),
+                                     domain_pattern.size() - 1);
+    absl::string_view host_prefix(expected_host_name.c_str(),
+                                  pattern_prefix.size());
     return pattern_prefix == host_prefix;
   } else {
     return match_type == UNIVERSE_MATCH;
@@ -948,6 +993,267 @@ MatchType DomainPatternMatchType(const std::string& domain_pattern) {
   return INVALID_MATCH;
 }
 
+grpc_error* RoutePathMatchParse(const envoy_api_v2_route_RouteMatch* match,
+                                XdsApi::RdsUpdate::RdsRoute* rds_route,
+                                bool* ignore_route) {
+  if (envoy_api_v2_route_RouteMatch_has_prefix(match)) {
+    upb_strview prefix = envoy_api_v2_route_RouteMatch_prefix(match);
+    // Empty prefix "" is accepted.
+    if (prefix.size > 0) {
+      // Prefix "/" is accepted.
+      if (prefix.data[0] != '/') {
+        // Prefix which does not start with a / will never match anything, so
+        // ignore this route.
+        *ignore_route = true;
+        return GRPC_ERROR_NONE;
+      }
+      std::vector<absl::string_view> prefix_elements =
+          absl::StrSplit(absl::string_view(prefix.data, prefix.size).substr(1),
+                         absl::MaxSplits('/', 2));
+      if (prefix_elements.size() > 2) {
+        // Prefix cannot have more than 2 slashes.
+        *ignore_route = true;
+        return GRPC_ERROR_NONE;
+      } else if (prefix_elements.size() == 2 && prefix_elements[0].empty()) {
+        // Prefix contains empty string between the 2 slashes
+        *ignore_route = true;
+        return GRPC_ERROR_NONE;
+      }
+    }
+    rds_route->matchers.path_matcher.type = XdsApi::RdsUpdate::RdsRoute::
+        Matchers::PathMatcher::PathMatcherType::PREFIX;
+    rds_route->matchers.path_matcher.string_matcher =
+        UpbStringToStdString(prefix);
+  } else if (envoy_api_v2_route_RouteMatch_has_path(match)) {
+    upb_strview path = envoy_api_v2_route_RouteMatch_path(match);
+    if (path.size == 0) {
+      // Path that is empty will never match anything, so ignore this route.
+      *ignore_route = true;
+      return GRPC_ERROR_NONE;
+    }
+    if (path.data[0] != '/') {
+      // Path which does not start with a / will never match anything, so
+      // ignore this route.
+      *ignore_route = true;
+      return GRPC_ERROR_NONE;
+    }
+    std::vector<absl::string_view> path_elements =
+        absl::StrSplit(absl::string_view(path.data, path.size).substr(1),
+                       absl::MaxSplits('/', 2));
+    if (path_elements.size() != 2) {
+      // Path not in the required format of /service/method will never match
+      // anything, so ignore this route.
+      *ignore_route = true;
+      return GRPC_ERROR_NONE;
+    } else if (path_elements[0].empty()) {
+      // Path contains empty service name will never match anything, so ignore
+      // this route.
+      *ignore_route = true;
+      return GRPC_ERROR_NONE;
+    } else if (path_elements[1].empty()) {
+      // Path contains empty method name will never match anything, so ignore
+      // this route.
+      *ignore_route = true;
+      return GRPC_ERROR_NONE;
+    }
+    rds_route->matchers.path_matcher.type = XdsApi::RdsUpdate::RdsRoute::
+        Matchers::PathMatcher::PathMatcherType::PATH;
+    rds_route->matchers.path_matcher.string_matcher =
+        UpbStringToStdString(path);
+  } else if (envoy_api_v2_route_RouteMatch_has_safe_regex(match)) {
+    const envoy_type_matcher_RegexMatcher* regex_matcher =
+        envoy_api_v2_route_RouteMatch_safe_regex(match);
+    GPR_ASSERT(regex_matcher != nullptr);
+    const std::string matcher = UpbStringToStdString(
+        envoy_type_matcher_RegexMatcher_regex(regex_matcher));
+    std::unique_ptr<RE2> regex = absl::make_unique<RE2>(matcher);
+    if (!regex->ok()) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "Invalid regex string specified in path matcher.");
+    }
+    rds_route->matchers.path_matcher.type = XdsApi::RdsUpdate::RdsRoute::
+        Matchers::PathMatcher::PathMatcherType::REGEX;
+    rds_route->matchers.path_matcher.regex_matcher = std::move(regex);
+  } else {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Invalid route path specifier specified.");
+  }
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error* RouteHeaderMatchersParse(const envoy_api_v2_route_RouteMatch* match,
+                                     XdsApi::RdsUpdate::RdsRoute* rds_route) {
+  size_t size;
+  const envoy_api_v2_route_HeaderMatcher* const* headers =
+      envoy_api_v2_route_RouteMatch_headers(match, &size);
+  for (size_t i = 0; i < size; ++i) {
+    const envoy_api_v2_route_HeaderMatcher* header = headers[i];
+    XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher header_matcher;
+    header_matcher.name =
+        UpbStringToStdString(envoy_api_v2_route_HeaderMatcher_name(header));
+    if (envoy_api_v2_route_HeaderMatcher_has_exact_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::EXACT;
+      header_matcher.string_matcher = UpbStringToStdString(
+          envoy_api_v2_route_HeaderMatcher_exact_match(header));
+    } else if (envoy_api_v2_route_HeaderMatcher_has_safe_regex_match(header)) {
+      const envoy_type_matcher_RegexMatcher* regex_matcher =
+          envoy_api_v2_route_HeaderMatcher_safe_regex_match(header);
+      GPR_ASSERT(regex_matcher != nullptr);
+      const std::string matcher = UpbStringToStdString(
+          envoy_type_matcher_RegexMatcher_regex(regex_matcher));
+      std::unique_ptr<RE2> regex = absl::make_unique<RE2>(matcher);
+      if (!regex->ok()) {
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "Invalid regex string specified in header matcher.");
+      }
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::REGEX;
+      header_matcher.regex_match = std::move(regex);
+    } else if (envoy_api_v2_route_HeaderMatcher_has_range_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::RANGE;
+      const envoy_type_Int64Range* range_matcher =
+          envoy_api_v2_route_HeaderMatcher_range_match(header);
+      header_matcher.range_start = envoy_type_Int64Range_start(range_matcher);
+      header_matcher.range_end = envoy_type_Int64Range_end(range_matcher);
+      if (header_matcher.range_end < header_matcher.range_start) {
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "Invalid range header matcher specifier specified: end "
+            "cannot be smaller than start.");
+      }
+    } else if (envoy_api_v2_route_HeaderMatcher_has_present_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::PRESENT;
+      header_matcher.present_match =
+          envoy_api_v2_route_HeaderMatcher_present_match(header);
+    } else if (envoy_api_v2_route_HeaderMatcher_has_prefix_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::PREFIX;
+      header_matcher.string_matcher = UpbStringToStdString(
+          envoy_api_v2_route_HeaderMatcher_prefix_match(header));
+    } else if (envoy_api_v2_route_HeaderMatcher_has_suffix_match(header)) {
+      header_matcher.type = XdsApi::RdsUpdate::RdsRoute::Matchers::
+          HeaderMatcher::HeaderMatcherType::SUFFIX;
+      header_matcher.string_matcher = UpbStringToStdString(
+          envoy_api_v2_route_HeaderMatcher_suffix_match(header));
+    } else {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "Invalid route header matcher specified.");
+    }
+    header_matcher.invert_match =
+        envoy_api_v2_route_HeaderMatcher_invert_match(header);
+    rds_route->matchers.header_matchers.emplace_back(std::move(header_matcher));
+  }
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error* RouteRuntimeFractionParse(
+    const envoy_api_v2_route_RouteMatch* match,
+    XdsApi::RdsUpdate::RdsRoute* rds_route) {
+  const envoy_api_v2_core_RuntimeFractionalPercent* runtime_fraction =
+      envoy_api_v2_route_RouteMatch_runtime_fraction(match);
+  if (runtime_fraction != nullptr) {
+    const envoy_type_FractionalPercent* fraction =
+        envoy_api_v2_core_RuntimeFractionalPercent_default_value(
+            runtime_fraction);
+    if (fraction != nullptr) {
+      uint32_t numerator = envoy_type_FractionalPercent_numerator(fraction);
+      const auto denominator =
+          static_cast<envoy_type_FractionalPercent_DenominatorType>(
+              envoy_type_FractionalPercent_denominator(fraction));
+      // Normalize to million.
+      switch (denominator) {
+        case envoy_type_FractionalPercent_HUNDRED:
+          numerator *= 10000;
+          break;
+        case envoy_type_FractionalPercent_TEN_THOUSAND:
+          numerator *= 100;
+          break;
+        case envoy_type_FractionalPercent_MILLION:
+          break;
+        default:
+          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "Unknown denominator type");
+      }
+      rds_route->matchers.fraction_per_million = numerator;
+    }
+  }
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error* RouteActionParse(const envoy_api_v2_route_Route* route,
+                             XdsApi::RdsUpdate::RdsRoute* rds_route,
+                             bool* ignore_route) {
+  if (!envoy_api_v2_route_Route_has_route(route)) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "No RouteAction found in route.");
+  }
+  const envoy_api_v2_route_RouteAction* route_action =
+      envoy_api_v2_route_Route_route(route);
+  // Get the cluster or weighted_clusters in the RouteAction.
+  if (envoy_api_v2_route_RouteAction_has_cluster(route_action)) {
+    const upb_strview cluster_name =
+        envoy_api_v2_route_RouteAction_cluster(route_action);
+    if (cluster_name.size == 0) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "RouteAction cluster contains empty cluster name.");
+    }
+    rds_route->cluster_name = UpbStringToStdString(cluster_name);
+  } else if (envoy_api_v2_route_RouteAction_has_weighted_clusters(
+                 route_action)) {
+    const envoy_api_v2_route_WeightedCluster* weighted_cluster =
+        envoy_api_v2_route_RouteAction_weighted_clusters(route_action);
+    uint32_t total_weight = 100;
+    const google_protobuf_UInt32Value* weight =
+        envoy_api_v2_route_WeightedCluster_total_weight(weighted_cluster);
+    if (weight != nullptr) {
+      total_weight = google_protobuf_UInt32Value_value(weight);
+    }
+    size_t clusters_size;
+    const envoy_api_v2_route_WeightedCluster_ClusterWeight* const* clusters =
+        envoy_api_v2_route_WeightedCluster_clusters(weighted_cluster,
+                                                    &clusters_size);
+    uint32_t sum_of_weights = 0;
+    for (size_t j = 0; j < clusters_size; ++j) {
+      const envoy_api_v2_route_WeightedCluster_ClusterWeight* cluster_weight =
+          clusters[j];
+      XdsApi::RdsUpdate::RdsRoute::ClusterWeight cluster;
+      cluster.name = UpbStringToStdString(
+          envoy_api_v2_route_WeightedCluster_ClusterWeight_name(
+              cluster_weight));
+      if (cluster.name.empty()) {
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "RouteAction weighted_cluster cluster contains empty cluster "
+            "name.");
+      }
+      const google_protobuf_UInt32Value* weight =
+          envoy_api_v2_route_WeightedCluster_ClusterWeight_weight(
+              cluster_weight);
+      if (weight == nullptr) {
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "RouteAction weighted_cluster cluster missing weight");
+      }
+      cluster.weight = google_protobuf_UInt32Value_value(weight);
+      sum_of_weights += cluster.weight;
+      rds_route->weighted_clusters.emplace_back(std::move(cluster));
+    }
+    if (total_weight != sum_of_weights) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "RouteAction weighted_cluster has incorrect total weight");
+    }
+    if (rds_route->weighted_clusters.empty()) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "RouteAction weighted_cluster has no valid clusters specified.");
+    }
+  } else {
+    // No cluster or weighted_clusters found in RouteAction, ignore this route.
+    *ignore_route = true;
+    return GRPC_ERROR_NONE;
+  }
+  return GRPC_ERROR_NONE;
+}
+
 grpc_error* RouteConfigParse(
     XdsClient* client, TraceFlag* tracer,
     const envoy_api_v2_RouteConfiguration* route_config,
@@ -1011,34 +1317,41 @@ grpc_error* RouteConfigParse(
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "No route found in the virtual host.");
   }
-  // Only look at the last one in the route list (the default route),
-  const envoy_api_v2_route_Route* route = routes[size - 1];
-  // Validate that the match field must have a prefix field which is an empty
-  // string.
-  const envoy_api_v2_route_RouteMatch* match =
-      envoy_api_v2_route_Route_match(route);
-  if (!envoy_api_v2_route_RouteMatch_has_prefix(match)) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "No prefix field found in RouteMatch.");
-  }
-  const upb_strview prefix = envoy_api_v2_route_RouteMatch_prefix(match);
-  if (!upb_strview_eql(prefix, upb_strview_makez(""))) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Prefix is not empty string.");
-  }
-  if (!envoy_api_v2_route_Route_has_route(route)) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "No RouteAction found in route.");
+  // Loop over the whole list of routes
+  for (size_t i = 0; i < size; ++i) {
+    const envoy_api_v2_route_Route* route = routes[i];
+    const envoy_api_v2_route_RouteMatch* match =
+        envoy_api_v2_route_Route_match(route);
+    size_t query_parameters_size;
+    static_cast<void>(envoy_api_v2_route_RouteMatch_query_parameters(
+        match, &query_parameters_size));
+    if (query_parameters_size > 0) {
+      continue;
+    }
+    XdsApi::RdsUpdate::RdsRoute rds_route;
+    bool ignore_route = false;
+    grpc_error* error = RoutePathMatchParse(match, &rds_route, &ignore_route);
+    if (error != GRPC_ERROR_NONE) return error;
+    if (ignore_route) continue;
+    error = RouteHeaderMatchersParse(match, &rds_route);
+    if (error != GRPC_ERROR_NONE) return error;
+    error = RouteRuntimeFractionParse(match, &rds_route);
+    if (error != GRPC_ERROR_NONE) return error;
+    error = RouteActionParse(route, &rds_route, &ignore_route);
+    if (error != GRPC_ERROR_NONE) return error;
+    if (ignore_route) continue;
+    const google_protobuf_BoolValue* case_sensitive =
+        envoy_api_v2_route_RouteMatch_case_sensitive(match);
+    if (case_sensitive != nullptr &&
+        !google_protobuf_BoolValue_value(case_sensitive)) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "case_sensitive if set must be set to true.");
+    }
+    rds_update->routes.emplace_back(std::move(rds_route));
   }
-  const envoy_api_v2_route_RouteAction* route_action =
-      envoy_api_v2_route_Route_route(route);
-  // Get the cluster in the RouteAction.
-  if (!envoy_api_v2_route_RouteAction_has_cluster(route_action)) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "No cluster found in RouteAction.");
+  if (rds_update->routes.empty()) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No valid routes specified.");
   }
-  const upb_strview cluster =
-      envoy_api_v2_route_RouteAction_cluster(route_action);
-  rds_update->cluster_name = std::string(cluster.data, cluster.size);
   return GRPC_ERROR_NONE;
 }
 
@@ -1075,7 +1388,7 @@ grpc_error* LdsResponseParse(XdsClient* client, TraceFlag* tracer,
         envoy_api_v2_Listener_api_listener(listener);
     if (api_listener == nullptr) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "Listener doesn't have ApiListener.");
+          "Listener has no ApiListener.");
     }
     const upb_strview encoded_api_listener = google_protobuf_Any_value(
         envoy_config_listener_v2_ApiListener_api_listener(api_listener));
@@ -1103,27 +1416,37 @@ grpc_error* LdsResponseParse(XdsClient* client, TraceFlag* tracer,
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "HttpConnectionManager neither has inlined route_config nor RDS.");
     }
-    // Get the route_config_name.
     const envoy_config_filter_network_http_connection_manager_v2_Rds* rds =
         envoy_config_filter_network_http_connection_manager_v2_HttpConnectionManager_rds(
             http_connection_manager);
-    const upb_strview route_config_name =
-        envoy_config_filter_network_http_connection_manager_v2_Rds_route_config_name(
+    // Check that the ConfigSource specifies ADS.
+    const envoy_api_v2_core_ConfigSource* config_source =
+        envoy_config_filter_network_http_connection_manager_v2_Rds_config_source(
             rds);
+    if (config_source == nullptr) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "HttpConnectionManager missing config_source for RDS.");
+    }
+    if (!envoy_api_v2_core_ConfigSource_has_ads(config_source)) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "HttpConnectionManager ConfigSource for RDS does not specify ADS.");
+    }
+    // Get the route_config_name.
     lds_update->emplace();
-    (*lds_update)->route_config_name =
-        std::string(route_config_name.data, route_config_name.size);
+    (*lds_update)->route_config_name = UpbStringToStdString(
+        envoy_config_filter_network_http_connection_manager_v2_Rds_route_config_name(
+            rds));
     return GRPC_ERROR_NONE;
   }
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* RdsResponseParse(XdsClient* client, TraceFlag* tracer,
-                             const envoy_api_v2_DiscoveryResponse* response,
-                             const std::string& expected_server_name,
-                             const std::string& expected_route_config_name,
-                             absl::optional<XdsApi::RdsUpdate>* rds_update,
-                             upb_arena* arena) {
+grpc_error* RdsResponseParse(
+    XdsClient* client, TraceFlag* tracer,
+    const envoy_api_v2_DiscoveryResponse* response,
+    const std::string& expected_server_name,
+    const std::set<absl::string_view>& expected_route_configuration_names,
+    absl::optional<XdsApi::RdsUpdate>* rds_update, upb_arena* arena) {
   // Get the resources from the response.
   size_t size;
   const google_protobuf_Any* const* resources =
@@ -1144,10 +1467,14 @@ grpc_error* RdsResponseParse(XdsClient* client, TraceFlag* tracer,
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Can't decode route_config.");
     }
     // Check route_config_name. Ignore unexpected route_config.
-    const upb_strview name = envoy_api_v2_RouteConfiguration_name(route_config);
-    const upb_strview expected_name =
-        upb_strview_makez(expected_route_config_name.c_str());
-    if (!upb_strview_eql(name, expected_name)) continue;
+    const upb_strview route_config_name =
+        envoy_api_v2_RouteConfiguration_name(route_config);
+    absl::string_view route_config_name_strview(route_config_name.data,
+                                                route_config_name.size);
+    if (expected_route_configuration_names.find(route_config_name_strview) ==
+        expected_route_configuration_names.end()) {
+      continue;
+    }
     // Parse the route_config.
     XdsApi::RdsUpdate local_rds_update;
     grpc_error* error = RouteConfigParse(
@@ -1159,11 +1486,11 @@ grpc_error* RdsResponseParse(XdsClient* client, TraceFlag* tracer,
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* CdsResponseParse(XdsClient* client, TraceFlag* tracer,
-                             const envoy_api_v2_DiscoveryResponse* response,
-                             const std::set<StringView>& expected_cluster_names,
-                             XdsApi::CdsUpdateMap* cds_update_map,
-                             upb_arena* arena) {
+grpc_error* CdsResponseParse(
+    XdsClient* client, TraceFlag* tracer,
+    const envoy_api_v2_DiscoveryResponse* response,
+    const std::set<absl::string_view>& expected_cluster_names,
+    XdsApi::CdsUpdateMap* cds_update_map, upb_arena* arena) {
   // Get the resources from the response.
   size_t size;
   const google_protobuf_Any* const* resources =
@@ -1186,7 +1513,8 @@ grpc_error* CdsResponseParse(XdsClient* client, TraceFlag* tracer,
     MaybeLogCluster(client, tracer, cluster);
     // Ignore unexpected cluster names.
     upb_strview cluster_name = envoy_api_v2_Cluster_name(cluster);
-    StringView cluster_name_strview(cluster_name.data, cluster_name.size);
+    absl::string_view cluster_name_strview(cluster_name.data,
+                                           cluster_name.size);
     if (expected_cluster_names.find(cluster_name_strview) ==
         expected_cluster_names.end()) {
       continue;
@@ -1204,14 +1532,14 @@ grpc_error* CdsResponseParse(XdsClient* client, TraceFlag* tracer,
     const envoy_api_v2_core_ConfigSource* eds_config =
         envoy_api_v2_Cluster_EdsClusterConfig_eds_config(eds_cluster_config);
     if (!envoy_api_v2_core_ConfigSource_has_ads(eds_config)) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("ConfigSource is not ADS.");
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "EDS ConfigSource is not ADS.");
     }
     // Record EDS service_name (if any).
     upb_strview service_name =
         envoy_api_v2_Cluster_EdsClusterConfig_service_name(eds_cluster_config);
     if (service_name.size != 0) {
-      cds_update.eds_service_name =
-          std::string(service_name.data, service_name.size);
+      cds_update.eds_service_name = UpbStringToStdString(service_name);
     }
     // Check the LB policy.
     if (envoy_api_v2_Cluster_lb_policy(cluster) !=
@@ -1225,11 +1553,11 @@ grpc_error* CdsResponseParse(XdsClient* client, TraceFlag* tracer,
     if (lrs_server != nullptr) {
       if (!envoy_api_v2_core_ConfigSource_has_self(lrs_server)) {
         return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "ConfigSource is not self.");
+            "LRS ConfigSource is not self.");
       }
       cds_update.lrs_load_reporting_server_name.emplace("");
     }
-    cds_update_map->emplace(std::string(cluster_name.data, cluster_name.size),
+    cds_update_map->emplace(UpbStringToStdString(cluster_name),
                             std::move(cds_update));
   }
   return GRPC_ERROR_NONE;
@@ -1290,8 +1618,8 @@ grpc_error* LocalityParse(
   upb_strview zone = envoy_api_v2_core_Locality_region(locality);
   upb_strview sub_zone = envoy_api_v2_core_Locality_sub_zone(locality);
   output_locality->name = MakeRefCounted<XdsLocalityName>(
-      std::string(region.data, region.size), std::string(zone.data, zone.size),
-      std::string(sub_zone.data, sub_zone.size));
+      UpbStringToStdString(region), UpbStringToStdString(zone),
+      UpbStringToStdString(sub_zone));
   // Parse the addresses.
   size_t size;
   const envoy_api_v2_endpoint_LbEndpoint* const* lb_endpoints =
@@ -1341,15 +1669,14 @@ grpc_error* DropParseAndAppend(
   }
   // Cap numerator to 1000000.
   numerator = GPR_MIN(numerator, 1000000);
-  drop_config->AddCategory(std::string(category.data, category.size),
-                           numerator);
+  drop_config->AddCategory(UpbStringToStdString(category), numerator);
   return GRPC_ERROR_NONE;
 }
 
 grpc_error* EdsResponseParse(
     XdsClient* client, TraceFlag* tracer,
     const envoy_api_v2_DiscoveryResponse* response,
-    const std::set<StringView>& expected_eds_service_names,
+    const std::set<absl::string_view>& expected_eds_service_names,
     XdsApi::EdsUpdateMap* eds_update_map, upb_arena* arena) {
   // Get the resources from the response.
   size_t size;
@@ -1378,7 +1705,8 @@ grpc_error* EdsResponseParse(
     // unexpected names.
     upb_strview cluster_name = envoy_api_v2_ClusterLoadAssignment_cluster_name(
         cluster_load_assignment);
-    StringView cluster_name_strview(cluster_name.data, cluster_name.size);
+    absl::string_view cluster_name_strview(cluster_name.data,
+                                           cluster_name.size);
     if (expected_eds_service_names.find(cluster_name_strview) ==
         expected_eds_service_names.end()) {
       continue;
@@ -1420,14 +1748,7 @@ grpc_error* EdsResponseParse(
         if (error != GRPC_ERROR_NONE) return error;
       }
     }
-    // Validate the update content.
-    if (eds_update.priority_list_update.empty() &&
-        !eds_update.drop_config->drop_all()) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "EDS response doesn't contain any valid "
-          "locality but doesn't require to drop all calls.");
-    }
-    eds_update_map->emplace(std::string(cluster_name.data, cluster_name.size),
+    eds_update_map->emplace(UpbStringToStdString(cluster_name),
                             std::move(eds_update));
   }
   return GRPC_ERROR_NONE;
@@ -1437,9 +1758,9 @@ grpc_error* EdsResponseParse(
 
 grpc_error* XdsApi::ParseAdsResponse(
     const grpc_slice& encoded_response, const std::string& expected_server_name,
-    const std::string& expected_route_config_name,
-    const std::set<StringView>& expected_cluster_names,
-    const std::set<StringView>& expected_eds_service_names,
+    const std::set<absl::string_view>& expected_route_configuration_names,
+    const std::set<absl::string_view>& expected_cluster_names,
+    const std::set<absl::string_view>& expected_eds_service_names,
     absl::optional<LdsUpdate>* lds_update,
     absl::optional<RdsUpdate>* rds_update, CdsUpdateMap* cds_update_map,
     EdsUpdateMap* eds_update_map, std::string* version, std::string* nonce,
@@ -1460,19 +1781,19 @@ grpc_error* XdsApi::ParseAdsResponse(
   // Record the type_url, the version_info, and the nonce of the response.
   upb_strview type_url_strview =
       envoy_api_v2_DiscoveryResponse_type_url(response);
-  *type_url = std::string(type_url_strview.data, type_url_strview.size);
+  *type_url = UpbStringToStdString(type_url_strview);
   upb_strview version_info =
       envoy_api_v2_DiscoveryResponse_version_info(response);
-  *version = std::string(version_info.data, version_info.size);
+  *version = UpbStringToStdString(version_info);
   upb_strview nonce_strview = envoy_api_v2_DiscoveryResponse_nonce(response);
-  *nonce = std::string(nonce_strview.data, nonce_strview.size);
+  *nonce = UpbStringToStdString(nonce_strview);
   // Parse the response according to the resource type.
   if (*type_url == kLdsTypeUrl) {
     return LdsResponseParse(client_, tracer_, response, expected_server_name,
                             lds_update, arena.ptr());
   } else if (*type_url == kRdsTypeUrl) {
     return RdsResponseParse(client_, tracer_, response, expected_server_name,
-                            expected_route_config_name, rds_update,
+                            expected_route_configuration_names, rds_update,
                             arena.ptr());
   } else if (*type_url == kCdsTypeUrl) {
     return CdsResponseParse(client_, tracer_, response, expected_cluster_names,
@@ -1626,6 +1947,9 @@ grpc_slice XdsApi::CreateLrsInitialRequest(const std::string& server_name) {
                                                                 arena.ptr());
   PopulateNode(arena.ptr(), node_, build_version_, user_agent_name_,
                server_name, node_msg);
+  envoy_api_v2_core_Node_add_client_features(
+      node_msg, upb_strview_makez("envoy.lrs.supports_send_all_clusters"),
+      arena.ptr());
   MaybeLogLrsRequest(client_, tracer_, request);
   return SerializeLrsRequest(request, arena.ptr());
 }
@@ -1744,6 +2068,7 @@ grpc_slice XdsApi::CreateLrsRequest(
 }
 
 grpc_error* XdsApi::ParseLrsResponse(const grpc_slice& encoded_response,
+                                     bool* send_all_clusters,
                                      std::set<std::string>* cluster_names,
                                      grpc_millis* load_reporting_interval) {
   upb::Arena arena;
@@ -1756,13 +2081,19 @@ grpc_error* XdsApi::ParseLrsResponse(const grpc_slice& encoded_response,
   if (decoded_response == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Can't decode response.");
   }
-  // Store the cluster names.
-  size_t size;
-  const upb_strview* clusters =
-      envoy_service_load_stats_v2_LoadStatsResponse_clusters(decoded_response,
-                                                             &size);
-  for (size_t i = 0; i < size; ++i) {
-    cluster_names->emplace(clusters[i].data, clusters[i].size);
+  // Check send_all_clusters.
+  if (envoy_service_load_stats_v2_LoadStatsResponse_send_all_clusters(
+          decoded_response)) {
+    *send_all_clusters = true;
+  } else {
+    // Store the cluster names.
+    size_t size;
+    const upb_strview* clusters =
+        envoy_service_load_stats_v2_LoadStatsResponse_clusters(decoded_response,
+                                                               &size);
+    for (size_t i = 0; i < size; ++i) {
+      cluster_names->emplace(clusters[i].data, clusters[i].size);
+    }
   }
   // Get the load report interval.
   const google_protobuf_Duration* load_reporting_interval_duration =