grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h

@@ -21,19 +21,23 @@
 
 #include <stdlib.h>
 
-#include <vector>
+#include "absl/status/statusor.h"
 
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
-extern const char* kRequestRingHashAttribute;
+
+UniqueTypeName RequestHashAttributeName();
 
 // Helper Parsing method to parse ring hash policy configs; for example, ring
 // hash size validity.
-void ParseRingHashLbConfig(const Json& json, size_t* min_ring_size,
-                           size_t* max_ring_size,
-                           std::vector<grpc_error_handle>* error_list);
+struct RingHashConfig {
+  size_t min_ring_size = 1024;
+  size_t max_ring_size = 8388608;
+};
+absl::StatusOr<RingHashConfig> ParseRingHashLbConfig(const Json& json);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H

data/src/core/ext/filters/client_channel/lb_policy/rls/rls.cc

@@ -39,7 +39,6 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/container/inlined_vector.h"
 #include "absl/hash/hash.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
@@ -64,11 +63,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
-#include "src/core/ext/filters/client_channel/lb_policy.h"
 #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/subchannel_interface.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
@@ -80,14 +75,18 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_util.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/lib/load_balancing/lb_policy_factory.h"
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
+#include "src/core/lib/load_balancing/subchannel_interface.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -108,7 +107,7 @@ TraceFlag grpc_lb_rls_trace(false, "rls_lb");
 
 namespace {
 
-const char* kRls = "rls_experimental";
+constexpr absl::string_view kRls = "rls_experimental";
 const char kGrpc[] = "grpc";
 const char* kRlsRequestPath = "/grpc.lookup.v1.RouteLookupService/RouteLookup";
 const char* kFakeTargetFieldValue = "fake_target_field_value";
@@ -163,7 +162,7 @@ class RlsLbConfig : public LoadBalancingPolicy::Config {
         default_child_policy_parsed_config_(
             std::move(default_child_policy_parsed_config)) {}
 
-  const char* name() const override { return kRls; }
+  absl::string_view name() const override { return kRls; }
 
   const KeyBuilderMap& key_builder_map() const {
     return route_lookup_config_.key_builder_map;
@@ -208,7 +207,7 @@ class RlsLb : public LoadBalancingPolicy {
  public:
   explicit RlsLb(Args args);
 
-  const char* name() const override { return kRls; }
+  absl::string_view name() const override { return kRls; }
   void UpdateLocked(UpdateArgs args) override;
   void ExitIdleLocked() override;
   void ResetBackoffLocked() override;
@@ -325,7 +324,7 @@ class RlsLb : public LoadBalancingPolicy {
       }
 
       RefCountedPtr<SubchannelInterface> CreateSubchannel(
-          ServerAddress address, const grpc_channel_args& args) override;
+          ServerAddress address, const ChannelArgs& args) override;
       void UpdateState(grpc_connectivity_state state,
                        const absl::Status& status,
                        std::unique_ptr<SubchannelPicker> picker) override;
@@ -707,7 +706,7 @@ class RlsLb : public LoadBalancingPolicy {
 
   // Accessed only from within WorkSerializer.
   absl::StatusOr<ServerAddressList> addresses_;
-  const grpc_channel_args* channel_args_ = nullptr;
+  ChannelArgs channel_args_;
   RefCountedPtr<RlsLbConfig> config_;
   RefCountedPtr<ChildPolicyWrapper> default_child_policy_;
   std::map<std::string /*target*/, ChildPolicyWrapper*> child_policy_map_;
@@ -783,7 +782,7 @@ void RlsLb::ChildPolicyWrapper::StartUpdate() {
   grpc_error_handle error = InsertOrUpdateChildPolicyField(
       lb_policy_->config_->child_policy_config_target_field_name(), target_,
       &child_policy_config);
-  GPR_ASSERT(error == GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(
         GPR_INFO,
@@ -791,23 +790,23 @@ void RlsLb::ChildPolicyWrapper::StartUpdate() {
         lb_policy_.get(), this, target_.c_str(),
         child_policy_config.Dump().c_str());
   }
-  pending_config_ = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-      child_policy_config, &error);
+  auto config = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
+      child_policy_config);
   // Returned RLS target fails the validation.
-  if (error != GRPC_ERROR_NONE) {
+  if (!config.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
       gpr_log(GPR_INFO,
               "[rlslb %p] ChildPolicyWrapper=%p [%s]: config failed to parse: "
-              "%s; config: %s",
+              "%s",
               lb_policy_.get(), this, target_.c_str(),
-              grpc_error_std_string(error).c_str(),
-              child_policy_config.Dump().c_str());
+              config.status().ToString().c_str());
     }
     pending_config_.reset();
     picker_ = absl::make_unique<TransientFailurePicker>(
-        grpc_error_to_absl_status(error));
-    GRPC_ERROR_UNREF(error);
+        absl::UnavailableError(config.status().message()));
     child_policy_.reset();
+  } else {
+    pending_config_ = std::move(*config);
   }
 }
 
@@ -843,7 +842,7 @@ void RlsLb::ChildPolicyWrapper::MaybeFinishUpdate() {
   UpdateArgs update_args;
   update_args.config = std::move(pending_config_);
   update_args.addresses = lb_policy_->addresses_;
-  update_args.args = grpc_channel_args_copy(lb_policy_->channel_args_);
+  update_args.args = lb_policy_->channel_args_;
   child_policy_->UpdateLocked(std::move(update_args));
 }
 
@@ -853,7 +852,7 @@ void RlsLb::ChildPolicyWrapper::MaybeFinishUpdate() {
 
 RefCountedPtr<SubchannelInterface>
 RlsLb::ChildPolicyWrapper::ChildPolicyHelper::CreateSubchannel(
-    ServerAddress address, const grpc_channel_args& args) {
+    ServerAddress address, const ChannelArgs& args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO,
             "[rlslb %p] ChildPolicyWrapper=%p [%s] ChildPolicyHelper=%p: "
@@ -1084,7 +1083,8 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
                 "[rlslb %p] picker=%p: RLS call in backoff; failing pick",
                 lb_policy_.get(), this);
       }
-      return PickResult::Fail(entry->status());
+      return PickResult::Fail(absl::UnavailableError(
+          absl::StrCat("RLS request failed: ", entry->status().ToString())));
     }
   }
   // RLS call pending.  Queue the pick.
