grpc 1.48.0 → 1.50.0

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

@@ -24,13 +24,13 @@
 #include <cstdint>
 #include <map>
 #include <string>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
 #include "absl/status/status.h"
 #include "absl/strings/match.h"
-#include "absl/strings/str_format.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"
@@ -48,8 +48,6 @@
 #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/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -77,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)) {
@@ -123,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));
@@ -217,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 =
@@ -225,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)}});
   };
@@ -313,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 =
@@ -321,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)}});
   };
@@ -412,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 =
@@ -420,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));
     }
@@ -432,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;
 }
@@ -457,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);
@@ -478,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(
@@ -496,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;
 }
@@ -555,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

@@ -20,12 +20,12 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/status/statusor.h"
+#include "upb/arena.h"
 #include "upb/def.h"
 #include "upb/upb.h"
 
-#include <grpc/impl/codegen/grpc_types.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 {
@@ -45,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

@@ -21,7 +21,6 @@
 #include <stddef.h>
 
 #include <string>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -36,15 +35,16 @@
 #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/upb.h"
+#include "upb/status.h"
 #include "upb/upb.hpp"
 #include "xds/type/v3/typed_struct.upb.h"
 
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_common_types.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
 
 namespace grpc_core {
 
@@ -54,8 +54,8 @@ class RingHashLbPolicyConfigFactory
     : public XdsLbPolicyRegistry::ConfigFactory {
  public:
   absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
-      const XdsEncodingContext& context, absl::string_view configuration,
-      int /* recursion_depth */) override {
+      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);
@@ -99,7 +99,7 @@ class RoundRobinLbPolicyConfigFactory
     : public XdsLbPolicyRegistry::ConfigFactory {
  public:
   absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
-      const XdsEncodingContext& /* context */,
+      const XdsResourceType::DecodeContext& /* context */,
       absl::string_view /* configuration */,
       int /* recursion_depth */) override {
     return Json::Object{{"round_robin", Json::Object()}};
@@ -116,8 +116,8 @@ class WrrLocalityLbPolicyConfigFactory
     : public XdsLbPolicyRegistry::ConfigFactory {
  public:
   absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
-      const XdsEncodingContext& context, absl::string_view configuration,
-      int recursion_depth) override {
+      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);
@@ -152,8 +152,9 @@ class WrrLocalityLbPolicyConfigFactory
   }
 };
 
-absl::StatusOr<Json> ParseStructToJson(const XdsEncodingContext& context,
-                                       const google_protobuf_Struct* resource) {
+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,
@@ -166,18 +167,15 @@ absl::StatusOr<Json> ParseStructToJson(const XdsEncodingContext& context,
   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());
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  auto json = Json::Parse(reinterpret_cast<char*>(buf), &error);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  auto json = Json::Parse(reinterpret_cast<char*>(buf));
+  if (!json.ok()) {
     // This should not happen
-    auto ret_status = absl::InternalError(
+    return absl::InternalError(
         absl::StrCat("Error parsing JSON form of google::Protobuf::Struct "
                      "produced by upb library: ",
-                     grpc_error_std_string(error)));
-    GRPC_ERROR_UNREF(error);
-    return ret_status;
+                     json.status().ToString()));
   }
-  return json;
+  return std::move(*json);
 }
 
 }  // namespace
@@ -187,7 +185,7 @@ absl::StatusOr<Json> ParseStructToJson(const XdsEncodingContext& context,
 //
 
 absl::StatusOr<Json::Array> XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
-    const XdsEncodingContext& context,
+    const XdsResourceType::DecodeContext& context,
     const envoy_config_cluster_v3_LoadBalancingPolicy* lb_policy,
     int recursion_depth) {
   constexpr int kMaxRecursionDepth = 16;
@@ -241,8 +239,9 @@ absl::StatusOr<Json::Array> XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
     } 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)) {
+      if (!CoreConfiguration::Get()
+               .lb_policy_registry()
+               .LoadBalancingPolicyExists(custom_type.c_str(), nullptr)) {
         // Skip unsupported custom lb policy.
         continue;
       }

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

@@ -26,7 +26,7 @@
 #include "absl/strings/string_view.h"
 #include "envoy/config/cluster/v3/cluster.upb.h"
 
-#include "src/core/ext/xds/upb_utils.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -39,8 +39,8 @@ class XdsLbPolicyRegistry {
    public:
     virtual ~ConfigFactory() {}
     virtual absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
-        const XdsEncodingContext& context, absl::string_view configuration,
-        int recursion_depth) = 0;
+        const XdsResourceType::DecodeContext& context,
+        absl::string_view configuration, int recursion_depth) = 0;
 
     virtual absl::string_view type() = 0;
   };
@@ -51,7 +51,7 @@ class XdsLbPolicyRegistry {
   // 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 XdsEncodingContext& context,
+      const XdsResourceType::DecodeContext& context,
       const envoy_config_cluster_v3_LoadBalancingPolicy* lb_policy,
       int recursion_depth = 0);