grpc 1.49.1-x86_64-linux → 1.50.0-x86_64-linux

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

@@ -19,7 +19,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <algorithm>
 #include <atomic>
 #include <map>
 #include <memory>
@@ -32,7 +31,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
@@ -44,21 +42,24 @@
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds.h"
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
+#include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_client_grpc.h"
 #include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/ext/xds/xds_endpoint.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.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"
@@ -105,7 +106,8 @@ class CircuitBreakerCallCounterMap {
   std::map<Key, CallCounter*> map_ ABSL_GUARDED_BY(mu_);
 };
 
-CircuitBreakerCallCounterMap* g_call_counter_map = nullptr;
+CircuitBreakerCallCounterMap* const g_call_counter_map =
+    new CircuitBreakerCallCounterMap;
 
 RefCountedPtr<CircuitBreakerCallCounterMap::CallCounter>
 CircuitBreakerCallCounterMap::GetOrCreate(const std::string& cluster,
@@ -143,18 +145,13 @@ constexpr absl::string_view kXdsClusterImpl = "xds_cluster_impl_experimental";
 // Config for xDS Cluster Impl LB policy.
 class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
  public:
-  XdsClusterImplLbConfig(
-      RefCountedPtr<LoadBalancingPolicy::Config> child_policy,
-      std::string cluster_name, std::string eds_service_name,
-      absl::optional<XdsBootstrap::XdsServer> lrs_load_reporting_server,
-      uint32_t max_concurrent_requests,
-      RefCountedPtr<XdsEndpointResource::DropConfig> drop_config)
-      : child_policy_(std::move(child_policy)),
-        cluster_name_(std::move(cluster_name)),
-        eds_service_name_(std::move(eds_service_name)),
-        lrs_load_reporting_server_(std::move(lrs_load_reporting_server)),
-        max_concurrent_requests_(max_concurrent_requests),
-        drop_config_(std::move(drop_config)) {}
+  XdsClusterImplLbConfig() = default;
+
+  XdsClusterImplLbConfig(const XdsClusterImplLbConfig&) = delete;
+  XdsClusterImplLbConfig& operator=(const XdsClusterImplLbConfig&) = delete;
+
+  XdsClusterImplLbConfig(XdsClusterImplLbConfig&& other) = delete;
+  XdsClusterImplLbConfig& operator=(XdsClusterImplLbConfig&& other) = delete;
 
   absl::string_view name() const override { return kXdsClusterImpl; }
 
@@ -163,8 +160,8 @@ class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
   }
   const std::string& cluster_name() const { return cluster_name_; }
   const std::string& eds_service_name() const { return eds_service_name_; }
-  const absl::optional<XdsBootstrap::XdsServer>& lrs_load_reporting_server()
-      const {
+  const absl::optional<GrpcXdsBootstrap::GrpcXdsServer>&
+  lrs_load_reporting_server() const {
     return lrs_load_reporting_server_;
   };
   uint32_t max_concurrent_requests() const { return max_concurrent_requests_; }
@@ -172,11 +169,15 @@ class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
     return drop_config_;
   }
 
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  void JsonPostLoad(const Json& json, const JsonArgs& args,
+                    ValidationErrors* errors);
+
  private:
   RefCountedPtr<LoadBalancingPolicy::Config> child_policy_;
   std::string cluster_name_;
   std::string eds_service_name_;
-  absl::optional<XdsBootstrap::XdsServer> lrs_load_reporting_server_;
+  absl::optional<GrpcXdsBootstrap::GrpcXdsServer> lrs_load_reporting_server_;
   uint32_t max_concurrent_requests_;
   RefCountedPtr<XdsEndpointResource::DropConfig> drop_config_;
 };