@@ -1191,46 +1191,48 @@ size_t RlsLb::Cache::Entry::Size() const {
 }
 
 LoadBalancingPolicy::PickResult RlsLb::Cache::Entry::Pick(PickArgs args) {
-  for (const auto& child_policy_wrapper : child_policy_wrappers_) {
+  size_t i = 0;
+  ChildPolicyWrapper* child_policy_wrapper = nullptr;
+  // Skip targets before the last one that are in state TRANSIENT_FAILURE.
+  for (; i < child_policy_wrappers_.size(); ++i) {
+    child_policy_wrapper = child_policy_wrappers_[i].get();
     if (child_policy_wrapper->connectivity_state() ==
-        GRPC_CHANNEL_TRANSIENT_FAILURE) {
+            GRPC_CHANNEL_TRANSIENT_FAILURE &&
+        i < child_policy_wrappers_.size() - 1) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
         gpr_log(GPR_INFO,
-                "[rlslb %p] cache entry=%p %s: target %s in state "
-                "TRANSIENT_FAILURE; skipping",
+                "[rlslb %p] cache entry=%p %s: target %s (%" PRIuPTR
+                " of %" PRIuPTR ") in state TRANSIENT_FAILURE; skipping",
                 lb_policy_.get(), this, lru_iterator_->ToString().c_str(),
-                child_policy_wrapper->target().c_str());
+                child_policy_wrapper->target().c_str(), i,
+                child_policy_wrappers_.size());
       }
       continue;
     }
