grpc 1.48.0 → 1.50.0

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

@@ -21,13 +21,14 @@
 #include <stdlib.h>
 
 #include <algorithm>
-#include <type_traits>
 #include <vector>
 
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
+#include "absl/types/optional.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/core/v3/health_check.upb.h"
@@ -43,9 +44,8 @@
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
 
@@ -126,7 +126,7 @@ std::string XdsEndpointResource::ToString() const {
 namespace {
 
 void MaybeLogClusterLoadAssignment(
-    const XdsEncodingContext& context,
+    const XdsResourceType::DecodeContext& context,
     const envoy_config_endpoint_v3_ClusterLoadAssignment* cla) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
@@ -140,15 +140,14 @@ void MaybeLogClusterLoadAssignment(
   }
 }
 
-grpc_error_handle ServerAddressParseAndAppend(
-    const envoy_config_endpoint_v3_LbEndpoint* lb_endpoint,
-    ServerAddressList* list) {
+absl::StatusOr<absl::optional<ServerAddress>> ServerAddressParse(
+    const envoy_config_endpoint_v3_LbEndpoint* lb_endpoint) {
   // If health_status is not HEALTHY or UNKNOWN, skip this endpoint.
   const int32_t health_status =
       envoy_config_endpoint_v3_LbEndpoint_health_status(lb_endpoint);
   if (health_status != envoy_config_core_v3_UNKNOWN &&
       health_status != envoy_config_core_v3_HEALTHY) {
-    return GRPC_ERROR_NONE;
+    return absl::nullopt;
   }
   // Find the ip:port.
   const envoy_config_endpoint_v3_Endpoint* endpoint =
@@ -161,7 +160,7 @@ grpc_error_handle ServerAddressParseAndAppend(
       envoy_config_core_v3_SocketAddress_address(socket_address));
   uint32_t port = envoy_config_core_v3_SocketAddress_port_value(socket_address);
   if (GPR_UNLIKELY(port >> 16) != 0) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Invalid port.");
+    return absl::InvalidArgumentError("Invalid port.");
   }
   // Find load_balancing_weight for the endpoint.
   uint32_t weight = 1;
@@ -170,44 +169,42 @@ grpc_error_handle ServerAddressParseAndAppend(
   if (load_balancing_weight != nullptr) {
     weight = google_protobuf_UInt32Value_value(load_balancing_weight);
     if (weight == 0) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "Invalid endpoint weight of 0.");
+      return absl::InvalidArgumentError("Invalid endpoint weight of 0.");
     }
   }
   // Populate grpc_resolved_address.
-  grpc_resolved_address addr;
-  grpc_error_handle error =
-      grpc_string_to_sockaddr(&addr, address_str.c_str(), port);
-  if (!GRPC_ERROR_IS_NONE(error)) return error;
+  auto addr = StringToSockaddr(address_str, port);
+  if (!addr.ok()) return addr.status();
   // Append the address to the list.
   std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>
       attributes;
   attributes[ServerAddressWeightAttribute::kServerAddressWeightAttributeKey] =
       absl::make_unique<ServerAddressWeightAttribute>(weight);
-  list->emplace_back(addr, nullptr, std::move(attributes));
-  return GRPC_ERROR_NONE;
+  return ServerAddress(*addr, ChannelArgs(), std::move(attributes));
 }
 
