grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

data/src/core/ext/xds/xds_lb_policy_registry.cc

@@ -19,73 +19,102 @@
 #include "src/core/ext/xds/xds_lb_policy_registry.h"
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include <string>
 #include <utility>
-#include <vector>
 
-#include "absl/memory/memory.h"
-#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
 #include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.upb.h"
 #include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
-#include "google/protobuf/any.upb.h"
-#include "google/protobuf/struct.upb.h"
-#include "google/protobuf/struct.upbdefs.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "upb/arena.h"
-#include "upb/json_encode.h"
-#include "upb/status.h"
-#include "upb/upb.hpp"
-#include "xds/type/v3/typed_struct.upb.h"
 
-#include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
 
 namespace grpc_core {
 
 namespace {
 
+class RoundRobinLbPolicyConfigFactory
+    : public XdsLbPolicyRegistry::ConfigFactory {
+ public:
+  Json::Object ConvertXdsLbPolicyConfig(
+      const XdsLbPolicyRegistry* /*registry*/,
+      const XdsResourceType::DecodeContext& /*context*/,
+      absl::string_view /*configuration*/, ValidationErrors* /*errors*/,
+      int /*recursion_depth*/) override {
+    return Json::Object{{"round_robin", Json::Object()}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.round_robin.v3.RoundRobin";
+  }
+};
+
 class RingHashLbPolicyConfigFactory
     : public XdsLbPolicyRegistry::ConfigFactory {
  public:
-  absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
+  Json::Object ConvertXdsLbPolicyConfig(
+      const XdsLbPolicyRegistry* /*registry*/,
       const XdsResourceType::DecodeContext& context,
-      absl::string_view configuration, int /* recursion_depth */) override {
+      absl::string_view configuration, ValidationErrors* errors,
+      int /*recursion_depth*/) override {
     const auto* resource =
         envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_parse(
             configuration.data(), configuration.size(), context.arena);
     if (resource == nullptr) {
-      return absl::InvalidArgumentError(
-          "Can't decode RingHash loadbalancing policy");
+      errors->AddError("can't decode RingHash LB policy config");
+      return {};
     }
     if (envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_hash_function(
             resource) !=
-        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_XX_HASH) {
-      return absl::InvalidArgumentError(
-          "Invalid hash function provided for RingHash loadbalancing policy. "
-          "Only XX_HASH is supported.");
+            envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_XX_HASH &&
+        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_hash_function(
+            resource) !=
+            envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_DEFAULT_HASH) {
+      ValidationErrors::ScopedField field(errors, ".hash_function");
+      errors->AddError("unsupported value (must be XX_HASH)");
     }
-    Json::Object json;
-    const auto* min_ring_size =
-        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_minimum_ring_size(
+    uint64_t max_ring_size = 8388608;
+    const auto* uint64_value =
+        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_maximum_ring_size(
             resource);
-    if (min_ring_size != nullptr) {
-      json.emplace("minRingSize",
-                   google_protobuf_UInt64Value_value(min_ring_size));
+    if (uint64_value != nullptr) {
+      max_ring_size = google_protobuf_UInt64Value_value(uint64_value);
+      if (max_ring_size == 0 || max_ring_size > 8388608) {
+        ValidationErrors::ScopedField field(errors, ".maximum_ring_size");
+        errors->AddError("value must be in the range [1, 8388608]");
+      }
     }
-    const auto* max_ring_size =
-        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_maximum_ring_size(
+    uint64_t min_ring_size = 1024;
+    uint64_value =
+        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_minimum_ring_size(
             resource);
-    if (max_ring_size != nullptr) {
-      json.emplace("maxRingSize",
-                   google_protobuf_UInt64Value_value(max_ring_size));
+    if (uint64_value != nullptr) {
+      min_ring_size = google_protobuf_UInt64Value_value(uint64_value);
+      ValidationErrors::ScopedField field(errors, ".minimum_ring_size");
+      if (min_ring_size == 0 || min_ring_size > 8388608) {
+        errors->AddError("value must be in the range [1, 8388608]");
+      }
+      if (min_ring_size > max_ring_size) {
+        errors->AddError("cannot be greater than maximum_ring_size");
+      }
     }
-    return Json::Object{{"ring_hash_experimental", std::move(json)}};
+    return Json::Object{
+        {"ring_hash_experimental",
+         Json::Object{
+             {"minRingSize", min_ring_size},
+             {"maxRingSize", max_ring_size},
+         }},
+    };
   }
 
   absl::string_view type() override { return Type(); }
@@ -95,53 +124,34 @@ class RingHashLbPolicyConfigFactory
   }
 };
 
-class RoundRobinLbPolicyConfigFactory
-    : public XdsLbPolicyRegistry::ConfigFactory {
- public:
-  absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
-      const XdsResourceType::DecodeContext& /* context */,
-      absl::string_view /* configuration */,
-      int /* recursion_depth */) override {
-    return Json::Object{{"round_robin", Json::Object()}};
-  }
-
-  absl::string_view type() override { return Type(); }
-
-  static absl::string_view Type() {
-    return "envoy.extensions.load_balancing_policies.round_robin.v3.RoundRobin";
-  }
-};
-
 class WrrLocalityLbPolicyConfigFactory
     : public XdsLbPolicyRegistry::ConfigFactory {
  public:
-  absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
+  Json::Object ConvertXdsLbPolicyConfig(
+      const XdsLbPolicyRegistry* registry,
       const XdsResourceType::DecodeContext& context,
-      absl::string_view configuration, int recursion_depth) override {
+      absl::string_view configuration, ValidationErrors* errors,
+      int recursion_depth) override {
     const auto* resource =
         envoy_extensions_load_balancing_policies_wrr_locality_v3_WrrLocality_parse(
             configuration.data(), configuration.size(), context.arena);
     if (resource == nullptr) {
-      return absl::InvalidArgumentError(
-          "Can't decode WrrLocality loadbalancing policy");
+      errors->AddError("can't decode WrrLocality LB policy config");
+      return {};
     }
+    ValidationErrors::ScopedField field(errors, ".endpoint_picking_policy");
     const auto* endpoint_picking_policy =
         envoy_extensions_load_balancing_policies_wrr_locality_v3_WrrLocality_endpoint_picking_policy(
             resource);
     if (endpoint_picking_policy == nullptr) {
-      return absl::InvalidArgumentError(
-          "WrrLocality: endpoint_picking_policy not found");
-    }
-    auto child_policy = XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
-        context, endpoint_picking_policy, recursion_depth + 1);
-    if (!child_policy.ok()) {
-      return absl::InvalidArgumentError(
-          absl::StrCat("Error parsing WrrLocality load balancing policy: ",
-                       child_policy.status().message()));
+      errors->AddError("field not present");
+      return {};
     }
+    auto child_policy = registry->ConvertXdsLbPolicyConfig(
+        context, endpoint_picking_policy, errors, recursion_depth + 1);
     return Json::Object{
         {"xds_wrr_locality_experimental",
-         Json::Object{{"child_policy", *std::move(child_policy)}}}};
+         Json::Object{{"childPolicy", std::move(child_policy)}}}};
   }
 
   absl::string_view type() override { return Type(); }
@@ -152,139 +162,82 @@ class WrrLocalityLbPolicyConfigFactory
   }
 };
 
-absl::StatusOr<Json> ParseStructToJson(
-    const XdsResourceType::DecodeContext& context,
-    const google_protobuf_Struct* resource) {
-  upb::Status status;
-  const auto* msg_def = google_protobuf_Struct_getmsgdef(context.symtab);
-  size_t json_size = upb_JsonEncode(resource, msg_def, context.symtab, 0,
-                                    nullptr, 0, status.ptr());
-  if (json_size == static_cast<size_t>(-1)) {
-    return absl::InvalidArgumentError(
-        absl::StrCat("Error parsing google::Protobuf::Struct: ",
-                     upb_Status_ErrorMessage(status.ptr())));
-  }
-  void* buf = upb_Arena_Malloc(context.arena, json_size + 1);
-  upb_JsonEncode(resource, msg_def, context.symtab, 0,
-                 reinterpret_cast<char*>(buf), json_size + 1, status.ptr());
-  auto json = Json::Parse(reinterpret_cast<char*>(buf));
-  if (!json.ok()) {
-    // This should not happen
-    return absl::InternalError(
-        absl::StrCat("Error parsing JSON form of google::Protobuf::Struct "
-                     "produced by upb library: ",
-                     json.status().ToString()));
-  }
-  return std::move(*json);
-}
-
 }  // namespace
 
 //
 // XdsLbPolicyRegistry
 //
 