-    // Child policy not in TRANSIENT_FAILURE, so delegate.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
-      gpr_log(
-          GPR_INFO,
-          "[rlslb %p] cache entry=%p %s: target %s in state %s; "
-          "delegating",
-          lb_policy_.get(), this, lru_iterator_->ToString().c_str(),
-          child_policy_wrapper->target().c_str(),
-          ConnectivityStateName(child_policy_wrapper->connectivity_state()));
-    }
-    // Add header data.
-    if (!header_data_.empty()) {
-      char* copied_header_data =
-          static_cast<char*>(args.call_state->Alloc(header_data_.length() + 1));
-      strcpy(copied_header_data, header_data_.c_str());
-      args.initial_metadata->Add(kRlsHeaderKey, copied_header_data);
-    }
-    return child_policy_wrapper->Pick(args);
+    break;
   }
-  // No child policy found.
+  // Child policy not in TRANSIENT_FAILURE or is the last target in
+  // the list, so delegate.
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO,
-            "[rlslb %p] cache entry=%p %s: no healthy target found; "
-            "failing pick",
-            lb_policy_.get(), this, lru_iterator_->ToString().c_str());
-  }
-  return PickResult::Fail(
-      absl::UnavailableError("all RLS targets unreachable"));
+            "[rlslb %p] cache entry=%p %s: target %s (%" PRIuPTR " of %" PRIuPTR
+            ") in state %s; delegating",
+            lb_policy_.get(), this, lru_iterator_->ToString().c_str(),
+            child_policy_wrapper->target().c_str(), i,
+            child_policy_wrappers_.size(),
+            ConnectivityStateName(child_policy_wrapper->connectivity_state()));
+  }
+  // Add header data.
+  // Note that even if the target we're using is in TRANSIENT_FAILURE,
+  // the pick might still succeed (e.g., if the child is ring_hash), so
+  // we need to pass the right header info down in all cases.
+  if (!header_data_.empty()) {
+    char* copied_header_data =
+        static_cast<char*>(args.call_state->Alloc(header_data_.length() + 1));
+    strcpy(copied_header_data, header_data_.c_str());
+    args.initial_metadata->Add(kRlsHeaderKey, copied_header_data);
+  }
+  return child_policy_wrapper->Pick(args);
 }
 
 void RlsLb::Cache::Entry::ResetBackoff() {
@@ -1541,41 +1543,32 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
   // Get channel creds from parent channel.
   // TODO(roth): Once we eliminate insecure builds, get this via a
   // method on the helper instead of digging through channel args.
-  grpc_channel_credentials* creds =
-      grpc_channel_credentials_find_in_args(lb_policy_->channel_args_);
+  auto* creds = lb_policy_->channel_args_.GetObject<grpc_channel_credentials>();
   // Use the parent channel's authority.
   std::string authority(lb_policy_->channel_control_helper()->GetAuthority());
-  absl::InlinedVector<grpc_arg, 3> args = {
-      grpc_channel_arg_string_create(
-          const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY),
-          const_cast<char*>(authority.c_str())),
-      grpc_channel_arg_integer_create(
-          const_cast<char*>(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL), 1),
-  };
+  ChannelArgs args = ChannelArgs()
+                         .Set(GRPC_ARG_DEFAULT_AUTHORITY, authority)
+                         .Set(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, 1);
   // Propagate fake security connector expected targets, if any.
   // (This is ugly, but it seems better than propagating all channel args
   // from the parent channel by default and then having a giant
   // exclude list of args to strip out, like we do in grpclb.)