-grpc_error_handle LocalityParse(
-    const envoy_config_endpoint_v3_LocalityLbEndpoints* locality_lb_endpoints,
-    XdsEndpointResource::Priority::Locality* output_locality,
-    size_t* priority) {
+struct ParsedLocality {
+  size_t priority;
+  XdsEndpointResource::Priority::Locality locality;
+};
+
+absl::StatusOr<ParsedLocality> LocalityParse(
+    const envoy_config_endpoint_v3_LocalityLbEndpoints* locality_lb_endpoints) {
+  ParsedLocality parsed_locality;
   // Parse LB weight.
   const google_protobuf_UInt32Value* lb_weight =
       envoy_config_endpoint_v3_LocalityLbEndpoints_load_balancing_weight(
           locality_lb_endpoints);
   // If LB weight is not specified, it means this locality is assigned no load.
-  // TODO(juanlishen): When we support CDS to configure the inter-locality
-  // policy, we should change the LB weight handling.
-  output_locality->lb_weight =
+  parsed_locality.locality.lb_weight =
       lb_weight != nullptr ? google_protobuf_UInt32Value_value(lb_weight) : 0;
-  if (output_locality->lb_weight == 0) return GRPC_ERROR_NONE;
+  if (parsed_locality.locality.lb_weight == 0) return parsed_locality;
   // Parse locality name.
   const envoy_config_core_v3_Locality* locality =
       envoy_config_endpoint_v3_LocalityLbEndpoints_locality(
           locality_lb_endpoints);
   if (locality == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty locality.");
+    return absl::InvalidArgumentError("Empty locality.");
   }
   std::string region =
       UpbStringToStdString(envoy_config_core_v3_Locality_region(locality));
@@ -215,7 +212,7 @@ grpc_error_handle LocalityParse(
       UpbStringToStdString(envoy_config_core_v3_Locality_zone(locality));
   std::string sub_zone =
       UpbStringToStdString(envoy_config_core_v3_Locality_sub_zone(locality));
-  output_locality->name = MakeRefCounted<XdsLocalityName>(
+  parsed_locality.locality.name = MakeRefCounted<XdsLocalityName>(
       std::move(region), std::move(zone), std::move(sub_zone));
   // Parse the addresses.
   size_t size;
@@ -223,17 +220,20 @@ grpc_error_handle LocalityParse(
       envoy_config_endpoint_v3_LocalityLbEndpoints_lb_endpoints(
           locality_lb_endpoints, &size);
   for (size_t i = 0; i < size; ++i) {
-    grpc_error_handle error = ServerAddressParseAndAppend(
-        lb_endpoints[i], &output_locality->endpoints);
-    if (!GRPC_ERROR_IS_NONE(error)) return error;
+    auto address = ServerAddressParse(lb_endpoints[i]);
+    if (!address.ok()) return address.status();
+    if (address->has_value()) {
+      parsed_locality.locality.endpoints.push_back(std::move(**address));
+    }
   }
   // Parse the priority.
-  *priority = envoy_config_endpoint_v3_LocalityLbEndpoints_priority(
-      locality_lb_endpoints);
-  return GRPC_ERROR_NONE;
+  parsed_locality.priority =
+      envoy_config_endpoint_v3_LocalityLbEndpoints_priority(
+          locality_lb_endpoints);
+  return parsed_locality;
 }
 
-grpc_error_handle DropParseAndAppend(
+absl::Status DropParseAndAppend(
     const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload*
         drop_overload,
     XdsEndpointResource::DropConfig* drop_config) {
@@ -242,7 +242,7 @@ grpc_error_handle DropParseAndAppend(
       envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload_category(
           drop_overload));
   if (category.empty()) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty drop category name");
+    return absl::InvalidArgumentError("Empty drop category name");
   }
   // Get the drop rate (per million).
   const envoy_type_v3_FractionalPercent* drop_percentage =
@@ -264,58 +264,60 @@ grpc_error_handle DropParseAndAppend(
     case envoy_type_v3_FractionalPercent_MILLION:
       break;
     default:
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unknown denominator type");
+      return absl::InvalidArgumentError(
+          "drop config: unknown denominator type");
   }
   // Cap numerator to 1000000.
   numerator = std::min(numerator, 1000000u);
   drop_config->AddCategory(std::move(category), numerator);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
-grpc_error_handle EdsResourceParse(
-    const XdsEncodingContext& /*context*/,
+absl::StatusOr<XdsEndpointResource> EdsResourceParse(
+    const XdsResourceType::DecodeContext& /*context*/,
     const envoy_config_endpoint_v3_ClusterLoadAssignment*
         cluster_load_assignment,
-    bool /*is_v2*/, XdsEndpointResource* eds_update) {
-  std::vector<grpc_error_handle> errors;
+    bool /*is_v2*/) {
+  XdsEndpointResource eds_resource;
+  std::vector<std::string> errors;
   // Get the endpoints.
   size_t locality_size;
   const envoy_config_endpoint_v3_LocalityLbEndpoints* const* endpoints =
       envoy_config_endpoint_v3_ClusterLoadAssignment_endpoints(
           cluster_load_assignment, &locality_size);
   for (size_t j = 0; j < locality_size; ++j) {
-    size_t priority;
-    XdsEndpointResource::Priority::Locality locality;
-    grpc_error_handle error = LocalityParse(endpoints[j], &locality, &priority);
-    if (!GRPC_ERROR_IS_NONE(error)) {
-      errors.push_back(error);
+    auto parsed_locality = LocalityParse(endpoints[j]);
+    if (!parsed_locality.ok()) {
+      errors.emplace_back(parsed_locality.status().message());
       continue;
     }
     // Filter out locality with weight 0.
-    if (locality.lb_weight == 0) continue;
+    if (parsed_locality->locality.lb_weight == 0) continue;
     // Make sure prorities is big enough. Note that they might not
     // arrive in priority order.
-    if (eds_update->priorities.size() < priority + 1) {
-      eds_update->priorities.resize(priority + 1);
+    if (eds_resource.priorities.size() < parsed_locality->priority + 1) {
+      eds_resource.priorities.resize(parsed_locality->priority + 1);
     }
-    auto& locality_map = eds_update->priorities[priority].localities;
-    auto it = locality_map.find(locality.name.get());
+    auto& locality_map =
+        eds_resource.priorities[parsed_locality->priority].localities;
+    auto it = locality_map.find(parsed_locality->locality.name.get());
     if (it != locality_map.end()) {
-      errors.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-          "duplicate locality ", locality.name->AsHumanReadableString(),
-          " found in priority ", priority)));
+      errors.emplace_back(
+          absl::StrCat("duplicate locality ",
+                       parsed_locality->locality.name->AsHumanReadableString(),
+                       " found in priority ", parsed_locality->priority));
     } else {
-      locality_map.emplace(locality.name.get(), std::move(locality));
+      locality_map.emplace(parsed_locality->locality.name.get(),
+                           std::move(parsed_locality->locality));
     }
   }
-  for (const auto& priority : eds_update->priorities) {
+  for (const auto& priority : eds_resource.priorities) {
     if (priority.localities.empty()) {
-      errors.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("sparse priority list"));
+      errors.emplace_back("sparse priority list");
     }
   }
   // Get the drop config.
-  eds_update->drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
+  eds_resource.drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
   const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy* policy =
       envoy_config_endpoint_v3_ClusterLoadAssignment_policy(
           cluster_load_assignment);
@@ -326,56 +328,56 @@ grpc_error_handle EdsResourceParse(
             envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_drop_overloads(
                 policy, &drop_size);
     for (size_t j = 0; j < drop_size; ++j) {
-      grpc_error_handle error =
-          DropParseAndAppend(drop_overload[j], eds_update->drop_config.get());
-      if (!GRPC_ERROR_IS_NONE(error)) {
-        errors.push_back(
-            grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                     "drop config validation error"),
-                                 error));
-      }
+      absl::Status status =
+          DropParseAndAppend(drop_overload[j], eds_resource.drop_config.get());
+      if (!status.ok()) errors.emplace_back(status.message());
     }
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing EDS resource", &errors);
+  // Return result.
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing EDS resource: [", absl::StrJoin(errors, "; "), "]"));
+  }
+  return eds_resource;
 }
 
 }  // namespace
 
-absl::StatusOr<XdsResourceType::DecodeResult> XdsEndpointResourceType::Decode(
-    const XdsEncodingContext& context, absl::string_view serialized_resource,
-    bool is_v2) const {
+XdsResourceType::DecodeResult XdsEndpointResourceType::Decode(
+    const XdsResourceType::DecodeContext& context,
+    absl::string_view serialized_resource, bool is_v2) const {
+  DecodeResult result;
   // Parse serialized proto.
   auto* resource = envoy_config_endpoint_v3_ClusterLoadAssignment_parse(
       serialized_resource.data(), serialized_resource.size(), context.arena);
   if (resource == nullptr) {
-    return absl::InvalidArgumentError(
+    result.resource = absl::InvalidArgumentError(
         "Can't parse ClusterLoadAssignment resource.");
+    return result;
   }
   MaybeLogClusterLoadAssignment(context, resource);
   // Validate resource.
-  DecodeResult result;
   result.name = UpbStringToStdString(
       envoy_config_endpoint_v3_ClusterLoadAssignment_cluster_name(resource));
-  auto endpoint_data = absl::make_unique<ResourceDataSubclass>();
-  grpc_error_handle error =
-      EdsResourceParse(context, resource, is_v2, &endpoint_data->resource);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    std::string error_str = grpc_error_std_string(error);
-    GRPC_ERROR_UNREF(error);
+  auto eds_resource = EdsResourceParse(context, resource, is_v2);
+  if (!eds_resource.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_ERROR, "[xds_client %p] invalid ClusterLoadAssignment %s: %s",
-              context.client, result.name.c_str(), error_str.c_str());
+              context.client, result.name->c_str(),
+              eds_resource.status().ToString().c_str());
     }
-    result.resource = absl::InvalidArgumentError(error_str);
+    result.resource = eds_resource.status();
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed ClusterLoadAssignment %s: %s",
-              context.client, result.name.c_str(),
-              endpoint_data->resource.ToString().c_str());
+              context.client, result.name->c_str(),
+              eds_resource->ToString().c_str());
     }