-absl::StatusOr<Json::Array> XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
+XdsLbPolicyRegistry::XdsLbPolicyRegistry() {
+  policy_config_factories_.emplace(
+      RingHashLbPolicyConfigFactory::Type(),
+      std::make_unique<RingHashLbPolicyConfigFactory>());
+  policy_config_factories_.emplace(
+      RoundRobinLbPolicyConfigFactory::Type(),
+      std::make_unique<RoundRobinLbPolicyConfigFactory>());
+  policy_config_factories_.emplace(
+      WrrLocalityLbPolicyConfigFactory::Type(),
+      std::make_unique<WrrLocalityLbPolicyConfigFactory>());
+}
+
+Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_cluster_v3_LoadBalancingPolicy* lb_policy,
-    int recursion_depth) {
+    ValidationErrors* errors, int recursion_depth) const {
   constexpr int kMaxRecursionDepth = 16;
   if (recursion_depth >= kMaxRecursionDepth) {
-    return absl::InvalidArgumentError(
-        absl::StrFormat("LoadBalancingPolicy configuration has a recursion "
-                        "depth of more than %d.",
-                        kMaxRecursionDepth));
+    errors->AddError(
+        absl::StrCat("exceeded max recursion depth of ", kMaxRecursionDepth));
+    return {};
   }
+  const size_t original_error_size = errors->size();
   size_t size = 0;
   const auto* policies =
       envoy_config_cluster_v3_LoadBalancingPolicy_policies(lb_policy, &size);
   for (size_t i = 0; i < size; ++i) {
-    absl::StatusOr<Json::Object> policy;
+    ValidationErrors::ScopedField field(
+        errors, absl::StrCat(".policies[", i, "].typed_extension_config"));
     const auto* typed_extension_config =
         envoy_config_cluster_v3_LoadBalancingPolicy_Policy_typed_extension_config(
             policies[i]);
     if (typed_extension_config == nullptr) {
-      return absl::InvalidArgumentError(
-          "Error parsing LoadBalancingPolicy::Policy - Missing "
-          "typed_extension_config field");
+      errors->AddError("field not present");
+      return {};
     }
+    ValidationErrors::ScopedField field2(errors, ".typed_config");
     const auto* typed_config =
         envoy_config_core_v3_TypedExtensionConfig_typed_config(
             typed_extension_config);
     if (typed_config == nullptr) {
-      return absl::InvalidArgumentError(
-          "Error parsing LoadBalancingPolicy::Policy - Missing "
-          "TypedExtensionConfig::typed_config field");
+      errors->AddError("field not present");
+      return {};
     }
-    auto type = ExtractExtensionTypeName(context, typed_config);
-    if (!type.ok()) {
-      return absl::InvalidArgumentError(absl::StrCat(
-          "Error parsing "
-          "LoadBalancingPolicy::Policy::TypedExtensionConfig::typed_config: ",
-          type.status().message()));
-    }
-    absl::string_view value =
-        UpbStringToAbsl(google_protobuf_Any_value(typed_config));
-    auto config_factory_it = Get()->policy_config_factories_.find(type->type);
-    if (config_factory_it != Get()->policy_config_factories_.end()) {
-      policy = config_factory_it->second->ConvertXdsLbPolicyConfig(
-          context, value, recursion_depth);
-      if (!policy.ok()) {
-        return absl::InvalidArgumentError(
-            absl::StrCat("Error parsing "
-                         "LoadBalancingPolicy::Policy::TypedExtensionConfig::"
-                         "typed_config to JSON: ",
-                         policy.status().message()));
-      }
-    } else if (type->typed_struct != nullptr) {
-      // Custom lb policy config
-      std::string custom_type = std::string(type->type);
-      if (!CoreConfiguration::Get()
-               .lb_policy_registry()
-               .LoadBalancingPolicyExists(custom_type.c_str(), nullptr)) {
-        // Skip unsupported custom lb policy.
-        continue;
+    auto extension = ExtractXdsExtension(context, typed_config, errors);
+    if (!extension.has_value()) return {};
+    // Check for registered LB policy type.
+    absl::string_view* serialized_value =
+        absl::get_if<absl::string_view>(&extension->value);
+    if (serialized_value != nullptr) {
+      auto config_factory_it = policy_config_factories_.find(extension->type);
+      if (config_factory_it != policy_config_factories_.end()) {
+        return Json::Array{config_factory_it->second->ConvertXdsLbPolicyConfig(
+            this, context, *serialized_value, errors, recursion_depth)};
       }
-      // Convert typed struct to json.
-      auto value = xds_type_v3_TypedStruct_value(type->typed_struct);
-      if (value == nullptr) {
-        policy = Json::Object{{std::move(custom_type), Json() /* null */}};
-      } else {
-        auto parsed_value = ParseStructToJson(context, value);
-        if (!parsed_value.ok()) {
-          return absl::InvalidArgumentError(absl::StrCat(
-              "Error parsing LoadBalancingPolicy: Custom Policy: ", custom_type,
-              ": ", parsed_value.status().message()));
-        }
-        policy =
-            Json::Object{{std::move(custom_type), *(std::move(parsed_value))}};
-      }
-    } else {
-      // Unsupported type. Skipping entry.
-      continue;
     }
-    return Json::Array{std::move(policy.value())};
+    // Check for custom LB policy type.
+    Json* json = absl::get_if<Json>(&extension->value);
+    if (json != nullptr &&
+        CoreConfiguration::Get().lb_policy_registry().LoadBalancingPolicyExists(
+            extension->type, nullptr)) {
+      return Json::Array{
+          Json::Object{{std::string(extension->type), std::move(*json)}}};
+    }
+    // Unsupported type.  Continue to next entry.
   }
-  return absl::InvalidArgumentError(
-      "No supported load balancing policy config found.");
-}
-
-XdsLbPolicyRegistry::XdsLbPolicyRegistry() {
-  policy_config_factories_.emplace(
-      RingHashLbPolicyConfigFactory::Type(),
-      absl::make_unique<RingHashLbPolicyConfigFactory>());
-  policy_config_factories_.emplace(
-      RoundRobinLbPolicyConfigFactory::Type(),
-      absl::make_unique<RoundRobinLbPolicyConfigFactory>());
-  policy_config_factories_.emplace(
-      WrrLocalityLbPolicyConfigFactory::Type(),
-      absl::make_unique<WrrLocalityLbPolicyConfigFactory>());
-}
-
-XdsLbPolicyRegistry* XdsLbPolicyRegistry::Get() {
-  // This is thread-safe since C++11
-  static XdsLbPolicyRegistry* instance = new XdsLbPolicyRegistry();
-  return instance;
+  if (original_error_size == errors->size()) {
+    errors->AddError("no supported load balancing policy config found");
+  }
+  return {};
 }
 
 }  // namespace grpc_core

data/src/core/ext/xds/xds_lb_policy_registry.h

@@ -22,11 +22,11 @@
 #include <map>
 #include <memory>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "envoy/config/cluster/v3/cluster.upb.h"
 
 #include "src/core/ext/xds/xds_resource_type.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -37,29 +37,28 @@ class XdsLbPolicyRegistry {
  public:
   class ConfigFactory {
    public:
-    virtual ~ConfigFactory() {}
-    virtual absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
+    virtual ~ConfigFactory() = default;
+    virtual Json::Object ConvertXdsLbPolicyConfig(
+        const XdsLbPolicyRegistry* registry,
         const XdsResourceType::DecodeContext& context,
-        absl::string_view configuration, int recursion_depth) = 0;
-
+        absl::string_view configuration, ValidationErrors* errors,
+        int recursion_depth) = 0;
     virtual absl::string_view type() = 0;
   };
 
+  XdsLbPolicyRegistry();
+
   // Converts an xDS cluster load balancing policy message to gRPC's JSON
   // format. An error is returned if none of the lb policies in the list are
   // supported, or if a supported lb policy configuration conversion fails. \a
   // recursion_depth indicates the current depth of the tree if lb_policy
   // configuration recursively holds other lb policies.
-  static absl::StatusOr<Json::Array> ConvertXdsLbPolicyConfig(
+  Json::Array ConvertXdsLbPolicyConfig(
       const XdsResourceType::DecodeContext& context,
       const envoy_config_cluster_v3_LoadBalancingPolicy* lb_policy,
-      int recursion_depth = 0);
+      ValidationErrors* errors, int recursion_depth = 0) const;
 
  private:
-  XdsLbPolicyRegistry();
-
-  static XdsLbPolicyRegistry* Get();
-
   // A map of config factories that goes from the type of the lb policy config
   // to the config factory.
   std::map<absl::string_view /* Owned by ConfigFactory */,