@@ -188,7 +189,7 @@ class XdsClusterImplLb : public LoadBalancingPolicy {
 
   absl::string_view name() const override { return kXdsClusterImpl; }
 
-  void UpdateLocked(UpdateArgs args) override;
+  absl::Status UpdateLocked(UpdateArgs args) override;
   void ExitIdleLocked() override;
   void ResetBackoffLocked() override;
 
@@ -266,9 +267,9 @@ class XdsClusterImplLb : public LoadBalancingPolicy {
 
   OrphanablePtr<LoadBalancingPolicy> CreateChildPolicyLocked(
       const ChannelArgs& args);
-  void UpdateChildPolicyLocked(absl::StatusOr<ServerAddressList> addresses,
-                               std::string resolution_note,
-                               const ChannelArgs& args);
+  absl::Status UpdateChildPolicyLocked(
+      absl::StatusOr<ServerAddressList> addresses, std::string resolution_note,
+      const ChannelArgs& args);
 
   void MaybeUpdatePickerLocked();
 
@@ -480,7 +481,7 @@ void XdsClusterImplLb::ResetBackoffLocked() {
   if (child_policy_ != nullptr) child_policy_->ResetBackoffLocked();
 }
 
-void XdsClusterImplLb::UpdateLocked(UpdateArgs args) {
+absl::Status XdsClusterImplLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
     gpr_log(GPR_INFO, "[xds_cluster_impl_lb %p] Received update", this);
   }
@@ -499,7 +500,8 @@ void XdsClusterImplLb::UpdateLocked(UpdateArgs args) {
                 "[xds_cluster_impl_lb %p] Failed to get cluster drop stats for "
                 "LRS server %s, cluster %s, EDS service name %s, load "
                 "reporting for drops will not be done.",
-                this, config_->lrs_load_reporting_server()->server_uri.c_str(),
+                this,
+                config_->lrs_load_reporting_server()->server_uri().c_str(),
                 config_->cluster_name().c_str(),
                 config_->eds_service_name().c_str());
       }
@@ -521,8 +523,8 @@ void XdsClusterImplLb::UpdateLocked(UpdateArgs args) {
     MaybeUpdatePickerLocked();
   }
   // Update child policy.
-  UpdateChildPolicyLocked(std::move(args.addresses),
-                          std::move(args.resolution_note), args.args);
+  return UpdateChildPolicyLocked(std::move(args.addresses),
+                                 std::move(args.resolution_note), args.args);
 }
 
 void XdsClusterImplLb::MaybeUpdatePickerLocked() {
@@ -578,7 +580,7 @@ OrphanablePtr<LoadBalancingPolicy> XdsClusterImplLb::CreateChildPolicyLocked(
   return lb_policy;
 }
 
-void XdsClusterImplLb::UpdateChildPolicyLocked(
+absl::Status XdsClusterImplLb::UpdateChildPolicyLocked(
     absl::StatusOr<ServerAddressList> addresses, std::string resolution_note,
     const ChannelArgs& args) {
   // Create policy if needed.
@@ -598,7 +600,7 @@ void XdsClusterImplLb::UpdateChildPolicyLocked(
             "[xds_cluster_impl_lb %p] Updating child policy handler %p", this,
             child_policy_.get());
   }
-  child_policy_->UpdateLocked(std::move(update_args));
+  return child_policy_->UpdateLocked(std::move(update_args));
 }
 
 //
@@ -638,7 +640,8 @@ RefCountedPtr<SubchannelInterface> XdsClusterImplLb::Helper::CreateSubchannel(
             "not be generated (not wrapping subchannel)",
             this,
             xds_cluster_impl_policy_->config_->lrs_load_reporting_server()
-                ->server_uri.c_str(),
+                ->server_uri()
+                .c_str(),
             xds_cluster_impl_policy_->config_->cluster_name().c_str(),
             xds_cluster_impl_policy_->config_->eds_service_name().c_str());
   }
