grpc 1.46.2 → 1.48.0.pre1

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

@@ -18,27 +18,41 @@
 
 #include "src/core/ext/xds/xds_cluster.h"
 
-#include "absl/container/inlined_vector.h"
+#include <stddef.h>
+
+#include <type_traits>
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "envoy/config/cluster/v3/circuit_breaker.upb.h"
 #include "envoy/config/cluster/v3/cluster.upb.h"
 #include "envoy/config/cluster/v3/cluster.upbdefs.h"
+#include "envoy/config/cluster/v3/outlier_detection.upb.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/core/v3/config_source.upb.h"
 #include "envoy/config/endpoint/v3/endpoint.upb.h"
 #include "envoy/config/endpoint/v3/endpoint_components.upb.h"
 #include "envoy/extensions/clusters/aggregate/v3/cluster.upb.h"
+#include "envoy/extensions/transport_sockets/tls/v3/tls.upb.h"
 #include "google/protobuf/any.upb.h"
+#include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "upb/text_encode.h"
+#include "upb/upb.h"
 
-#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
+#include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/ext/xds/xds_resource_type.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
 
 namespace grpc_core {
 
@@ -47,7 +61,7 @@ namespace grpc_core {
 //
 
 std::string XdsClusterResource::ToString() const {
-  absl::InlinedVector<std::string, 8> contents;
+  std::vector<std::string> contents;
   switch (cluster_type) {
     case EDS:
       contents.push_back("cluster_type=EDS");
@@ -120,7 +134,7 @@ grpc_error_handle UpstreamTlsContextParse(
     if (common_tls_context_proto != nullptr) {
       grpc_error_handle error = CommonTlsContext::Parse(
           context, common_tls_context_proto, common_tls_context);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         return grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                         "Error parsing UpstreamTlsContext"),
                                     error);
@@ -203,19 +217,6 @@ grpc_error_handle CdsLogicalDnsParse(
   return GRPC_ERROR_NONE;
 }
 
-// TODO(donnadionne): Check to see if cluster types aggregate_cluster and
-// logical_dns are enabled, this will be
-// removed once the cluster types are fully integration-tested and enabled by
-// default.
-bool XdsAggregateAndLogicalDnsClusterEnabled() {
-  char* value = gpr_getenv(
-      "GRPC_XDS_EXPERIMENTAL_ENABLE_AGGREGATE_AND_LOGICAL_DNS_CLUSTER");
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value, &parsed_value);
-  gpr_free(value);
-  return parse_succeeded && parsed_value;
-}
-
 grpc_error_handle CdsResourceParse(
     const XdsEncodingContext& context,
     const envoy_config_cluster_v3_Cluster* cluster, bool /*is_v2*/,
@@ -247,14 +248,11 @@ grpc_error_handle CdsResourceParse(
     if (service_name.size != 0) {
       cds_update->eds_service_name = UpbStringToStdString(service_name);
     }
-  } else if (!XdsAggregateAndLogicalDnsClusterEnabled()) {
-    errors.push_back(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("DiscoveryType is not valid."));
   } else if (envoy_config_cluster_v3_Cluster_type(cluster) ==
              envoy_config_cluster_v3_Cluster_LOGICAL_DNS) {
     cds_update->cluster_type = XdsClusterResource::ClusterType::LOGICAL_DNS;
     grpc_error_handle error = CdsLogicalDnsParse(cluster, cds_update);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   } else {
     if (!envoy_config_cluster_v3_Cluster_has_cluster_type(cluster)) {
       errors.push_back(
@@ -355,7 +353,7 @@ grpc_error_handle CdsResourceParse(
   if (transport_socket != nullptr) {
     grpc_error_handle error = UpstreamTlsContextParse(
         context, transport_socket, &cds_update->common_tls_context);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       errors.push_back(
           grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                    "Error parsing security configuration"),
@@ -398,6 +396,109 @@ grpc_error_handle CdsResourceParse(
       }
     }
   }
+  // As long as outlier detection field is present in the cluster update,
+  // we will end up with a outlier detection in the cluster resource which will
+  // lead to the creation of outlier detection in discovery mechanism.  Values
+  // for outlier detection will be based on fields received and
+  // default values.
+  if (XdsOutlierDetectionEnabled() &&
+      envoy_config_cluster_v3_Cluster_has_outlier_detection(cluster)) {
+    OutlierDetectionConfig outlier_detection_update;
+    const envoy_config_cluster_v3_OutlierDetection* outlier_detection =
+        envoy_config_cluster_v3_Cluster_outlier_detection(cluster);
+    const google_protobuf_Duration* duration =
+        envoy_config_cluster_v3_OutlierDetection_interval(outlier_detection);
+    if (duration != nullptr) {
+      outlier_detection_update.interval = ParseDuration(duration);
+    }
+    duration = envoy_config_cluster_v3_OutlierDetection_base_ejection_time(
+        outlier_detection);
+    if (duration != nullptr) {
+      outlier_detection_update.base_ejection_time = ParseDuration(duration);
+    }
+    duration = envoy_config_cluster_v3_OutlierDetection_max_ejection_time(
+        outlier_detection);
+    if (duration != nullptr) {
+      outlier_detection_update.max_ejection_time = ParseDuration(duration);
+    }
+    const google_protobuf_UInt32Value* max_ejection_percent =
+        envoy_config_cluster_v3_OutlierDetection_max_ejection_percent(
+            outlier_detection);
+    if (max_ejection_percent != nullptr) {
+      outlier_detection_update.max_ejection_percent =
+          google_protobuf_UInt32Value_value(max_ejection_percent);
+    }
+    const google_protobuf_UInt32Value* enforcing_success_rate =
+        envoy_config_cluster_v3_OutlierDetection_enforcing_success_rate(
+            outlier_detection);
+    if (enforcing_success_rate != nullptr) {
+      uint32_t enforcement_percentage =
+          google_protobuf_UInt32Value_value(enforcing_success_rate);
+      if (enforcement_percentage != 0) {
+        OutlierDetectionConfig::SuccessRateEjection success_rate_ejection;
+        success_rate_ejection.enforcement_percentage = enforcement_percentage;
+        const google_protobuf_UInt32Value* minimum_hosts =
+            envoy_config_cluster_v3_OutlierDetection_success_rate_minimum_hosts(
+                outlier_detection);
+        if (minimum_hosts != nullptr) {
+          success_rate_ejection.minimum_hosts =
+              google_protobuf_UInt32Value_value(minimum_hosts);
+        }
+        const google_protobuf_UInt32Value* request_volume =
+            envoy_config_cluster_v3_OutlierDetection_success_rate_request_volume(
+                outlier_detection);
+        if (request_volume != nullptr) {
+          success_rate_ejection.request_volume =
+              google_protobuf_UInt32Value_value(request_volume);
+        }
+        const google_protobuf_UInt32Value* stdev_factor =
+            envoy_config_cluster_v3_OutlierDetection_success_rate_stdev_factor(
+                outlier_detection);
+        if (stdev_factor != nullptr) {
+          success_rate_ejection.stdev_factor =
+              google_protobuf_UInt32Value_value(stdev_factor);
+        }
+        outlier_detection_update.success_rate_ejection = success_rate_ejection;
+      }
+    }
+    const google_protobuf_UInt32Value* enforcing_failure_percentage =
+        envoy_config_cluster_v3_OutlierDetection_enforcing_failure_percentage(
+            outlier_detection);
+    if (enforcing_failure_percentage != nullptr) {
+      uint32_t enforcement_percentage =
+          google_protobuf_UInt32Value_value(enforcing_failure_percentage);
+      if (enforcement_percentage != 0) {
+        OutlierDetectionConfig::FailurePercentageEjection
+            failure_percentage_ejection;
+        failure_percentage_ejection.enforcement_percentage =
+            enforcement_percentage;
+        const google_protobuf_UInt32Value* minimum_hosts =
+            envoy_config_cluster_v3_OutlierDetection_failure_percentage_minimum_hosts(
+                outlier_detection);
+        if (minimum_hosts != nullptr) {
+          failure_percentage_ejection.minimum_hosts =
+              google_protobuf_UInt32Value_value(minimum_hosts);
+        }
+        const google_protobuf_UInt32Value* request_volume =
+            envoy_config_cluster_v3_OutlierDetection_failure_percentage_request_volume(
+                outlier_detection);
+        if (request_volume != nullptr) {
+          failure_percentage_ejection.request_volume =
+              google_protobuf_UInt32Value_value(request_volume);
+        }
+        const google_protobuf_UInt32Value* threshold =
+            envoy_config_cluster_v3_OutlierDetection_failure_percentage_threshold(
+                outlier_detection);
+        if (threshold != nullptr) {
+          failure_percentage_ejection.threshold =
+              google_protobuf_UInt32Value_value(threshold);
+        }
+        outlier_detection_update.failure_percentage_ejection =
+            failure_percentage_ejection;
+      }
+    }
+    cds_update->outlier_detection = outlier_detection_update;
+  }
   return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing CDS resource", &errors);
 }
 
@@ -432,7 +533,7 @@ absl::StatusOr<XdsResourceType::DecodeResult> XdsClusterResourceType::Decode(
   auto cluster_data = absl::make_unique<ResourceDataSubclass>();
   grpc_error_handle error =
       CdsResourceParse(context, resource, is_v2, &cluster_data->resource);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     std::string error_str = grpc_error_std_string(error);
     GRPC_ERROR_UNREF(error);
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {

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

@@ -19,15 +19,24 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
+#include <algorithm>
+#include <memory>
 #include <string>
 #include <vector>
 
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "envoy/config/cluster/v3/cluster.upbdefs.h"
 #include "envoy/extensions/clusters/aggregate/v3/cluster.upbdefs.h"
 #include "envoy/extensions/transport_sockets/tls/v3/tls.upbdefs.h"
+#include "upb/def.h"
 
-#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h"
+#include "src/core/ext/xds/upb_utils.h"
+#include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 
@@ -63,6 +72,8 @@ struct XdsClusterResource {
   // cluster.
   uint32_t max_concurrent_requests = 1024;
 
+  absl::optional<OutlierDetectionConfig> outlier_detection;
+
   bool operator==(const XdsClusterResource& other) const {
     return cluster_type == other.cluster_type &&
            eds_service_name == other.eds_service_name &&

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

@@ -18,14 +18,23 @@
 
 #include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
 
-#include "absl/strings/str_format.h"
-#include "envoy/extensions/filters/http/router/v3/router.upb.h"
-#include "envoy/extensions/filters/http/router/v3/router.upbdefs.h"
-#include "google/protobuf/duration.upb.h"
+#include <stddef.h>
+
+#include <algorithm>
+#include <map>
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 #include "upb/json_encode.h"
+#include "upb/upb.hpp"
+
+#include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/ext/xds/upb_utils.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/json/json.h"
 #include "src/proto/grpc/lookup/v1/rls_config.upb.h"
 #include "src/proto/grpc/lookup/v1/rls_config.upbdefs.h"
 
@@ -72,7 +81,7 @@ XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
   grpc_error_handle error = GRPC_ERROR_NONE;
   rls_policy["routeLookupConfig"] =
       Json::Parse(reinterpret_cast<char*>(buf), &error);
-  GPR_ASSERT(error == GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
   Json::Object cds_policy;
   cds_policy["cds_experimental"] = Json::Object();
   Json::Array child_policy;
@@ -91,7 +100,7 @@ XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
   // itself.
   LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(lb_policy_config,
                                                         &parse_error);
-  if (parse_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(parse_error)) {
     absl::Status status = absl::InvalidArgumentError(absl::StrCat(
         kXdsRouteLookupClusterSpecifierPluginConfigName,
         " ClusterSpecifierPlugin returned invalid LB policy config: ",

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

@@ -20,19 +20,12 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
-#include <set>
 #include <string>
 
 #include "absl/status/statusor.h"
-#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "google/protobuf/any.upb.h"
 #include "upb/def.h"
-
-#include <grpc/grpc.h>
-
-#include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/json/json.h"
+#include "upb/upb.h"
 
 namespace grpc_core {
 

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

@@ -18,7 +18,13 @@
 
 #include "src/core/ext/xds/xds_common_types.h"
 
-#include "absl/container/inlined_vector.h"
+#include <stddef.h>
+
+#include <algorithm>
+#include <map>
+#include <utility>
+
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -29,8 +35,11 @@
 #include "envoy/type/matcher/v3/string.upb.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "upb/upb.h"
 #include "xds/type/v3/typed_struct.upb.h"
 
+#include "src/core/ext/xds/certificate_provider_store.h"
+
 namespace grpc_core {
 
 //
@@ -56,7 +65,7 @@ bool CommonTlsContext::CertificateValidationContext::Empty() const {
 
 std::string CommonTlsContext::CertificateProviderPluginInstance::ToString()
     const {
-  absl::InlinedVector<std::string, 2> contents;
+  std::vector<std::string> contents;
   if (!instance_name.empty()) {
     contents.push_back(absl::StrFormat("instance_name=%s", instance_name));
   }
@@ -76,7 +85,7 @@ bool CommonTlsContext::CertificateProviderPluginInstance::Empty() const {
 //
 
 std::string CommonTlsContext::ToString() const {
-  absl::InlinedVector<std::string, 2> contents;
+  std::vector<std::string> contents;
   if (!tls_certificate_provider_instance.Empty()) {
     contents.push_back(
         absl::StrFormat("tls_certificate_provider_instance=%s",
@@ -220,7 +229,7 @@ grpc_error_handle CertificateValidationContextParse(
     grpc_error_handle error = CertificateProviderPluginInstanceParse(
         context, ca_certificate_provider_instance,
         &certificate_validation_context->ca_certificate_provider_instance);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   }
   if (envoy_extensions_transport_sockets_tls_v3_CertificateValidationContext_verify_certificate_spki(
           certificate_validation_context_proto, nullptr) != nullptr) {
@@ -280,7 +289,7 @@ grpc_error_handle CommonTlsContext::Parse(
       grpc_error_handle error = CertificateValidationContextParse(
           context, default_validation_context,
           &common_tls_context->certificate_validation_context);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     }
     // If after parsing default_validation_context,
     // common_tls_context->certificate_validation_context.ca_certificate_provider_instance
@@ -299,7 +308,7 @@ grpc_error_handle CommonTlsContext::Parse(
           context, validation_context_certificate_provider_instance,
           &common_tls_context->certificate_validation_context
                .ca_certificate_provider_instance);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     }
   } else {
     auto* validation_context =
@@ -309,7 +318,7 @@ grpc_error_handle CommonTlsContext::Parse(
       grpc_error_handle error = CertificateValidationContextParse(
           context, validation_context,
           &common_tls_context->certificate_validation_context);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     } else if (
         envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_has_validation_context_sds_secret_config(
             common_tls_context_proto)) {
@@ -324,7 +333,7 @@ grpc_error_handle CommonTlsContext::Parse(
     grpc_error_handle error = CertificateProviderPluginInstanceParse(
         context, tls_certificate_provider_instance,
         &common_tls_context->tls_certificate_provider_instance);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   } else {
     // Fall back onto 'tls_certificate_certificate_provider_instance'. Note that
     // this way of fetching identity certificates is deprecated and will be
@@ -337,7 +346,7 @@ grpc_error_handle CommonTlsContext::Parse(
       grpc_error_handle error = CertificateProviderInstanceParse(
           context, tls_certificate_certificate_provider_instance,
           &common_tls_context->tls_certificate_provider_instance);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     } else {
       if (envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_has_tls_certificates(
               common_tls_context_proto)) {
@@ -365,24 +374,29 @@ grpc_error_handle CommonTlsContext::Parse(
                                        &errors);
 }
 
-grpc_error_handle ExtractExtensionTypeName(const XdsEncodingContext& context,
-                                           const google_protobuf_Any* any,
-                                           absl::string_view* extension_type) {
-  *extension_type = UpbStringToAbsl(google_protobuf_Any_type_url(any));
-  if (*extension_type == "type.googleapis.com/xds.type.v3.TypedStruct" ||
-      *extension_type == "type.googleapis.com/udpa.type.v1.TypedStruct") {
+absl::StatusOr<ExtractExtensionTypeNameResult> ExtractExtensionTypeName(
+    const XdsEncodingContext& context, const google_protobuf_Any* any) {
+  ExtractExtensionTypeNameResult result;
+  result.type = UpbStringToAbsl(google_protobuf_Any_type_url(any));
+  if (result.type == "type.googleapis.com/xds.type.v3.TypedStruct" ||
+      result.type == "type.googleapis.com/udpa.type.v1.TypedStruct") {
     upb_StringView any_value = google_protobuf_Any_value(any);
-    const auto* typed_struct = xds_type_v3_TypedStruct_parse(
+    result.typed_struct = xds_type_v3_TypedStruct_parse(
         any_value.data, any_value.size, context.arena);
-    if (typed_struct == nullptr) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    if (result.typed_struct == nullptr) {
+      return absl::InvalidArgumentError(
           "could not parse TypedStruct from extension");
     }
-    *extension_type =
-        UpbStringToAbsl(xds_type_v3_TypedStruct_type_url(typed_struct));
+    result.type =
+        UpbStringToAbsl(xds_type_v3_TypedStruct_type_url(result.typed_struct));
   }
-  *extension_type = absl::StripPrefix(*extension_type, "type.googleapis.com/");
-  return GRPC_ERROR_NONE;
+  size_t pos = result.type.rfind('/');
+  if (pos == absl::string_view::npos || pos == result.type.size() - 1) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("Invalid type_url ", result.type));
+  }
+  result.type = result.type.substr(pos + 1);
+  return result;
 }
 
 }  // namespace grpc_core

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

@@ -22,12 +22,16 @@
 #include <string>
 #include <vector>
 
-#include "absl/strings/str_format.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 #include "envoy/extensions/transport_sockets/tls/v3/tls.upb.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
+#include "xds/type/v3/typed_struct.upb.h"
 
 #include "src/core/ext/xds/upb_utils.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/matchers/matchers.h"
 
 namespace grpc_core {
@@ -86,9 +90,13 @@ struct CommonTlsContext {
       CommonTlsContext* common_tls_context);
 };
 
-grpc_error_handle ExtractExtensionTypeName(const XdsEncodingContext& context,
-                                           const google_protobuf_Any* any,
-                                           absl::string_view* extension_type);
+struct ExtractExtensionTypeNameResult {
+  absl::string_view type;
+  xds_type_v3_TypedStruct* typed_struct = nullptr;
+};
+
+absl::StatusOr<ExtractExtensionTypeNameResult> ExtractExtensionTypeName(
+    const XdsEncodingContext& context, const google_protobuf_Any* any);
 
 }  // namespace grpc_core
 

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

@@ -18,7 +18,14 @@
 
 #include "src/core/ext/xds/xds_endpoint.h"
 
+#include <stdlib.h>
+
+#include <algorithm>
+#include <type_traits>
+#include <vector>
+
 #include "absl/memory/memory.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "envoy/config/core/v3/address.upb.h"
@@ -30,12 +37,15 @@
 #include "envoy/type/v3/percent.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 #include "upb/text_encode.h"
-#include "upb/upb.h"
-#include "upb/upb.hpp"
+
+#include <grpc/support/log.h>
 
 #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/address_utils/sockaddr_utils.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 {
 
@@ -154,21 +164,21 @@ grpc_error_handle ServerAddressParseAndAppend(
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Invalid port.");
   }
   // Find load_balancing_weight for the endpoint.
+  uint32_t weight = 1;
   const google_protobuf_UInt32Value* load_balancing_weight =
       envoy_config_endpoint_v3_LbEndpoint_load_balancing_weight(lb_endpoint);
-  const int32_t weight =
-      load_balancing_weight != nullptr
-          ? google_protobuf_UInt32Value_value(load_balancing_weight)
-          : 500;
-  if (weight == 0) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Invalid endpoint weight of 0.");
+  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.");
+    }
   }
   // Populate grpc_resolved_address.
   grpc_resolved_address addr;
   grpc_error_handle error =
       grpc_string_to_sockaddr(&addr, address_str.c_str(), port);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   // Append the address to the list.
   std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>
       attributes;
@@ -215,7 +225,7 @@ grpc_error_handle LocalityParse(
   for (size_t i = 0; i < size; ++i) {
     grpc_error_handle error = ServerAddressParseAndAppend(
         lb_endpoints[i], &output_locality->endpoints);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
   }
   // Parse the priority.
   *priority = envoy_config_endpoint_v3_LocalityLbEndpoints_priority(
@@ -277,7 +287,7 @@ grpc_error_handle EdsResourceParse(
     size_t priority;
     XdsEndpointResource::Priority::Locality locality;
     grpc_error_handle error = LocalityParse(endpoints[j], &locality, &priority);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       errors.push_back(error);
       continue;
     }
@@ -318,7 +328,7 @@ grpc_error_handle EdsResourceParse(
     for (size_t j = 0; j < drop_size; ++j) {
       grpc_error_handle error =
           DropParseAndAppend(drop_overload[j], eds_update->drop_config.get());
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         errors.push_back(
             grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                      "drop config validation error"),
@@ -349,7 +359,7 @@ absl::StatusOr<XdsResourceType::DecodeResult> XdsEndpointResourceType::Decode(
   auto endpoint_data = absl::make_unique<ResourceDataSubclass>();
   grpc_error_handle error =
       EdsResourceParse(context, resource, is_v2, &endpoint_data->resource);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     std::string error_str = grpc_error_std_string(error);
     GRPC_ERROR_UNREF(error);
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {

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

@@ -19,16 +19,24 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
+#include <algorithm>
 #include <map>
-#include <set>
+#include <memory>
 #include <string>
+#include <utility>
+#include <vector>
 
-#include "absl/container/inlined_vector.h"
+#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/xds_client.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_impl.h"
+#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/resolver/server_address.h"
 
@@ -54,7 +62,7 @@ struct XdsEndpointResource {
     bool operator==(const Priority& other) const;
     std::string ToString() const;
   };
-  using PriorityList = absl::InlinedVector<Priority, 2>;
+  using PriorityList = std::vector<Priority>;
 
   // There are two phases of accessing this class's content:
   // 1. to initialize in the control plane combiner;
@@ -72,7 +80,7 @@ struct XdsEndpointResource {
       const uint32_t parts_per_million;
     };
 
-    using DropCategoryList = absl::InlinedVector<DropCategory, 2>;
+    using DropCategoryList = std::vector<DropCategory>;
 
     void AddCategory(std::string name, uint32_t parts_per_million) {
       drop_category_list_.emplace_back(