-  const char* fake_security_expected_targets = grpc_channel_args_find_string(
-      lb_policy_->channel_args_, GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS);
-  if (fake_security_expected_targets != nullptr) {
-    args.push_back(grpc_channel_arg_string_create(
-        const_cast<char*>(GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS),
-        const_cast<char*>(fake_security_expected_targets)));
+  absl::optional<absl::string_view> fake_security_expected_targets =
+      lb_policy_->channel_args_.GetString(
+          GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS);
+  if (fake_security_expected_targets.has_value()) {
+    args = args.Set(GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS,
+                    *fake_security_expected_targets);
   }
   // Add service config args if needed.
   const std::string& service_config =
       lb_policy_->config_->rls_channel_service_config();
   if (!service_config.empty()) {
-    args.push_back(grpc_channel_arg_string_create(
-        const_cast<char*>(GRPC_ARG_SERVICE_CONFIG),
-        const_cast<char*>(service_config.c_str())));
-    args.push_back(grpc_channel_arg_integer_create(
-        const_cast<char*>(GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION), 1));
+    args = args.Set(GRPC_ARG_SERVICE_CONFIG, service_config)
+               .Set(GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION, 1);
   }
-  grpc_channel_args rls_channel_args = {args.size(), args.data()};
   channel_ = grpc_channel_create(lb_policy_->config_->lookup_service().c_str(),
-                                 creds, &rls_channel_args);
+                                 creds, args.ToC().get());
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] RlsChannel=%p: created channel %p for %s",
             lb_policy_.get(), this, channel_,
@@ -1586,8 +1579,7 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
     channelz::ChannelNode* child_channelz_node =
         grpc_channel_get_channelz_node(channel_);
     channelz::ChannelNode* parent_channelz_node =