@@ -688,6 +691,71 @@ void XdsClusterImplLb::Helper::AddTraceEvent(TraceSeverity severity,
 // factory
 //
 
+struct DropCategory {
+  std::string category;
+  uint32_t requests_per_million;
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader =
+        JsonObjectLoader<DropCategory>()
+            .Field("category", &DropCategory::category)
+            .Field("requests_per_million", &DropCategory::requests_per_million)
+            .Finish();
+    return loader;
+  }
+};
+
+const JsonLoaderInterface* XdsClusterImplLbConfig::JsonLoader(const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<XdsClusterImplLbConfig>()
+          // Note: Some fields require custom processing, so they are
+          // handled in JsonPostLoad() instead.
+          .Field("clusterName", &XdsClusterImplLbConfig::cluster_name_)
+          .OptionalField("edsServiceName",
+                         &XdsClusterImplLbConfig::eds_service_name_)
+          .OptionalField("lrsLoadReportingServer",
+                         &XdsClusterImplLbConfig::lrs_load_reporting_server_)
+          .OptionalField("maxConcurrentRequests",
+                         &XdsClusterImplLbConfig::max_concurrent_requests_)
+          .Finish();
+  return loader;
+}
+
+void XdsClusterImplLbConfig::JsonPostLoad(const Json& json,
+                                          const JsonArgs& args,
+                                          ValidationErrors* errors) {
+  // Parse "childPolicy" field.
+  {
+    ValidationErrors::ScopedField field(errors, ".childPolicy");
+    auto it = json.object_value().find("childPolicy");
+    if (it == json.object_value().end()) {
+      errors->AddError("field not present");
+    } else {
+      auto lb_config = CoreConfiguration::Get()
+                           .lb_policy_registry()
+                           .ParseLoadBalancingConfig(it->second);
+      if (!lb_config.ok()) {
+        errors->AddError(lb_config.status().message());
+      } else {
+        child_policy_ = std::move(*lb_config);
+      }
+    }
+  }
+  // Parse "dropCategories" field.
+  {
+    auto value = LoadJsonObjectField<std::vector<DropCategory>>(
+        json.object_value(), args, "dropCategories", errors);
+    if (value.has_value()) {
+      drop_config_ = MakeRefCounted<XdsEndpointResource::DropConfig>();
+      for (size_t i = 0; i < value->size(); ++i) {
+        DropCategory& drop_category = (*value)[i];
+        drop_config_->AddCategory(std::move(drop_category.category),
+                                  drop_category.requests_per_million);
+      }
+    }
+  }
+}
+
 class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
@@ -716,165 +784,17 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
           "configuration. Please use loadBalancingConfig field of service "
           "config instead.");
     }
