grpc 1.50.0 → 1.52.0.pre2

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

@@ -19,11 +19,13 @@
 #include "src/core/ext/xds/xds_endpoint.h"
 
 #include <stdlib.h>
+#include <string.h>
 
 #include <algorithm>
+#include <limits>
+#include <set>
 #include <vector>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -42,10 +44,15 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/xds/upb_utils.h"
+#include "src/core/ext/xds/xds_cluster.h"
+#include "src/core/ext/xds/xds_health_status.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/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
 
@@ -78,6 +85,7 @@ bool XdsEndpointResource::Priority::operator==(const Priority& other) const {
 
 std::string XdsEndpointResource::Priority::ToString() const {
   std::vector<std::string> locality_strings;
+  locality_strings.reserve(localities.size());
   for (const auto& p : localities) {
     locality_strings.emplace_back(p.second.ToString());
   }
@@ -140,47 +148,82 @@ void MaybeLogClusterLoadAssignment(
   }
 }
 
-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.
+absl::optional<ServerAddress> ServerAddressParse(
+    const envoy_config_endpoint_v3_LbEndpoint* lb_endpoint,
+    ValidationErrors* errors) {
+  // health_status
   const int32_t health_status =
       envoy_config_endpoint_v3_LbEndpoint_health_status(lb_endpoint);
-  if (health_status != envoy_config_core_v3_UNKNOWN &&
+  if (!XdsHostOverrideEnabled() &&
+      health_status != envoy_config_core_v3_UNKNOWN &&
       health_status != envoy_config_core_v3_HEALTHY) {
     return absl::nullopt;
   }
-  // Find the ip:port.
-  const envoy_config_endpoint_v3_Endpoint* endpoint =
-      envoy_config_endpoint_v3_LbEndpoint_endpoint(lb_endpoint);
-  const envoy_config_core_v3_Address* address =
-      envoy_config_endpoint_v3_Endpoint_address(endpoint);
-  const envoy_config_core_v3_SocketAddress* socket_address =
-      envoy_config_core_v3_Address_socket_address(address);
-  std::string address_str = UpbStringToStdString(
-      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 absl::InvalidArgumentError("Invalid port.");
-  }
-  // Find load_balancing_weight for the endpoint.
+  auto status = XdsHealthStatus::FromUpb(health_status);
+  if (!status.has_value()) return absl::nullopt;
+  // load_balancing_weight
   uint32_t weight = 1;
-  const google_protobuf_UInt32Value* load_balancing_weight =
-      envoy_config_endpoint_v3_LbEndpoint_load_balancing_weight(lb_endpoint);
-  if (load_balancing_weight != nullptr) {
-    weight = google_protobuf_UInt32Value_value(load_balancing_weight);
-    if (weight == 0) {
-      return absl::InvalidArgumentError("Invalid endpoint weight of 0.");
+  {
+    ValidationErrors::ScopedField field(errors, ".load_balancing_weight");
+    const google_protobuf_UInt32Value* load_balancing_weight =
+        envoy_config_endpoint_v3_LbEndpoint_load_balancing_weight(lb_endpoint);
+    if (load_balancing_weight != nullptr) {
+      weight = google_protobuf_UInt32Value_value(load_balancing_weight);
+      if (weight == 0) {
+        errors->AddError("must be greater than 0");
+      }
+    }
+  }
+  // endpoint
+  grpc_resolved_address grpc_address;
+  {
+    ValidationErrors::ScopedField field(errors, ".endpoint");
+    const envoy_config_endpoint_v3_Endpoint* endpoint =
+        envoy_config_endpoint_v3_LbEndpoint_endpoint(lb_endpoint);
+    if (endpoint == nullptr) {
+      errors->AddError("field not present");
+      return absl::nullopt;
+    }
+    ValidationErrors::ScopedField field2(errors, ".address");
+    const envoy_config_core_v3_Address* address =
+        envoy_config_endpoint_v3_Endpoint_address(endpoint);
+    if (address == nullptr) {
+      errors->AddError("field not present");
+      return absl::nullopt;
+    }
+    ValidationErrors::ScopedField field3(errors, ".socket_address");
+    const envoy_config_core_v3_SocketAddress* socket_address =
+        envoy_config_core_v3_Address_socket_address(address);
+    if (socket_address == nullptr) {
+      errors->AddError("field not present");
+      return absl::nullopt;
+    }
+    std::string address_str = UpbStringToStdString(
+        envoy_config_core_v3_SocketAddress_address(socket_address));
+    uint32_t port;
+    {
+      ValidationErrors::ScopedField field(errors, ".port_value");
+      port = envoy_config_core_v3_SocketAddress_port_value(socket_address);
+      if (GPR_UNLIKELY(port >> 16) != 0) {
+        errors->AddError("invalid port");
+        return absl::nullopt;
+      }
+    }
+    auto addr = StringToSockaddr(address_str, port);
+    if (!addr.ok()) {
+      errors->AddError(addr.status().message());
+    } else {
+      grpc_address = *addr;
     }
   }
-  // Populate grpc_resolved_address.
-  auto addr = StringToSockaddr(address_str, port);
-  if (!addr.ok()) return addr.status();
-  // Append the address to the list.
+  // Convert to ServerAddress.
   std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>
       attributes;
   attributes[ServerAddressWeightAttribute::kServerAddressWeightAttributeKey] =
-      absl::make_unique<ServerAddressWeightAttribute>(weight);
-  return ServerAddress(*addr, ChannelArgs(), std::move(attributes));
+      std::make_unique<ServerAddressWeightAttribute>(weight);
+  attributes[XdsEndpointHealthStatusAttribute::kKey] =
+      std::make_unique<XdsEndpointHealthStatusAttribute>(*status);
+  return ServerAddress(grpc_address, ChannelArgs(), std::move(attributes));
 }
 
 struct ParsedLocality {
@@ -188,156 +231,205 @@ struct ParsedLocality {
   XdsEndpointResource::Priority::Locality locality;
 };
 
-absl::StatusOr<ParsedLocality> LocalityParse(
-    const envoy_config_endpoint_v3_LocalityLbEndpoints* locality_lb_endpoints) {
+struct ResolvedAddressLessThan {
+  bool operator()(const grpc_resolved_address& a1,
+                  const grpc_resolved_address& a2) const {
+    if (a1.len != a2.len) return a1.len < a2.len;
+    return memcmp(a1.addr, a2.addr, a1.len) < 0;
+  }
+};
+using ResolvedAddressSet =
+    std::set<grpc_resolved_address, ResolvedAddressLessThan>;
+
+absl::optional<ParsedLocality> LocalityParse(
+    const envoy_config_endpoint_v3_LocalityLbEndpoints* locality_lb_endpoints,
+    ResolvedAddressSet* address_set, ValidationErrors* errors) {
+  const size_t original_error_size = errors->size();
   ParsedLocality parsed_locality;
-  // Parse LB weight.
+  // load_balancing_weight
+  // If LB weight is not specified or 0, it means this locality is assigned
+  // no load.
   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.
   parsed_locality.locality.lb_weight =
       lb_weight != nullptr ? google_protobuf_UInt32Value_value(lb_weight) : 0;
-  if (parsed_locality.locality.lb_weight == 0) return parsed_locality;
-  // Parse locality name.
+  if (parsed_locality.locality.lb_weight == 0) return absl::nullopt;
+  // locality
   const envoy_config_core_v3_Locality* locality =
       envoy_config_endpoint_v3_LocalityLbEndpoints_locality(
           locality_lb_endpoints);
   if (locality == nullptr) {
-    return absl::InvalidArgumentError("Empty locality.");
+    ValidationErrors::ScopedField field(errors, ".locality");
+    errors->AddError("field not present");
+    return absl::nullopt;
   }
+  // region
   std::string region =
       UpbStringToStdString(envoy_config_core_v3_Locality_region(locality));
+  // zone
   std::string zone =
       UpbStringToStdString(envoy_config_core_v3_Locality_zone(locality));
+  // sub_zone
   std::string sub_zone =
       UpbStringToStdString(envoy_config_core_v3_Locality_sub_zone(locality));
   parsed_locality.locality.name = MakeRefCounted<XdsLocalityName>(
       std::move(region), std::move(zone), std::move(sub_zone));
-  // Parse the addresses.
+  // lb_endpoints
   size_t size;
   const envoy_config_endpoint_v3_LbEndpoint* const* lb_endpoints =
       envoy_config_endpoint_v3_LocalityLbEndpoints_lb_endpoints(
           locality_lb_endpoints, &size);
   for (size_t i = 0; i < size; ++i) {
-    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));
+    ValidationErrors::ScopedField field(errors,
+                                        absl::StrCat(".lb_endpoints[", i, "]"));
+    auto address = ServerAddressParse(lb_endpoints[i], errors);
+    if (address.has_value()) {
+      bool inserted = address_set->insert(address->address()).second;
+      if (!inserted) {
+        errors->AddError(absl::StrCat(
+            "duplicate endpoint address \"",
+            grpc_sockaddr_to_uri(&address->address()).value_or("<unknown>"),
+            "\""));
+      }
+      parsed_locality.locality.endpoints.push_back(std::move(*address));
     }
   }
-  // Parse the priority.
+  // priority
   parsed_locality.priority =
       envoy_config_endpoint_v3_LocalityLbEndpoints_priority(
           locality_lb_endpoints);
+  // Return result.
+  if (original_error_size != errors->size()) return absl::nullopt;
   return parsed_locality;
 }
 
-absl::Status DropParseAndAppend(
+void DropParseAndAppend(
     const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload*
         drop_overload,
-    XdsEndpointResource::DropConfig* drop_config) {
-  // Get the category.
+    XdsEndpointResource::DropConfig* drop_config, ValidationErrors* errors) {
+  // category
   std::string category = UpbStringToStdString(
       envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload_category(
           drop_overload));
   if (category.empty()) {
-    return absl::InvalidArgumentError("Empty drop category name");
+    ValidationErrors::ScopedField field(errors, ".category");
+    errors->AddError("empty drop category name");
   }
-  // Get the drop rate (per million).
-  const envoy_type_v3_FractionalPercent* drop_percentage =
-      envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload_drop_percentage(
-          drop_overload);
-  uint32_t numerator =
-      envoy_type_v3_FractionalPercent_numerator(drop_percentage);
-  const auto denominator =
-      static_cast<envoy_type_v3_FractionalPercent_DenominatorType>(
-          envoy_type_v3_FractionalPercent_denominator(drop_percentage));
-  // Normalize to million.
-  switch (denominator) {
-    case envoy_type_v3_FractionalPercent_HUNDRED:
-      numerator *= 10000;
-      break;
-    case envoy_type_v3_FractionalPercent_TEN_THOUSAND:
-      numerator *= 100;
-      break;
-    case envoy_type_v3_FractionalPercent_MILLION:
-      break;
-    default:
-      return absl::InvalidArgumentError(
-          "drop config: unknown denominator type");
+  // drop_percentage
+  uint32_t numerator;
+  {
+    ValidationErrors::ScopedField field(errors, ".drop_percentage");
+    const envoy_type_v3_FractionalPercent* drop_percentage =
+        envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload_drop_percentage(
+            drop_overload);
+    if (drop_percentage == nullptr) {
+      errors->AddError("field not present");
+      return;
+    }
+    numerator = envoy_type_v3_FractionalPercent_numerator(drop_percentage);
+    {
+      ValidationErrors::ScopedField field(errors, ".denominator");
+      const int denominator =
+          envoy_type_v3_FractionalPercent_denominator(drop_percentage);
+      // Normalize to million.
+      switch (denominator) {
+        case envoy_type_v3_FractionalPercent_HUNDRED:
+          numerator *= 10000;
+          break;
+        case envoy_type_v3_FractionalPercent_TEN_THOUSAND:
+          numerator *= 100;
+          break;
+        case envoy_type_v3_FractionalPercent_MILLION:
+          break;
+        default:
+          errors->AddError("unknown denominator type");
+      }
+    }
+    // Cap numerator to 1000000.
+    numerator = std::min(numerator, 1000000u);
   }
-  // Cap numerator to 1000000.
-  numerator = std::min(numerator, 1000000u);
+  // Add category.
   drop_config->AddCategory(std::move(category), numerator);
-  return absl::OkStatus();
 }
 
 absl::StatusOr<XdsEndpointResource> EdsResourceParse(
     const XdsResourceType::DecodeContext& /*context*/,
     const envoy_config_endpoint_v3_ClusterLoadAssignment*
-        cluster_load_assignment,
-    bool /*is_v2*/) {
+        cluster_load_assignment) {
+  ValidationErrors errors;
   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) {
-    auto parsed_locality = LocalityParse(endpoints[j]);
-    if (!parsed_locality.ok()) {
-      errors.emplace_back(parsed_locality.status().message());
-      continue;
+  // endpoints
+  {
+    ValidationErrors::ScopedField field(&errors, "endpoints");
+    ResolvedAddressSet address_set;
+    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 i = 0; i < locality_size; ++i) {
+      ValidationErrors::ScopedField field(&errors, absl::StrCat("[", i, "]"));
+      auto parsed_locality = LocalityParse(endpoints[i], &address_set, &errors);
+      if (parsed_locality.has_value()) {
+        GPR_ASSERT(parsed_locality->locality.lb_weight != 0);
+        // Make sure prorities is big enough. Note that they might not
+        // arrive in priority order.
+        if (eds_resource.priorities.size() < parsed_locality->priority + 1) {
+          eds_resource.priorities.resize(parsed_locality->priority + 1);
+        }
+        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.AddError(absl::StrCat(
+              "duplicate locality ",
+              parsed_locality->locality.name->AsHumanReadableString(),
+              " found in priority ", parsed_locality->priority));
+        } else {
+          locality_map.emplace(parsed_locality->locality.name.get(),
+                               std::move(parsed_locality->locality));
+        }
+      }
     }
-    // Filter out locality with weight 0.
-    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_resource.priorities.size() < parsed_locality->priority + 1) {
-      eds_resource.priorities.resize(parsed_locality->priority + 1);
-    }
-    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.emplace_back(
-          absl::StrCat("duplicate locality ",
-                       parsed_locality->locality.name->AsHumanReadableString(),
-                       " found in priority ", parsed_locality->priority));
-    } else {
-      locality_map.emplace(parsed_locality->locality.name.get(),
-                           std::move(parsed_locality->locality));
+    for (size_t i = 0; i < eds_resource.priorities.size(); ++i) {
+      const auto& priority = eds_resource.priorities[i];
+      if (priority.localities.empty()) {
+        errors.AddError(absl::StrCat("priority ", i, " empty"));
+      } else {
+        // Check that the sum of the locality weights in this priority
+        // does not exceed the max value for a uint32.
+        uint64_t total_weight = 0;
+        for (const auto& p : priority.localities) {
+          total_weight += p.second.lb_weight;
+          if (total_weight > std::numeric_limits<uint32_t>::max()) {
+            errors.AddError(
+                absl::StrCat("sum of locality weights for priority ", i,
+                             " exceeds uint32 max"));
+            break;
+          }
+        }
+      }
     }
   }
-  for (const auto& priority : eds_resource.priorities) {
-    if (priority.localities.empty()) {
-      errors.emplace_back("sparse priority list");
-    }
-  }
-  // Get the drop config.
+  // policy
   eds_resource.drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
-  const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy* policy =
-      envoy_config_endpoint_v3_ClusterLoadAssignment_policy(
-          cluster_load_assignment);
+  const auto* policy = envoy_config_endpoint_v3_ClusterLoadAssignment_policy(
+      cluster_load_assignment);
   if (policy != nullptr) {
+    ValidationErrors::ScopedField field(&errors, "policy");
     size_t drop_size;
-    const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload* const*
-        drop_overload =
-            envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_drop_overloads(
-                policy, &drop_size);
-    for (size_t j = 0; j < drop_size; ++j) {
-      absl::Status status =
-          DropParseAndAppend(drop_overload[j], eds_resource.drop_config.get());
-      if (!status.ok()) errors.emplace_back(status.message());
+    const auto* const* drop_overload =
+        envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_drop_overloads(
+            policy, &drop_size);
+    for (size_t i = 0; i < drop_size; ++i) {
+      ValidationErrors::ScopedField field(
+          &errors, absl::StrCat(".drop_overloads[", i, "]"));
+      DropParseAndAppend(drop_overload[i], eds_resource.drop_config.get(),
+                         &errors);
     }
   }
   // Return result.
-  if (!errors.empty()) {
-    return absl::InvalidArgumentError(absl::StrCat(
-        "errors parsing EDS resource: [", absl::StrJoin(errors, "; "), "]"));
-  }
+  if (!errors.ok()) return errors.status("errors parsing EDS resource");
   return eds_resource;
 }
 
@@ -345,7 +437,7 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
 
 XdsResourceType::DecodeResult XdsEndpointResourceType::Decode(
     const XdsResourceType::DecodeContext& context,
-    absl::string_view serialized_resource, bool is_v2) const {
+    absl::string_view serialized_resource) const {
   DecodeResult result;
   // Parse serialized proto.
   auto* resource = envoy_config_endpoint_v3_ClusterLoadAssignment_parse(
@@ -359,7 +451,7 @@ XdsResourceType::DecodeResult XdsEndpointResourceType::Decode(
   // Validate resource.
   result.name = UpbStringToStdString(
       envoy_config_endpoint_v3_ClusterLoadAssignment_cluster_name(resource));
-  auto eds_resource = EdsResourceParse(context, resource, is_v2);
+  auto eds_resource = EdsResourceParse(context, resource);
   if (!eds_resource.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_ERROR, "[xds_client %p] invalid ClusterLoadAssignment %s: %s",
@@ -373,9 +465,8 @@ XdsResourceType::DecodeResult XdsEndpointResourceType::Decode(
               context.client, result.name->c_str(),
               eds_resource->ToString().c_str());
     }
-    auto resource = absl::make_unique<ResourceDataSubclass>();
-    resource->resource = std::move(*eds_resource);
-    result.resource = std::move(resource);
+    result.resource =
+        std::make_unique<XdsEndpointResource>(std::move(*eds_resource));
   }
   return result;
 }

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

@@ -32,6 +32,7 @@
 #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/xds_client_stats.h"
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
@@ -41,7 +42,7 @@
 
 namespace grpc_core {
 
-struct XdsEndpointResource {
+struct XdsEndpointResource : public XdsResourceType::ResourceData {
   struct Priority {
     struct Locality {
       RefCountedPtr<XdsLocalityName> name;
@@ -124,15 +125,11 @@ class XdsEndpointResourceType
   absl::string_view type_url() const override {
     return "envoy.config.endpoint.v3.ClusterLoadAssignment";
   }
-  absl::string_view v2_type_url() const override {
-    return "envoy.api.v2.ClusterLoadAssignment";
-  }
 
   DecodeResult Decode(const XdsResourceType::DecodeContext& context,
-                      absl::string_view serialized_resource,
-                      bool is_v2) const override;
+                      absl::string_view serialized_resource) const override;
 
-  void InitUpbSymtab(upb_DefPool* symtab) const override {
+  void InitUpbSymtab(XdsClient*, upb_DefPool* symtab) const override {
     envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(symtab);
   }
 };

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

@@ -0,0 +1,80 @@
+//
+// 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_health_status.h"
+
+#include "absl/strings/str_cat.h"
+#include "envoy/config/core/v3/health_check.upb.h"
+
+#include "src/core/lib/gpr/useful.h"
+
+namespace grpc_core {
+
+absl::optional<XdsHealthStatus> XdsHealthStatus::FromUpb(uint32_t status) {
+  switch (status) {
+    case envoy_config_core_v3_UNKNOWN:
+      return XdsHealthStatus(kUnknown);
+    case envoy_config_core_v3_HEALTHY:
+      return XdsHealthStatus(kHealthy);
+    case envoy_config_core_v3_DRAINING:
+      return XdsHealthStatus(kDraining);
+    default:
+      return absl::nullopt;
+  }
+}
+
+absl::optional<XdsHealthStatus> XdsHealthStatus::FromString(
+    absl::string_view status) {
+  if (status == "UNKNOWN") return XdsHealthStatus(kUnknown);
+  if (status == "HEALTHY") return XdsHealthStatus(kHealthy);
+  if (status == "DRAINING") return XdsHealthStatus(kDraining);
+  return absl::nullopt;
+}
+
+const char* XdsHealthStatus::ToString() const {
+  switch (status_) {
+    case kUnknown:
+      return "UNKNOWN";
+    case kHealthy:
+      return "HEALTHY";
+    case kDraining:
+      return "DRAINING";
+    default:
+      return "<INVALID>";
+  }
+}
+
+bool operator<(const XdsHealthStatus& hs1, const XdsHealthStatus& hs2) {
+  return hs1.status() < hs2.status();
+}
+
+const char* XdsEndpointHealthStatusAttribute::kKey =
+    "xds_endpoint_health_status";
+
+int XdsEndpointHealthStatusAttribute::Cmp(
+    const AttributeInterface* other) const {
+  const auto* other_attr =
+      static_cast<const XdsEndpointHealthStatusAttribute*>(other);
+  return QsortCompare(status_, other_attr->status_);
+}
+
+std::string XdsEndpointHealthStatusAttribute::ToString() const {
+  return absl::StrCat("{status_=", status_.ToString(), "}");
+}
+
+}  // namespace grpc_core