-        grpc_channel_args_find_pointer<channelz::ChannelNode>(
-            lb_policy_->channel_args_, GRPC_ARG_CHANNELZ_CHANNEL_NODE);
+        lb_policy_->channel_args_.GetObject<channelz::ChannelNode>();
     if (child_channelz_node != nullptr && parent_channelz_node != nullptr) {
       parent_channelz_node->AddChildChannel(child_channelz_node->uuid());
       parent_channelz_node_ = parent_channelz_node->Ref();
@@ -1776,7 +1768,7 @@ void RlsLb::RlsRequest::OnRlsCallCompleteLocked(grpc_error_handle error) {
   }
   // Parse response.
   ResponseInfo response;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_status_code code;
     std::string message;
     grpc_error_get_status(error, deadline_, &code, &message,
@@ -1887,18 +1879,17 @@ RlsLb::ResponseInfo RlsLb::RlsRequest::ParseResponseProto() {
 // RlsLb
 //
 
-std::string GetServerUri(const grpc_channel_args* args) {
-  const char* server_uri_str =
-      grpc_channel_args_find_string(args, GRPC_ARG_SERVER_URI);
-  GPR_ASSERT(server_uri_str != nullptr);
-  absl::StatusOr<URI> uri = URI::Parse(server_uri_str);
+std::string GetServerUri(const ChannelArgs& args) {
+  auto server_uri_str = args.GetString(GRPC_ARG_SERVER_URI);
+  GPR_ASSERT(server_uri_str.has_value());
+  absl::StatusOr<URI> uri = URI::Parse(*server_uri_str);
   GPR_ASSERT(uri.ok());
   return std::string(absl::StripPrefix(uri->path(), "/"));
 }
 
 RlsLb::RlsLb(Args args)
     : LoadBalancingPolicy(std::move(args)),
-      server_name_(GetServerUri(args.args)),
+      server_name_(GetServerUri(channel_args())),
       cache_(this) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] policy created", this);
@@ -1930,14 +1921,12 @@ void RlsLb::UpdateLocked(UpdateArgs args) {
     old_addresses = addresses_;
   }
   // Swap out channel args.
-  grpc_channel_args_destroy(channel_args_);
-  channel_args_ = grpc_channel_args_copy(args.args);
+  channel_args_ = std::move(args.args);
   // Determine whether we need to update all child policies.
   bool update_child_policies =
       old_config == nullptr ||
       old_config->child_policy_config() != config_->child_policy_config() ||
-      old_addresses != addresses_ ||
-      grpc_channel_args_compare(args.args, channel_args_) != 0;
+      old_addresses != addresses_ || args.args != channel_args_;
   // If default target changes, swap out child policy.
   bool created_default_child = false;
   if (old_config == nullptr ||
@@ -1979,7 +1968,7 @@ void RlsLb::UpdateLocked(UpdateArgs args) {
     // Resize cache if needed.
     if (old_config == nullptr ||
         config_->cache_size_bytes() != old_config->cache_size_bytes()) {
-      cache_.Resize(config_->cache_size_bytes());
+      cache_.Resize(static_cast<size_t>(config_->cache_size_bytes()));
     }
     // Start update of child policies if needed.
     if (update_child_policies) {
@@ -2047,9 +2036,7 @@ void RlsLb::ShutdownLocked() {
   MutexLock lock(&mu_);
   is_shutdown_ = true;
   config_.reset(DEBUG_LOCATION, "ShutdownLocked");
-  if (channel_args_ != nullptr) {
-    grpc_channel_args_destroy(channel_args_);
-  }
+  channel_args_ = ChannelArgs();
   cache_.Shutdown();
   request_map_.clear();
   rls_channel_.reset();
@@ -2230,7 +2217,7 @@ grpc_error_handle ParseGrpcKeybuilder(
         grpc_error_handle child_error = GRPC_ERROR_NONE;
         std::string name =
             ParseJsonMethodName(name_idx++, name_json, &child_error);
-        if (child_error != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(child_error)) {
           error_list.push_back(child_error);
         } else {
           bool inserted = names.insert(name).second;
@@ -2266,7 +2253,7 @@ grpc_error_handle ParseGrpcKeybuilder(
       std::vector<std::string> headers;
       grpc_error_handle child_error =
           ParseJsonHeaders(header_idx++, header_json, &key, &headers);
-      if (child_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(child_error)) {
         error_list.push_back(child_error);
       } else {
         duplicate_key_check_func(key);
@@ -2359,7 +2346,7 @@ RlsLbConfig::KeyBuilderMap ParseGrpcKeybuilders(
   for (const Json& key_builder : key_builder_list) {
     grpc_error_handle child_error =
         ParseGrpcKeybuilder(idx++, key_builder, &key_builder_map);
-    if (child_error != GRPC_ERROR_NONE) error_list.push_back(child_error);
+    if (!GRPC_ERROR_IS_NONE(child_error)) error_list.push_back(child_error);
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("field:grpcKeybuilders", &error_list);
   return key_builder_map;
@@ -2376,7 +2363,7 @@ RlsLbConfig::RouteLookupConfig ParseRouteLookupConfig(
     grpc_error_handle child_error = GRPC_ERROR_NONE;
     route_lookup_config.key_builder_map =
         ParseGrpcKeybuilders(*keybuilder_list, &child_error);
-    if (child_error != GRPC_ERROR_NONE) error_list.push_back(child_error);
+    if (!GRPC_ERROR_IS_NONE(child_error)) error_list.push_back(child_error);
   }
   // Parse lookupService.
   if (ParseJsonObjectField(json, "lookupService",
@@ -2452,45 +2439,44 @@ grpc_error_handle ValidateChildPolicyList(
       default_target.empty() ? kFakeTargetFieldValue : default_target;
   grpc_error_handle error = InsertOrUpdateChildPolicyField(
       child_policy_config_target_field_name, target, child_policy_config);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   // Parse the config.
-  RefCountedPtr<LoadBalancingPolicy::Config> parsed_config =
-      LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-          *child_policy_config, &error);
-  if (error != GRPC_ERROR_NONE) return error;
+  auto parsed_config = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
+      *child_policy_config);
+  if (!parsed_config.ok()) {
+    return absl_status_to_grpc_error(parsed_config.status());
+  }
   // Find the chosen config and return it in JSON form.
   // We remove all non-selected configs, and in the selected config, we leave
   // the target field in place, set to the default value.  This slightly
   // optimizes what we need to do later when we update a child policy for a
   // given target.
-  if (parsed_config != nullptr) {
-    for (Json& config : *(child_policy_config->mutable_array())) {
-      if (config.object_value().begin()->first == parsed_config->name()) {
-        Json save_config = std::move(config);
-        child_policy_config->mutable_array()->clear();
-        child_policy_config->mutable_array()->push_back(std::move(save_config));
-        break;
-      }
+  for (Json& config : *(child_policy_config->mutable_array())) {
+    if (config.object_value().begin()->first == (*parsed_config)->name()) {
+      Json save_config = std::move(config);
+      child_policy_config->mutable_array()->clear();
+      child_policy_config->mutable_array()->push_back(std::move(save_config));
+      break;
     }
   }
   // If default target is set, return the parsed config.
   if (!default_target.empty()) {
-    *default_child_policy_parsed_config = std::move(parsed_config);
+    *default_child_policy_parsed_config = std::move(*parsed_config);
   }
   return GRPC_ERROR_NONE;
 }
 
 class RlsLbFactory : public LoadBalancingPolicyFactory {
  public:
-  const char* name() const override { return kRls; }
+  absl::string_view name() const override { return kRls; }
 
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {
     return MakeOrphanable<RlsLb>(std::move(args));
   }
 
-  RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const Json& config, grpc_error_handle* error) const override {
+  absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
+  ParseLoadBalancingConfig(const Json& config) const override {
     std::vector<grpc_error_handle> error_list;
     // Parse routeLookupConfig.
     RlsLbConfig::RouteLookupConfig route_lookup_config;
@@ -2500,7 +2486,7 @@ class RlsLbFactory : public LoadBalancingPolicyFactory {
       grpc_error_handle child_error = GRPC_ERROR_NONE;
       route_lookup_config =
           ParseRouteLookupConfig(*route_lookup_config_json, &child_error);
-      if (child_error != GRPC_ERROR_NONE) error_list.push_back(child_error);
+      if (!GRPC_ERROR_IS_NONE(child_error)) error_list.push_back(child_error);
     }
     // Parse routeLookupChannelServiceConfig.
     std::string rls_channel_service_config;
@@ -2514,9 +2500,9 @@ class RlsLbFactory : public LoadBalancingPolicyFactory {
           *rls_channel_service_config_json_obj);
       rls_channel_service_config = rls_channel_service_config_json.Dump();
       auto service_config = MakeRefCounted<ServiceConfigImpl>(
-          /*args=*/nullptr, rls_channel_service_config,
+          ChannelArgs(), rls_channel_service_config,
           std::move(rls_channel_service_config_json), &child_error);
-      if (child_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(child_error)) {
         error_list.push_back(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "field:routeLookupChannelServiceConfig", &child_error, 1));
         GRPC_ERROR_UNREF(child_error);
@@ -2548,15 +2534,20 @@ class RlsLbFactory : public LoadBalancingPolicyFactory {
           it->second, child_policy_config_target_field_name,
           route_lookup_config.default_target, &child_policy_config,
           &default_child_policy_parsed_config);
-      if (child_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(child_error)) {
         error_list.push_back(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "field:childPolicy", &child_error, 1));
         GRPC_ERROR_UNREF(child_error);
       }
     }
     // Return result.
-    *error = GRPC_ERROR_CREATE_FROM_VECTOR(
-        "errors parsing RLS LB policy config", &error_list);
+    if (!error_list.empty()) {
+      grpc_error_handle error = GRPC_ERROR_CREATE_FROM_VECTOR(
+          "errors parsing RLS LB policy config", &error_list);
+      std::string error_string = grpc_error_std_string(error);
+      GRPC_ERROR_UNREF(error);
+      return absl::InvalidArgumentError(error_string);
+    }
     return MakeRefCounted<RlsLbConfig>(
         std::move(route_lookup_config), std::move(rls_channel_service_config),
         std::move(child_policy_config),