-    result.resource = std::move(endpoint_data);
+    auto resource = absl::make_unique<ResourceDataSubclass>();
+    resource->resource = std::move(*eds_resource);
+    result.resource = std::move(resource);
   }
-  return std::move(result);
+  return result;
 }
 
 }  // namespace grpc_core

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

@@ -28,13 +28,12 @@
 #include <utility>
 #include <vector>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
 #include "upb/def.h"
 
-#include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_client_stats.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -129,9 +128,9 @@ class XdsEndpointResourceType
     return "envoy.api.v2.ClusterLoadAssignment";
   }
 
-  absl::StatusOr<DecodeResult> Decode(const XdsEncodingContext& context,
-                                      absl::string_view serialized_resource,
-                                      bool is_v2) const override;
+  DecodeResult Decode(const XdsResourceType::DecodeContext& context,
+                      absl::string_view serialized_resource,
+                      bool is_v2) const override;
 
   void InitUpbSymtab(upb_DefPool* symtab) const override {
     envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(symtab);

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

@@ -109,7 +109,7 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(
       int abort_http_status_code =
           envoy_extensions_filters_http_fault_v3_FaultAbort_http_status(
               fault_abort);
-      if (abort_http_status_code != 0 and abort_http_status_code != 200) {
+      if (abort_http_status_code != 0 && abort_http_status_code != 200) {
         abort_grpc_status_code =
             grpc_http2_status_to_grpc_status(abort_http_status_code);
       }
@@ -203,16 +203,9 @@ const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {
   return &FaultInjectionFilter::kFilter;
 }
 
-grpc_channel_args* XdsHttpFaultFilter::ModifyChannelArgs(
-    grpc_channel_args* args) const {
-  grpc_arg args_to_add = grpc_channel_arg_integer_create(
-      const_cast<char*>(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG), 1);
-  grpc_channel_args* new_args =
-      grpc_channel_args_copy_and_add(args, &args_to_add, 1);
-  // Since this function takes the ownership of the channel args, it needs to
-  // deallocate the old ones to prevent leak.
-  grpc_channel_args_destroy(args);
-  return new_args;
+ChannelArgs XdsHttpFaultFilter::ModifyChannelArgs(
+    const ChannelArgs& args) const {
+  return args.Set(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG, 1);
 }
 
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>

data/src/core/ext/xds/xds_http_fault_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 {
@@ -49,7 +49,7 @@ class XdsHttpFaultFilter : public XdsHttpFilterImpl {
   const grpc_channel_filter* channel_filter() const override;
 
   // Overrides the ModifyChannelArgs method
-  grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) const override;
+  ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
 
   // Overrides the GenerateServiceConfig method
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(

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

@@ -26,11 +26,11 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "upb/arena.h"
 #include "upb/def.h"
 #include "upb/upb.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/json/json.h"
 
@@ -88,7 +88,7 @@ class XdsHttpFilterImpl {
   // Modifies channel args that may affect service config parsing (not
   // visible to the channel as a whole).
   // Takes ownership of args.  Caller takes ownership of return value.
-  virtual grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) const {
+  virtual ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const {
     return args;
   }