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

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

@@ -18,7 +18,20 @@
 
 #include "src/core/ext/xds/xds_http_rbac_filter.h"
 
-#include "absl/strings/str_format.h"
+#include <stddef.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/rbac/v3/rbac.upb.h"
 #include "envoy/config/route/v3/route_components.upb.h"
@@ -35,6 +48,7 @@
 #include "src/core/ext/filters/rbac/rbac_service_config_parser.h"
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/json/json.h"
 
 namespace grpc_core {
 
@@ -61,15 +75,13 @@ Json ParseInt64RangeToJson(const envoy_type_v3_Int64Range* range) {
 absl::StatusOr<Json> ParseHeaderMatcherToJson(
     const envoy_config_route_v3_HeaderMatcher* header) {
   Json::Object header_json;
-  std::vector<absl::Status> error_list;
+  std::vector<std::string> errors;
   std::string name =
       UpbStringToStdString(envoy_config_route_v3_HeaderMatcher_name(header));
   if (name == ":scheme") {
-    error_list.push_back(
-        absl::InvalidArgumentError("':scheme' not allowed in header"));
+    errors.emplace_back("':scheme' not allowed in header");
   } else if (absl::StartsWith(name, "grpc-")) {
-    error_list.push_back(
-        absl::InvalidArgumentError("'grpc-' prefixes not allowed in header"));
+    errors.emplace_back("'grpc-' prefixes not allowed in header");
   }
   header_json.emplace("name", std::move(name));
   if (envoy_config_route_v3_HeaderMatcher_has_exact_match(header)) {
@@ -107,13 +119,11 @@ absl::StatusOr<Json> ParseHeaderMatcherToJson(
         UpbStringToStdString(
             envoy_config_route_v3_HeaderMatcher_contains_match(header)));
   } else {
-    error_list.push_back(
-        absl::InvalidArgumentError("Invalid route header matcher specified."));
+    errors.emplace_back("Invalid route header matcher specified.");
   }
-  if (!error_list.empty()) {
-    return StatusCreate(absl::StatusCode::kInvalidArgument,
-                        "Error parsing HeaderMatcher", DEBUG_LOCATION,
-                        std::move(error_list));
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing HeaderMatcher: [", absl::StrJoin(errors, "; "), "]"));
   }
   header_json.emplace("invertMatch",
                       envoy_config_route_v3_HeaderMatcher_invert_match(header));
@@ -201,7 +211,7 @@ absl::StatusOr<Json> ParsePermissionToJson(
   auto parse_permission_set_to_json =
       [](const envoy_config_rbac_v3_Permission_Set* set)
       -> absl::StatusOr<Json> {
-    std::vector<absl::Status> error_list;
+    std::vector<std::string> errors;
     Json::Array rules_json;
     size_t size;
     const envoy_config_rbac_v3_Permission* const* rules =
@@ -209,15 +219,14 @@ absl::StatusOr<Json> ParsePermissionToJson(
     for (size_t i = 0; i < size; ++i) {
       auto permission_json = ParsePermissionToJson(rules[i]);
       if (!permission_json.ok()) {
-        error_list.push_back(permission_json.status());
+        errors.emplace_back(permission_json.status().message());
       } else {
         rules_json.emplace_back(std::move(*permission_json));
       }
     }
-    if (!error_list.empty()) {
-      return StatusCreate(absl::StatusCode::kInvalidArgument,
-                          "Error parsing Set", DEBUG_LOCATION,
-                          std::move(error_list));
+    if (!errors.empty()) {
+      return absl::InvalidArgumentError(absl::StrCat(
+          "errors parsing Set: [", absl::StrJoin(errors, "; "), "]"));
     }
     return Json::Object({{"rules", std::move(rules_json)}});
   };
@@ -297,7 +306,7 @@ absl::StatusOr<Json> ParsePrincipalToJson(
       [](const envoy_config_rbac_v3_Principal_Set* set)
       -> absl::StatusOr<Json> {
     Json::Object json;
-    std::vector<absl::Status> error_list;
+    std::vector<std::string> errors;
     Json::Array ids_json;
     size_t size;
     const envoy_config_rbac_v3_Principal* const* ids =
@@ -305,15 +314,14 @@ absl::StatusOr<Json> ParsePrincipalToJson(
     for (size_t i = 0; i < size; ++i) {
       auto principal_json = ParsePrincipalToJson(ids[i]);
       if (!principal_json.ok()) {
-        error_list.push_back(principal_json.status());
+        errors.emplace_back(principal_json.status().message());
       } else {
         ids_json.emplace_back(std::move(*principal_json));
       }
     }
-    if (!error_list.empty()) {
-      return StatusCreate(absl::StatusCode::kInvalidArgument,
-                          "Error parsing Set", DEBUG_LOCATION,
-                          std::move(error_list));
+    if (!errors.empty()) {
+      return absl::InvalidArgumentError(absl::StrCat(
+          "errors parsing Set: [", absl::StrJoin(errors, "; "), "]"));
     }
     return Json::Object({{"ids", std::move(ids_json)}});
   };
@@ -396,7 +404,7 @@ absl::StatusOr<Json> ParsePrincipalToJson(
 absl::StatusOr<Json> ParsePolicyToJson(
     const envoy_config_rbac_v3_Policy* policy) {
   Json::Object policy_json;
-  std::vector<absl::Status> error_list;
+  std::vector<std::string> errors;
   size_t size;
   Json::Array permissions_json;
   const envoy_config_rbac_v3_Permission* const* permissions =
@@ -404,7 +412,7 @@ absl::StatusOr<Json> ParsePolicyToJson(
   for (size_t i = 0; i < size; ++i) {
     auto permission_json = ParsePermissionToJson(permissions[i]);
     if (!permission_json.ok()) {
-      error_list.push_back(permission_json.status());
+      errors.emplace_back(permission_json.status().message());
     } else {
       permissions_json.emplace_back(std::move(*permission_json));
     }
@@ -416,24 +424,21 @@ absl::StatusOr<Json> ParsePolicyToJson(
   for (size_t i = 0; i < size; ++i) {
     auto principal_json = ParsePrincipalToJson(principals[i]);
     if (!principal_json.ok()) {
-      error_list.push_back(principal_json.status());
+      errors.emplace_back(principal_json.status().message());
     } else {
       principals_json.emplace_back(std::move(*principal_json));
     }
   }
   policy_json.emplace("principals", std::move(principals_json));
   if (envoy_config_rbac_v3_Policy_has_condition(policy)) {
-    error_list.push_back(
-        absl::InvalidArgumentError("Policy: condition not supported"));
+    errors.emplace_back("Policy: condition not supported");
   }
   if (envoy_config_rbac_v3_Policy_has_checked_condition(policy)) {
-    error_list.push_back(
-        absl::InvalidArgumentError("Policy: checked condition not supported"));
+    errors.emplace_back("Policy: checked condition not supported");
   }
-  if (!error_list.empty()) {
-    return StatusCreate(absl::StatusCode::kInvalidArgument,
-                        "Error parsing Policy", DEBUG_LOCATION,
-                        std::move(error_list));
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing Policy: [", absl::StrJoin(errors, "; "), "]"));
   }
   return policy_json;
 }
@@ -441,7 +446,7 @@ absl::StatusOr<Json> ParsePolicyToJson(
 absl::StatusOr<Json> ParseHttpRbacToJson(
     const envoy_extensions_filters_http_rbac_v3_RBAC* rbac) {
   Json::Object rbac_json;
-  std::vector<absl::Status> error_list;
+  std::vector<std::string> errors;
   const auto* rules = envoy_extensions_filters_http_rbac_v3_RBAC_rules(rbac);
   if (rules != nullptr) {
     int action = envoy_config_rbac_v3_RBAC_action(rules);
@@ -462,13 +467,11 @@ absl::StatusOr<Json> ParseHttpRbacToJson(
         auto policy = ParsePolicyToJson(
             envoy_config_rbac_v3_RBAC_PoliciesEntry_value(entry));
         if (!policy.ok()) {
-          error_list.push_back(StatusCreate(
-              absl::StatusCode::kInvalidArgument,
-              absl::StrFormat(
-                  "RBAC PoliciesEntry key:%s",
-                  UpbStringToStdString(
-                      envoy_config_rbac_v3_RBAC_PoliciesEntry_key(entry))),
-              DEBUG_LOCATION, {policy.status()}));
+          errors.emplace_back(absl::StrCat(
+              "RBAC PoliciesEntry key:",
+              UpbStringToStdString(
+                  envoy_config_rbac_v3_RBAC_PoliciesEntry_key(entry)),
+              " error:", policy.status().message()));
         } else {
           policies_object.emplace(
               UpbStringToStdString(
@@ -480,10 +483,9 @@ absl::StatusOr<Json> ParseHttpRbacToJson(
     }
     rbac_json.emplace("rules", std::move(inner_rbac_json));
   }
-  if (!error_list.empty()) {
-    return StatusCreate(absl::StatusCode::kInvalidArgument,
-                        "Error parsing RBAC", DEBUG_LOCATION,
-                        std::move(error_list));
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing RBAC: [", absl::StrJoin(errors, "; "), "]"));
   }
   return rbac_json;
 }
@@ -539,14 +541,9 @@ const grpc_channel_filter* XdsHttpRbacFilter::channel_filter() const {
   return &RbacFilter::kFilterVtable;
 }
 
-grpc_channel_args* XdsHttpRbacFilter::ModifyChannelArgs(
-    grpc_channel_args* args) const {
-  grpc_arg arg_to_add = grpc_channel_arg_integer_create(
-      const_cast<char*>(GRPC_ARG_PARSE_RBAC_METHOD_CONFIG), 1);
-  grpc_channel_args* new_args =
-      grpc_channel_args_copy_and_add(args, &arg_to_add, 1);
-  grpc_channel_args_destroy(args);
-  return new_args;
+ChannelArgs XdsHttpRbacFilter::ModifyChannelArgs(
+    const ChannelArgs& args) const {
+  return args.Set(GRPC_ARG_PARSE_RBAC_METHOD_CONFIG, 1);
 }
 
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>

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

@@ -19,7 +19,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/statusor.h"
+#include "upb/arena.h"
+#include "upb/def.h"
+#include "upb/upb.h"
+
 #include "src/core/ext/xds/xds_http_filters.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 
 namespace grpc_core {
 
@@ -38,7 +45,7 @@ class XdsHttpRbacFilter : public XdsHttpFilterImpl {
 
   const grpc_channel_filter* channel_filter() const override;
 
-  grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) const override;
+  ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
 
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& hcm_filter_config,

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

@@ -0,0 +1,288 @@
+//
+// 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_lb_policy_registry.h"
+
+#include <stddef.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 "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/load_balancing/lb_policy_registry.h"
+
+namespace grpc_core {
+
+namespace {
+
+class RingHashLbPolicyConfigFactory
+    : public XdsLbPolicyRegistry::ConfigFactory {
+ public:
+  absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
+      const XdsResourceType::DecodeContext& context,
+      absl::string_view configuration, 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");
+    }
+    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.");
+    }
+    Json::Object json;
+    const auto* min_ring_size =
+        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_minimum_ring_size(
+            resource);
+    if (min_ring_size != nullptr) {
+      json.emplace("minRingSize",
+                   google_protobuf_UInt64Value_value(min_ring_size));
+    }
+    const auto* max_ring_size =
+        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_maximum_ring_size(
+            resource);
+    if (max_ring_size != nullptr) {
+      json.emplace("maxRingSize",
+                   google_protobuf_UInt64Value_value(max_ring_size));
+    }
+    return Json::Object{{"ring_hash_experimental", std::move(json)}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.ring_hash.v3.RingHash";
+  }
+};
+
+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(
+      const XdsResourceType::DecodeContext& context,
+      absl::string_view configuration, 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");
+    }
+    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()));
+    }
+    return Json::Object{
+        {"xds_wrr_locality_experimental",
+         Json::Object{{"child_policy", *std::move(child_policy)}}}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.wrr_locality.v3."
+           "WrrLocality";
+  }
+};
+
+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(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_cluster_v3_LoadBalancingPolicy* lb_policy,
+    int recursion_depth) {
+  constexpr int kMaxRecursionDepth = 16;
+  if (recursion_depth >= kMaxRecursionDepth) {
+    return absl::InvalidArgumentError(
+        absl::StrFormat("LoadBalancingPolicy configuration has a recursion "
+                        "depth of more than %d.",
+                        kMaxRecursionDepth));
+  }
+  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;
+    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");
+    }
+    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 (!LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
+              custom_type.c_str(), nullptr)) {
+        // Skip unsupported custom lb policy.
+        continue;
+      }
+      // 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())};
+  }
+  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;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,72 @@
+//
+// 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_LB_POLICY_REGISTRY_H
+#define GRPC_CORE_EXT_XDS_XDS_LB_POLICY_REGISTRY_H
+
+#include <grpc/support/port_platform.h>
+
+#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/json/json.h"
+
+namespace grpc_core {
+
+// A registry that maintans a set of converters that are able to map xDS
+// loadbalancing policy configurations to gRPC's JSON format.
+class XdsLbPolicyRegistry {
+ public:
+  class ConfigFactory {
+   public:
+    virtual ~ConfigFactory() {}
+    virtual absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
+        const XdsResourceType::DecodeContext& context,
+        absl::string_view configuration, int recursion_depth) = 0;
+
+    virtual absl::string_view type() = 0;
+  };
+
+  // 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(
+      const XdsResourceType::DecodeContext& context,
+      const envoy_config_cluster_v3_LoadBalancingPolicy* lb_policy,
+      int recursion_depth = 0);
+
+ 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 */,
+           std::unique_ptr<ConfigFactory>>
+      policy_config_factories_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_LB_POLICY_REGISTRY_H