-    std::vector<std::string> errors;
-    // Child policy.
-    RefCountedPtr<LoadBalancingPolicy::Config> child_policy;
-    auto it = json.object_value().find("childPolicy");
-    if (it == json.object_value().end()) {
-      errors.emplace_back("field:childPolicy error:required field missing");
-    } else {
-      auto config =
-          LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(it->second);
-      if (!config.ok()) {
-        errors.emplace_back(absl::StrCat("field:childPolicy error:",
-                                         config.status().message()));
-      } else {
-        child_policy = std::move(*config);
-      }
-    }
-    // Cluster name.
-    std::string cluster_name;
-    it = json.object_value().find("clusterName");
-    if (it == json.object_value().end()) {
-      errors.emplace_back("field:clusterName error:required field missing");
-    } else if (it->second.type() != Json::Type::STRING) {
-      errors.emplace_back("field:clusterName error:type should be string");
-    } else {
-      cluster_name = it->second.string_value();
-    }
-    // EDS service name.
-    std::string eds_service_name;
-    it = json.object_value().find("edsServiceName");
-    if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::STRING) {
-        errors.emplace_back("field:edsServiceName error:type should be string");
-      } else {
-        eds_service_name = it->second.string_value();
-      }
-    }
-    // LRS load reporting server name.
-    absl::optional<XdsBootstrap::XdsServer> lrs_load_reporting_server;
-    it = json.object_value().find("lrsLoadReportingServer");
-    if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::OBJECT) {
-        errors.emplace_back(
-            "field:lrsLoadReportingServer error:type should be object");
-      } else {
-        grpc_error_handle parser_error;
-        lrs_load_reporting_server = XdsBootstrap::XdsServer::Parse(
-            it->second.object_value(), &parser_error);
-        if (!GRPC_ERROR_IS_NONE(parser_error)) {
-          errors.emplace_back(
-              absl::StrCat("error parsing lrs_load_reporting_server: ",
-                           grpc_error_std_string(parser_error)));
-          GRPC_ERROR_UNREF(parser_error);
-        }
-      }
-    }
-    // Max concurrent requests.
-    uint32_t max_concurrent_requests = 1024;
-    it = json.object_value().find("maxConcurrentRequests");
-    if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::NUMBER) {
-        errors.emplace_back(
-            "field:max_concurrent_requests error:must be of type number");
-      } else {
-        max_concurrent_requests =
-            gpr_parse_nonnegative_int(it->second.string_value().c_str());
-      }
-    }
-    // Drop config.
-    auto drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
-    it = json.object_value().find("dropCategories");
-    if (it == json.object_value().end()) {
-      errors.emplace_back("field:dropCategories error:required field missing");
-    } else {
-      absl::Status status = ParseDropCategories(it->second, drop_config.get());
-      if (!status.ok()) errors.emplace_back(status.message());
-    }
-    if (!errors.empty()) {
-      return absl::InvalidArgumentError(absl::StrCat(
-          "errors parseing xds_cluster_impl_experimental LB policy config: [",
-          absl::StrJoin(errors, "; "), "]"));
-    }
-    return MakeRefCounted<XdsClusterImplLbConfig>(
-        std::move(child_policy), std::move(cluster_name),
-        std::move(eds_service_name), std::move(lrs_load_reporting_server),
-        max_concurrent_requests, std::move(drop_config));
-  }
-
- private:
-  static absl::Status ParseDropCategories(
-      const Json& json, XdsEndpointResource::DropConfig* drop_config) {
-    if (json.type() != Json::Type::ARRAY) {
-      return absl::InvalidArgumentError("dropCategories field is not an array");
-    }
-    std::vector<std::string> errors;
-    for (size_t i = 0; i < json.array_value().size(); ++i) {
-      const Json& entry = json.array_value()[i];
-      absl::Status status = ParseDropCategory(entry, drop_config);
-      if (!status.ok()) {
-        errors.emplace_back(
-            absl::StrCat("error parsing index ", i, ": ", status.message()));
-      }
-    }
-    if (!errors.empty()) {
-      return absl::InvalidArgumentError(
-          absl::StrCat("errors parsing dropCategories field: [",
-                       absl::StrJoin(errors, "; "), "]"));
-    }
-    return absl::OkStatus();
-  }
-
-  static absl::Status ParseDropCategory(
-      const Json& json, XdsEndpointResource::DropConfig* drop_config) {
-    if (json.type() != Json::Type::OBJECT) {
-      return absl::InvalidArgumentError(
-          "dropCategories entry is not an object");
-    }
-    std::vector<std::string> errors;
-    std::string category;
-    auto it = json.object_value().find("category");
-    if (it == json.object_value().end()) {
-      errors.emplace_back("\"category\" field not present");
-    } else if (it->second.type() != Json::Type::STRING) {
-      errors.emplace_back("\"category\" field is not a string");
-    } else {
-      category = it->second.string_value();
-    }
-    uint32_t requests_per_million = 0;
-    it = json.object_value().find("requests_per_million");
-    if (it == json.object_value().end()) {
-      errors.emplace_back("\"requests_per_million\" field is not present");
-    } else if (it->second.type() != Json::Type::NUMBER) {
-      errors.emplace_back("\"requests_per_million\" field is not a number");
-    } else {
-      requests_per_million =
-          gpr_parse_nonnegative_int(it->second.string_value().c_str());
-    }
-    if (!errors.empty()) {
-      return absl::InvalidArgumentError(absl::StrJoin(errors, "; "));
-    }
-    drop_config->AddCategory(std::move(category), requests_per_million);
-    return absl::OkStatus();
+    return LoadRefCountedFromJson<XdsClusterImplLbConfig>(
+        json, JsonArgs(),
+        "errors validating xds_cluster_impl LB policy config");
   }
 };
 
 }  // namespace
 
-}  // namespace grpc_core
-
-//
-// Plugin registration
-//
-
-void grpc_lb_policy_xds_cluster_impl_init() {
-  grpc_core::g_call_counter_map = new grpc_core::CircuitBreakerCallCounterMap();
-  grpc_core::LoadBalancingPolicyRegistry::Builder::
-      RegisterLoadBalancingPolicyFactory(
-          absl::make_unique<grpc_core::XdsClusterImplLbFactory>());
+void RegisterXdsClusterImplLbPolicy(CoreConfiguration::Builder* builder) {
+  builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
+      absl::make_unique<XdsClusterImplLbFactory>());
 }
 
-void grpc_lb_policy_xds_cluster_impl_shutdown() {
-  delete grpc_core::g_call_counter_map;
-}
+}  // namespace grpc_core