grpc 1.43.1 → 1.45.0

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -18,8 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/random/random.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/str_replace.h"
 #include "absl/strings/str_split.h"
 #include "re2/re2.h"
 #define XXH_INLINE_ALL
@@ -27,14 +29,19 @@
 
 #include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h"
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_http_filters.h"
+#include "src/core/ext/xds/xds_listener.h"
+#include "src/core/ext/xds/xds_route_config.h"
 #include "src/core/ext/xds/xds_routing.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/service_config/service_config_impl.h"
+#include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 
 namespace grpc_core {
@@ -45,6 +52,24 @@ const char* kXdsClusterAttribute = "xds_cluster_name";
 
 namespace {
 
+std::string GetDefaultAuthorityInternal(const URI& uri) {
+  // Obtain the authority to use for the data plane connections, which is
+  // also used to select the right VirtualHost from the RouteConfiguration.
+  // We need to take the part of the URI path following the last
+  // "/" character or the entire path if the path contains no "/" character.
+  size_t pos = uri.path().find_last_of('/');
+  if (pos == uri.path().npos) return uri.path();
+  return uri.path().substr(pos + 1);
+}
+
+std::string GetDataPlaneAuthority(const grpc_channel_args& args,
+                                  const URI& uri) {
+  const char* authority =
+      grpc_channel_args_find_string(&args, GRPC_ARG_DEFAULT_AUTHORITY);
+  if (authority != nullptr) return authority;
+  return GetDefaultAuthorityInternal(uri);
+}
+
 //
 // XdsResolver
 //
@@ -54,12 +79,16 @@ class XdsResolver : public Resolver {
   explicit XdsResolver(ResolverArgs args)
       : work_serializer_(std::move(args.work_serializer)),
         result_handler_(std::move(args.result_handler)),
-        server_name_(absl::StripPrefix(args.uri.path(), "/")),
         args_(grpc_channel_args_copy(args.args)),
-        interested_parties_(args.pollset_set) {
+        interested_parties_(args.pollset_set),
+        uri_(std::move(args.uri)),
+        data_plane_authority_(GetDataPlaneAuthority(*args.args, uri_)),
+        channel_id_(absl::Uniform<uint64_t>(absl::BitGen())) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
-      gpr_log(GPR_INFO, "[xds_resolver %p] created for server name %s", this,
-              server_name_.c_str());
+      gpr_log(
+          GPR_INFO,
+          "[xds_resolver %p] created for URI %s; data plane authority is %s",
+          this, uri_.ToString().c_str(), data_plane_authority_.c_str());
     }
   }
 
@@ -79,11 +108,11 @@ class XdsResolver : public Resolver {
   }
 
  private:
-  class ListenerWatcher : public XdsClient::ListenerWatcherInterface {
+  class ListenerWatcher : public XdsListenerResourceType::WatcherInterface {
    public:
     explicit ListenerWatcher(RefCountedPtr<XdsResolver> resolver)
         : resolver_(std::move(resolver)) {}
-    void OnListenerChanged(XdsApi::LdsUpdate listener) override {
+    void OnResourceChanged(XdsListenerResource listener) override {
       Ref().release();  // ref held by lambda
       resolver_->work_serializer_->Run(
           // TODO(yashykt): When we move to C++14, capture listener with
@@ -117,11 +146,12 @@ class XdsResolver : public Resolver {
     RefCountedPtr<XdsResolver> resolver_;
   };
 
-  class RouteConfigWatcher : public XdsClient::RouteConfigWatcherInterface {
+  class RouteConfigWatcher
+      : public XdsRouteConfigResourceType::WatcherInterface {
    public:
     explicit RouteConfigWatcher(RefCountedPtr<XdsResolver> resolver)
         : resolver_(std::move(resolver)) {}
-    void OnRouteConfigChanged(XdsApi::RdsUpdate route_config) override {
+    void OnResourceChanged(XdsRouteConfigResource route_config) override {
       Ref().release();  // ref held by lambda
       resolver_->work_serializer_->Run(
           // TODO(yashykt): When we move to C++14, capture route_config with
@@ -250,7 +280,7 @@ class XdsResolver : public Resolver {
         bool operator==(const ClusterWeightState& other) const;
       };
 
-      XdsApi::Route route;
+      XdsRouteConfigResource::Route route;
       RefCountedPtr<ServiceConfig> method_config;
       absl::InlinedVector<ClusterWeightState, 2> weighted_cluster_state;
 
@@ -262,8 +292,9 @@ class XdsResolver : public Resolver {
 
     void MaybeAddCluster(const std::string& name);
     grpc_error_handle CreateMethodConfig(
-        const XdsApi::Route& route,
-        const XdsApi::Route::RouteAction::ClusterWeight* cluster_weight,
+        const XdsRouteConfigResource::Route& route,
+        const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
+            cluster_weight,
         RefCountedPtr<ServiceConfig>* method_config);
 
     RefCountedPtr<XdsResolver> resolver_;
@@ -272,33 +303,35 @@ class XdsResolver : public Resolver {
     std::vector<const grpc_channel_filter*> filters_;
   };
 
-  void OnListenerUpdate(XdsApi::LdsUpdate listener);
-  void OnRouteConfigUpdate(XdsApi::RdsUpdate rds_update);
+  void OnListenerUpdate(XdsListenerResource listener);
+  void OnRouteConfigUpdate(XdsRouteConfigResource rds_update);
   void OnError(grpc_error_handle error);
   void OnResourceDoesNotExist();
 
-  grpc_error_handle CreateServiceConfig(
-      RefCountedPtr<ServiceConfig>* service_config);
+  absl::StatusOr<RefCountedPtr<ServiceConfig>> CreateServiceConfig();
   void GenerateResult();
   void MaybeRemoveUnusedClusters();
+  uint64_t channel_id() const { return channel_id_; }
 
   std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
-  std::string server_name_;
   const grpc_channel_args* args_;
   grpc_pollset_set* interested_parties_;
-
+  URI uri_;
   RefCountedPtr<XdsClient> xds_client_;
+  std::string lds_resource_name_;
+  std::string data_plane_authority_;
+  uint64_t channel_id_;
 
-  XdsClient::ListenerWatcherInterface* listener_watcher_ = nullptr;
+  ListenerWatcher* listener_watcher_ = nullptr;
   // This will not contain the RouteConfiguration, even if it comes with the
   // LDS response; instead, the relevant VirtualHost from the
   // RouteConfiguration will be saved in current_virtual_host_.
-  XdsApi::LdsUpdate current_listener_;
+  XdsListenerResource current_listener_;
 
   std::string route_config_name_;
-  XdsClient::RouteConfigWatcherInterface* route_config_watcher_ = nullptr;
-  XdsApi::RdsUpdate::VirtualHost current_virtual_host_;
+  RouteConfigWatcher* route_config_watcher_ = nullptr;
+  XdsRouteConfigResource::VirtualHost current_virtual_host_;
 
   ClusterState::ClusterStateMap cluster_state_map_;
 };
@@ -336,7 +369,7 @@ class XdsResolver::XdsConfigSelector::RouteListIterator
 
   size_t Size() const override { return route_table_->size(); }
 
-  const XdsApi::Route::Matchers& GetMatchersForRoute(
+  const XdsRouteConfigResource::Route::Matchers& GetMatchersForRoute(
       size_t index) const override {
     return (*route_table_)[index].route.matchers;
   }
@@ -375,7 +408,8 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
     auto& route_entry = route_table_.back();
     route_entry.route = route;
     auto* route_action =
-        absl::get_if<XdsApi::Route::RouteAction>(&route_entry.route.action);
+        absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
+            &route_entry.route.action);
     if (route_action != nullptr) {
       // If the route doesn't specify a timeout, set its timeout to the global
       // one.
@@ -431,27 +465,29 @@ XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
 }
 
 grpc_error_handle XdsResolver::XdsConfigSelector::CreateMethodConfig(
-    const XdsApi::Route& route,
-    const XdsApi::Route::RouteAction::ClusterWeight* cluster_weight,
+    const XdsRouteConfigResource::Route& route,
+    const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
+        cluster_weight,
     RefCountedPtr<ServiceConfig>* method_config) {
   std::vector<std::string> fields;
   const auto& route_action =
-      absl::get<XdsApi::Route::RouteAction>(route.action);
+      absl::get<XdsRouteConfigResource::Route::RouteAction>(route.action);
   // Set retry policy if any.
   if (route_action.retry_policy.has_value() &&
       !route_action.retry_policy->retry_on.Empty()) {
     std::vector<std::string> retry_parts;
+    const auto base_interval =
+        route_action.retry_policy->retry_back_off.base_interval.as_timespec();
+    const auto max_interval =
+        route_action.retry_policy->retry_back_off.max_interval.as_timespec();
     retry_parts.push_back(absl::StrFormat(
         "\"retryPolicy\": {\n"
         "      \"maxAttempts\": %d,\n"
         "      \"initialBackoff\": \"%d.%09ds\",\n"
         "      \"maxBackoff\": \"%d.%09ds\",\n"
         "      \"backoffMultiplier\": 2,\n",
-        route_action.retry_policy->num_retries + 1,
-        route_action.retry_policy->retry_back_off.base_interval.seconds,
-        route_action.retry_policy->retry_back_off.base_interval.nanos,
-        route_action.retry_policy->retry_back_off.max_interval.seconds,
-        route_action.retry_policy->retry_back_off.max_interval.nanos));
+        route_action.retry_policy->num_retries + 1, base_interval.tv_sec,
+        base_interval.tv_nsec, max_interval.tv_sec, max_interval.tv_nsec));
     std::vector<std::string> code_parts;
     if (route_action.retry_policy->retry_on.Contains(GRPC_STATUS_CANCELLED)) {
       code_parts.push_back("        \"CANCELLED\"");
@@ -478,12 +514,10 @@ grpc_error_handle XdsResolver::XdsConfigSelector::CreateMethodConfig(
   }
   // Set timeout.
   if (route_action.max_stream_duration.has_value() &&
-      (route_action.max_stream_duration->seconds != 0 ||
-       route_action.max_stream_duration->nanos != 0)) {
-    fields.emplace_back(
-        absl::StrFormat("    \"timeout\": \"%d.%09ds\"",
-                        route_action.max_stream_duration->seconds,
-                        route_action.max_stream_duration->nanos));
+      (route_action.max_stream_duration != Duration::Zero())) {
+    gpr_timespec ts = route_action.max_stream_duration->as_timespec();
+    fields.emplace_back(absl::StrFormat("    \"timeout\": \"%d.%09ds\"",
+                                        ts.tv_sec, ts.tv_nsec));
   }
   // Handle xDS HTTP filters.
   XdsRouting::GeneratePerHttpFilterConfigsResult result =
@@ -512,7 +546,8 @@ grpc_error_handle XdsResolver::XdsConfigSelector::CreateMethodConfig(
         absl::StrJoin(fields, ",\n"),
         "\n  } ]\n"
         "}");
-    *method_config = ServiceConfig::Create(result.args, json.c_str(), &error);
+    *method_config =
+        ServiceConfigImpl::Create(result.args, json.c_str(), &error);
   }
   grpc_channel_args_destroy(result.args);
   return error;
@@ -536,9 +571,10 @@ void XdsResolver::XdsConfigSelector::MaybeAddCluster(const std::string& name) {
 }
 
 absl::optional<uint64_t> HeaderHashHelper(
-    const XdsApi::Route::RouteAction::HashPolicy& policy,
+    const XdsRouteConfigResource::Route::RouteAction::HashPolicy& policy,
     grpc_metadata_batch* initial_metadata) {
-  GPR_ASSERT(policy.type == XdsApi::Route::RouteAction::HashPolicy::HEADER);
+  GPR_ASSERT(policy.type ==
+             XdsRouteConfigResource::Route::RouteAction::HashPolicy::HEADER);
   std::string value_buffer;
   absl::optional<absl::string_view> header_value = XdsRouting::GetHeaderValue(
       initial_metadata, policy.header_name, &value_buffer);
@@ -568,7 +604,8 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
   auto& entry = route_table_[*route_index];
   // Found a route match
   const auto* route_action =
-      absl::get_if<XdsApi::Route::RouteAction>(&entry.route.action);
+      absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
+          &entry.route.action);
   if (route_action == nullptr) {
     CallConfig call_config;
     call_config.error =
@@ -615,12 +652,11 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
   for (const auto& hash_policy : route_action->hash_policies) {
     absl::optional<uint64_t> new_hash;
     switch (hash_policy.type) {
-      case XdsApi::Route::RouteAction::HashPolicy::HEADER:
+      case XdsRouteConfigResource::Route::RouteAction::HashPolicy::HEADER:
         new_hash = HeaderHashHelper(hash_policy, args.initial_metadata);
         break;
-      case XdsApi::Route::RouteAction::HashPolicy::CHANNEL_ID:
-        new_hash =
-            static_cast<uint64_t>(reinterpret_cast<uintptr_t>(resolver_.get()));
+      case XdsRouteConfigResource::Route::RouteAction::HashPolicy::CHANNEL_ID:
+        new_hash = resolver_->channel_id();
         break;
       default:
         GPR_ASSERT(0);
@@ -639,13 +675,7 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
     }
   }
   if (!hash.has_value()) {
-    // If there is no hash, we just choose a random value as a default.
-    // We cannot directly use the result of rand() as the hash value,
-    // since it is a 32-bit number and not a 64-bit number and will
-    // therefore not be evenly distributed.
-    uint32_t upper = rand();
-    uint32_t lower = rand();
-    hash = (static_cast<uint64_t>(upper) << 32) | lower;
+    hash = absl::Uniform<uint64_t>(absl::BitGen());
   }
   CallConfig call_config;
   if (method_config != nullptr) {
@@ -677,14 +707,62 @@ void XdsResolver::StartLocked() {
             "Failed to create xds client -- channel will remain in "
             "TRANSIENT_FAILURE: %s",
             grpc_error_std_string(error).c_str());
-    result_handler_->ReturnError(error);
+    std::string error_message;
+    grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION, &error_message);
+    Result result;
+    result.service_config = absl::UnavailableError(
+        absl::StrCat("Failed to create XdsClient: ", error_message));
+    result_handler_->ReportResult(std::move(result));
+    GRPC_ERROR_UNREF(error);
     return;
   }
+  std::string resource_name_fragment(absl::StripPrefix(uri_.path(), "/"));
+  if (!uri_.authority().empty()) {
+    // target_uri.authority is set case
+    const auto* authority_config =
+        xds_client_->bootstrap().LookupAuthority(uri_.authority());
+    if (authority_config == nullptr) {
+      Result result;
+      result.service_config = absl::UnavailableError(
+          absl::StrCat("Invalid target URI -- authority not found for %s.",
+                       uri_.authority().c_str()));
+      result_handler_->ReportResult(std::move(result));
+      return;
+    }
+    std::string name_template =
+        authority_config->client_listener_resource_name_template;
+    if (name_template.empty()) {
+      name_template = absl::StrCat(
+          "xdstp://", URI::PercentEncodeAuthority(uri_.authority()),
+          "/envoy.config.listener.v3.Listener/%s");
+    }
+    lds_resource_name_ = absl::StrReplaceAll(
+        name_template,
+        {{"%s", URI::PercentEncodePath(resource_name_fragment)}});
+  } else {
+    // target_uri.authority not set
+    absl::string_view name_template =
+        xds_client_->bootstrap()
+            .client_default_listener_resource_name_template();
+    if (name_template.empty()) {
+      name_template = "%s";
+    }
+    if (absl::StartsWith(name_template, "xdstp:")) {
+      resource_name_fragment = URI::PercentEncodePath(resource_name_fragment);
+    }
+    lds_resource_name_ =
+        absl::StrReplaceAll(name_template, {{"%s", resource_name_fragment}});
+  }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    gpr_log(GPR_INFO, "[xds_resolver %p] Started with lds_resource_name %s.",
+            this, lds_resource_name_.c_str());
+  }
   grpc_pollset_set_add_pollset_set(xds_client_->interested_parties(),
                                    interested_parties_);
   auto watcher = MakeRefCounted<ListenerWatcher>(Ref());
   listener_watcher_ = watcher.get();
-  xds_client_->WatchListenerData(server_name_, std::move(watcher));
+  XdsListenerResourceType::StartWatch(xds_client_.get(), lds_resource_name_,
+                                      std::move(watcher));
 }
 
 void XdsResolver::ShutdownLocked() {
@@ -693,12 +771,14 @@ void XdsResolver::ShutdownLocked() {
   }
   if (xds_client_ != nullptr) {
     if (listener_watcher_ != nullptr) {
-      xds_client_->CancelListenerDataWatch(server_name_, listener_watcher_,
-                                           /*delay_unsubscription=*/false);
+      XdsListenerResourceType::CancelWatch(
+          xds_client_.get(), lds_resource_name_, listener_watcher_,
+          /*delay_unsubscription=*/false);
     }
     if (route_config_watcher_ != nullptr) {
-      xds_client_->CancelRouteConfigDataWatch(
-          server_name_, route_config_watcher_, /*delay_unsubscription=*/false);
+      XdsRouteConfigResourceType::CancelWatch(
+          xds_client_.get(), route_config_name_, route_config_watcher_,
+          /*delay_unsubscription=*/false);
     }
     grpc_pollset_set_del_pollset_set(xds_client_->interested_parties(),
                                      interested_parties_);
@@ -706,7 +786,7 @@ void XdsResolver::ShutdownLocked() {
   }
 }
 
-void XdsResolver::OnListenerUpdate(XdsApi::LdsUpdate listener) {
+void XdsResolver::OnListenerUpdate(XdsListenerResource listener) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] received updated listener data", this);
   }
@@ -716,8 +796,8 @@ void XdsResolver::OnListenerUpdate(XdsApi::LdsUpdate listener) {
   if (listener.http_connection_manager.route_config_name !=
       route_config_name_) {
     if (route_config_watcher_ != nullptr) {
-      xds_client_->CancelRouteConfigDataWatch(
-          route_config_name_, route_config_watcher_,
+      XdsRouteConfigResourceType::CancelWatch(
+          xds_client_.get(), route_config_name_, route_config_watcher_,
           /*delay_unsubscription=*/
           !listener.http_connection_manager.route_config_name.empty());
       route_config_watcher_ = nullptr;
@@ -728,7 +808,8 @@ void XdsResolver::OnListenerUpdate(XdsApi::LdsUpdate listener) {
       current_virtual_host_.routes.clear();
       auto watcher = MakeRefCounted<RouteConfigWatcher>(Ref());
       route_config_watcher_ = watcher.get();
-      xds_client_->WatchRouteConfigData(route_config_name_, std::move(watcher));
+      XdsRouteConfigResourceType::StartWatch(
+          xds_client_.get(), route_config_name_, std::move(watcher));
     }
   }
   current_listener_ = std::move(listener);
@@ -748,7 +829,7 @@ namespace {
 class VirtualHostListIterator : public XdsRouting::VirtualHostListIterator {
  public:
   explicit VirtualHostListIterator(
-      const std::vector<XdsApi::RdsUpdate::VirtualHost>* virtual_hosts)
+      const std::vector<XdsRouteConfigResource::VirtualHost>* virtual_hosts)
       : virtual_hosts_(virtual_hosts) {}
 
   size_t Size() const override { return virtual_hosts_->size(); }
@@ -759,11 +840,11 @@ class VirtualHostListIterator : public XdsRouting::VirtualHostListIterator {
   }
 
  private:
-  const std::vector<XdsApi::RdsUpdate::VirtualHost>* virtual_hosts_;
+  const std::vector<XdsRouteConfigResource::VirtualHost>* virtual_hosts_;
 };
 }  // namespace
 
-void XdsResolver::OnRouteConfigUpdate(XdsApi::RdsUpdate rds_update) {
+void XdsResolver::OnRouteConfigUpdate(XdsRouteConfigResource rds_update) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] received updated route config", this);
   }
@@ -772,10 +853,11 @@ void XdsResolver::OnRouteConfigUpdate(XdsApi::RdsUpdate rds_update) {
   }
   // Find the relevant VirtualHost from the RouteConfiguration.
   auto vhost_index = XdsRouting::FindVirtualHostForDomain(
-      VirtualHostListIterator(&rds_update.virtual_hosts), server_name_);
+      VirtualHostListIterator(&rds_update.virtual_hosts),
+      data_plane_authority_);
   if (!vhost_index.has_value()) {
     OnError(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("could not find VirtualHost for ", server_name_,
+        absl::StrCat("could not find VirtualHost for ", data_plane_authority_,
                      " in RouteConfiguration")));
     return;
   }
@@ -795,8 +877,10 @@ void XdsResolver::OnError(grpc_error_handle error) {
   Result result;
   grpc_arg new_arg = xds_client_->MakeChannelArg();
   result.args = grpc_channel_args_copy_and_add(args_, &new_arg, 1);
-  result.service_config_error = error;
-  result_handler_->ReturnResult(std::move(result));
+  result.service_config = absl::UnavailableError(absl::StrCat(
+      "error obtaining xDS resources: ", grpc_error_std_string(error)));
+  result_handler_->ReportResult(std::move(result));
+  GRPC_ERROR_UNREF(error);
 }
 
 void XdsResolver::OnResourceDoesNotExist() {
@@ -809,15 +893,15 @@ void XdsResolver::OnResourceDoesNotExist() {
   }
   current_virtual_host_.routes.clear();
   Result result;
-  result.service_config =
-      ServiceConfig::Create(args_, "{}", &result.service_config_error);
-  GPR_ASSERT(result.service_config != nullptr);
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  result.service_config = ServiceConfigImpl::Create(args_, "{}", &error);
+  GPR_ASSERT(*result.service_config != nullptr);
   result.args = grpc_channel_args_copy(args_);
-  result_handler_->ReturnResult(std::move(result));
+  result_handler_->ReportResult(std::move(result));
 }
 
-grpc_error_handle XdsResolver::CreateServiceConfig(
-    RefCountedPtr<ServiceConfig>* service_config) {
+absl::StatusOr<RefCountedPtr<ServiceConfig>>
+XdsResolver::CreateServiceConfig() {
   std::vector<std::string> clusters;
   for (const auto& cluster : cluster_state_map_) {
     clusters.push_back(
@@ -844,8 +928,13 @@ grpc_error_handle XdsResolver::CreateServiceConfig(
       "}");
   std::string json = absl::StrJoin(config_parts, "");
   grpc_error_handle error = GRPC_ERROR_NONE;
-  *service_config = ServiceConfig::Create(args_, json.c_str(), &error);
-  return error;
+  absl::StatusOr<RefCountedPtr<ServiceConfig>> result =
+      ServiceConfigImpl::Create(args_, json.c_str(), &error);
+  if (error != GRPC_ERROR_NONE) {
+    result = grpc_error_to_absl_status(error);
+    GRPC_ERROR_UNREF(error);
+  }
+  return result;
 }
 
 void XdsResolver::GenerateResult() {
@@ -860,15 +949,12 @@ void XdsResolver::GenerateResult() {
     return;
   }
   Result result;
-  error = CreateServiceConfig(&result.service_config);
-  if (error != GRPC_ERROR_NONE) {
-    OnError(grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS,
-                               GRPC_STATUS_UNAVAILABLE));
-    return;
-  }
+  result.service_config = CreateServiceConfig();
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] generated service config: %s", this,
-            result.service_config->json_string().c_str());
+            result.service_config.ok()
+                ? std::string((*result.service_config)->json_string()).c_str()
+                : result.service_config.status().ToString().c_str());
   }
   grpc_arg new_args[] = {
       xds_client_->MakeChannelArg(),
@@ -876,7 +962,7 @@ void XdsResolver::GenerateResult() {
   };
   result.args =
       grpc_channel_args_copy_and_add(args_, new_args, GPR_ARRAY_SIZE(new_args));
-  result_handler_->ReturnResult(std::move(result));
+  result_handler_->ReportResult(std::move(result));
 }
 
 void XdsResolver::MaybeRemoveUnusedClusters() {
@@ -902,29 +988,32 @@ void XdsResolver::MaybeRemoveUnusedClusters() {
 
 class XdsResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "xds"; }
+
   bool IsValidUri(const URI& uri) const override {
-    if (GPR_UNLIKELY(!uri.authority().empty())) {
-      gpr_log(GPR_ERROR, "URI authority not supported");
+    if (uri.path().empty() || uri.path().back() == '/') {
+      gpr_log(GPR_ERROR,
+              "URI path does not contain valid data plane authority");
       return false;
     }
     return true;
   }
 
+  std::string GetDefaultAuthority(const URI& uri) const override {
+    return GetDefaultAuthorityInternal(uri);
+  }
+
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     if (!IsValidUri(args.uri)) return nullptr;
     return MakeOrphanable<XdsResolver>(std::move(args));
   }
-
-  const char* scheme() const override { return "xds"; }
 };
 
 }  // namespace
 
-}  // namespace grpc_core
-
-void grpc_resolver_xds_init() {
-  grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      absl::make_unique<grpc_core::XdsResolverFactory>());
+void RegisterXdsResolver(CoreConfiguration::Builder* builder) {
+  builder->resolver_registry()->RegisterResolverFactory(
+      absl::make_unique<XdsResolverFactory>());
 }
 
-void grpc_resolver_xds_shutdown() {}
+}  // namespace grpc_core

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

@@ -31,12 +31,12 @@
 
 #include "src/core/ext/filters/client_channel/client_channel.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/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/json/json_util.h"
+#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.
@@ -45,18 +45,15 @@
 namespace grpc_core {
 namespace internal {
 
-namespace {
-size_t g_client_channel_service_config_parser_index;
-}
-
 size_t ClientChannelServiceConfigParser::ParserIndex() {
-  return g_client_channel_service_config_parser_index;
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
 }
 
-void ClientChannelServiceConfigParser::Register() {
-  g_client_channel_service_config_parser_index =
-      ServiceConfigParser::RegisterParser(
-          absl::make_unique<ClientChannelServiceConfigParser>());
+void ClientChannelServiceConfigParser::Register(
+    CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      absl::make_unique<ClientChannelServiceConfigParser>());
 }
 
 namespace {
@@ -173,7 +170,7 @@ ClientChannelServiceConfigParser::ParsePerMethodParams(
     }
   }
   // Parse timeout.
-  grpc_millis timeout = 0;
+  Duration timeout;
   ParseJsonObjectFieldAsDuration(json.object_value(), "timeout", &timeout,
                                  &error_list, false);
   // Return result.