grpc 1.50.0.pre1 → 1.52.0.pre2

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

@@ -0,0 +1,218 @@
+//
+// Copyright 2022 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/xds/xds_http_stateful_session_filter.h"
+
+#include <string>
+#include <utility>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
+#include "envoy/config/core/v3/extension.upb.h"
+#include "envoy/extensions/filters/http/stateful_session/v3/stateful_session.upb.h"
+#include "envoy/extensions/filters/http/stateful_session/v3/stateful_session.upbdefs.h"
+#include "envoy/extensions/http/stateful_session/cookie/v3/cookie.upb.h"
+#include "envoy/extensions/http/stateful_session/cookie/v3/cookie.upbdefs.h"
+#include "envoy/type/http/v3/cookie.upb.h"
+#include "upb/def.h"
+
+#include "src/core/ext/filters/stateful_session/stateful_session_filter.h"
+#include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
+#include "src/core/ext/xds/upb_utils.h"
+#include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/ext/xds/xds_http_filters.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/json/json.h"
+
+namespace grpc_core {
+
+absl::string_view XdsHttpStatefulSessionFilter::ConfigProtoName() const {
+  return "envoy.extensions.filters.http.stateful_session.v3.StatefulSession";
+}
+
+absl::string_view XdsHttpStatefulSessionFilter::OverrideConfigProtoName()
+    const {
+  return "envoy.extensions.filters.http.stateful_session.v3"
+         ".StatefulSessionPerRoute";
+}
+
+void XdsHttpStatefulSessionFilter::PopulateSymtab(upb_DefPool* symtab) const {
+  envoy_extensions_filters_http_stateful_session_v3_StatefulSession_getmsgdef(
+      symtab);
+  envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_getmsgdef(
+      symtab);
+  envoy_extensions_http_stateful_session_cookie_v3_CookieBasedSessionState_getmsgdef(
+      symtab);
+}
+
+namespace {
+
+Json::Object ValidateStatefulSession(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_extensions_filters_http_stateful_session_v3_StatefulSession*
+        stateful_session,
+    ValidationErrors* errors) {
+  ValidationErrors::ScopedField field(errors, ".session_state");
+  const auto* session_state =
+      envoy_extensions_filters_http_stateful_session_v3_StatefulSession_session_state(
+          stateful_session);
+  if (session_state == nullptr) {
+    errors->AddError("field not present");
+    return {};
+  }
+  ValidationErrors::ScopedField field2(errors, ".typed_config");
+  const auto* typed_config =
+      envoy_config_core_v3_TypedExtensionConfig_typed_config(session_state);
+  auto extension = ExtractXdsExtension(context, typed_config, errors);
+  if (!extension.has_value()) return {};
+  if (extension->type !=
+      "envoy.extensions.http.stateful_session.cookie.v3"
+      ".CookieBasedSessionState") {
+    errors->AddError("unsupported session state type");
+    return {};
+  }
+  absl::string_view* serialized_session_state =
+      absl::get_if<absl::string_view>(&extension->value);
+  if (serialized_session_state == nullptr) {
+    errors->AddError("could not parse session state config");
+    return {};
+  }
+  auto* cookie_state =
+      envoy_extensions_http_stateful_session_cookie_v3_CookieBasedSessionState_parse(
+          serialized_session_state->data(), serialized_session_state->size(),
+          context.arena);
+  if (cookie_state == nullptr) {
+    errors->AddError("could not parse session state config");
+    return {};
+  }
+  ValidationErrors::ScopedField field3(errors, ".cookie");
+  const auto* cookie =
+      envoy_extensions_http_stateful_session_cookie_v3_CookieBasedSessionState_cookie(
+          cookie_state);
+  if (cookie == nullptr) {
+    errors->AddError("field not present");
+    return {};
+  }
+  Json::Object cookie_config;
+  // name
+  std::string cookie_name =
+      UpbStringToStdString(envoy_type_http_v3_Cookie_name(cookie));
+  if (cookie_name.empty()) {
+    ValidationErrors::ScopedField field(errors, ".name");
+    errors->AddError("field not present");
+  }
+  cookie_config["name"] = std::move(cookie_name);
+  // ttl
+  {
+    ValidationErrors::ScopedField field(errors, ".ttl");
+    const auto* duration = envoy_type_http_v3_Cookie_ttl(cookie);
+    if (duration != nullptr) {
+      Duration ttl = ParseDuration(duration, errors);
+      cookie_config["ttl"] = ttl.ToJsonString();
+    }
+  }
+  // path
+  std::string path =
+      UpbStringToStdString(envoy_type_http_v3_Cookie_path(cookie));
+  if (!path.empty()) cookie_config["path"] = std::move(path);
+  return cookie_config;
+}
+
+}  // namespace
+
+absl::optional<XdsHttpFilterImpl::FilterConfig>
+XdsHttpStatefulSessionFilter::GenerateFilterConfig(
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) const {
+  absl::string_view* serialized_filter_config =
+      absl::get_if<absl::string_view>(&extension.value);
+  if (serialized_filter_config == nullptr) {
+    errors->AddError("could not parse stateful session filter config");
+    return absl::nullopt;
+  }
+  auto* stateful_session =
+      envoy_extensions_filters_http_stateful_session_v3_StatefulSession_parse(
+          serialized_filter_config->data(), serialized_filter_config->size(),
+          context.arena);
+  if (stateful_session == nullptr) {
+    errors->AddError("could not parse stateful session filter config");
+    return absl::nullopt;
+  }
+  return FilterConfig{
+      ConfigProtoName(),
+      ValidateStatefulSession(context, stateful_session, errors)};
+}
+
+absl::optional<XdsHttpFilterImpl::FilterConfig>
+XdsHttpStatefulSessionFilter::GenerateFilterConfigOverride(
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) const {
+  absl::string_view* serialized_filter_config =
+      absl::get_if<absl::string_view>(&extension.value);
+  if (serialized_filter_config == nullptr) {
+    errors->AddError("could not parse stateful session filter override config");
+    return absl::nullopt;
+  }
+  auto* stateful_session_per_route =
+      envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_parse(
+          serialized_filter_config->data(), serialized_filter_config->size(),
+          context.arena);
+  if (stateful_session_per_route == nullptr) {
+    errors->AddError("could not parse stateful session filter override config");
+    return absl::nullopt;
+  }
+  Json::Object config;
+  if (!envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_disabled(
+          stateful_session_per_route)) {
+    ValidationErrors::ScopedField field(errors, ".stateful_session");
+    const auto* stateful_session =
+        envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_stateful_session(
+            stateful_session_per_route);
+    if (stateful_session == nullptr) {
+      errors->AddError("field not present");
+    } else {
+      config = ValidateStatefulSession(context, stateful_session, errors);
+    }
+  }
+  return FilterConfig{OverrideConfigProtoName(), Json(std::move(config))};
+}
+
+const grpc_channel_filter* XdsHttpStatefulSessionFilter::channel_filter()
+    const {
+  return &StatefulSessionFilter::kFilter;
+}
+
+ChannelArgs XdsHttpStatefulSessionFilter::ModifyChannelArgs(
+    const ChannelArgs& args) const {
+  return args.Set(GRPC_ARG_PARSE_STATEFUL_SESSION_METHOD_CONFIG, 1);
+}
+
+absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
+XdsHttpStatefulSessionFilter::GenerateServiceConfig(
+    const FilterConfig& hcm_filter_config,
+    const FilterConfig* filter_config_override) const {
+  Json config = filter_config_override != nullptr
+                    ? filter_config_override->config
+                    : hcm_filter_config.config;
+  return ServiceConfigJsonEntry{"stateful_session", config.Dump()};
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,58 @@
+//
+// Copyright 2022 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_XDS_XDS_HTTP_STATEFUL_SESSION_FILTER_H
+#define GRPC_CORE_EXT_XDS_XDS_HTTP_STATEFUL_SESSION_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "upb/def.h"
+
+#include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/ext/xds/xds_http_filters.h"
+#include "src/core/ext/xds/xds_resource_type.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+
+namespace grpc_core {
+
+class XdsHttpStatefulSessionFilter : public XdsHttpFilterImpl {
+ public:
+  absl::string_view ConfigProtoName() const override;
+  absl::string_view OverrideConfigProtoName() const override;
+  void PopulateSymtab(upb_DefPool* symtab) const override;
+  absl::optional<FilterConfig> GenerateFilterConfig(
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
+      ValidationErrors* errors) const override;
+  absl::optional<FilterConfig> GenerateFilterConfigOverride(
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
+      ValidationErrors* errors) const override;
+  const grpc_channel_filter* channel_filter() const override;
+  ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
+  absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+      const FilterConfig& hcm_filter_config,
+      const FilterConfig* filter_config_override) const override;
+  bool IsSupportedOnClients() const override { return true; }
+  bool IsSupportedOnServers() const override { return false; }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_HTTP_STATEFUL_SESSION_FILTER_H

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,78 @@ 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");
-    }
-    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