grpc 1.63.0 → 1.66.0

data/src/core/{ext/xds/xds_common_types.cc → xds/grpc/xds_common_types_parser.cc}

@@ -14,9 +14,7 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/xds/grpc/xds_common_types_parser.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ -44,11 +42,13 @@
 #include "xds/type/v3/typed_struct.upb.h"
 
 #include <grpc/support/json.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/ext/xds/upb_utils.h"
-#include "src/core/ext/xds/xds_bootstrap_grpc.h"
-#include "src/core/ext/xds/xds_client.h"
-#include "src/core/lib/json/json_reader.h"
+#include "src/core/lib/gprpp/env.h"
+#include "src/core/util/json/json_reader.h"
+#include "src/core/util/upb_utils.h"
+#include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/xds_client/xds_client.h"
 
 namespace grpc_core {
 
@@ -72,70 +72,19 @@ Duration ParseDuration(const google_protobuf_Duration* proto_duration,
 }
 
 //
-// CommonTlsContext::CertificateValidationContext
-//
-
-std::string CommonTlsContext::CertificateValidationContext::ToString() const {
-  std::vector<std::string> contents;
-  contents.reserve(match_subject_alt_names.size());
-  for (const auto& match : match_subject_alt_names) {
-    contents.push_back(match.ToString());
-  }
-  return absl::StrFormat("{match_subject_alt_names=[%s]}",
-                         absl::StrJoin(contents, ", "));
-}
-
-bool CommonTlsContext::CertificateValidationContext::Empty() const {
-  return match_subject_alt_names.empty();
-}
-
-//
-// CommonTlsContext::CertificateProviderPluginInstance
-//
-
-std::string CommonTlsContext::CertificateProviderPluginInstance::ToString()
-    const {
-  std::vector<std::string> contents;
-  if (!instance_name.empty()) {
-    contents.push_back(absl::StrFormat("instance_name=%s", instance_name));
-  }
-  if (!certificate_name.empty()) {
-    contents.push_back(
-        absl::StrFormat("certificate_name=%s", certificate_name));
-  }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
-}
-
-bool CommonTlsContext::CertificateProviderPluginInstance::Empty() const {
-  return instance_name.empty() && certificate_name.empty();
-}
-
-//
-// CommonTlsContext
+// CommonTlsContextParse()
 //
 
-std::string CommonTlsContext::ToString() const {
-  std::vector<std::string> contents;
-  if (!tls_certificate_provider_instance.Empty()) {
-    contents.push_back(
-        absl::StrFormat("tls_certificate_provider_instance=%s",
-                        tls_certificate_provider_instance.ToString()));
-  }
-  if (!certificate_validation_context.Empty()) {
-    contents.push_back(
-        absl::StrFormat("certificate_validation_context=%s",
-                        certificate_validation_context.ToString()));
-  }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
-}
+namespace {
 
-bool CommonTlsContext::Empty() const {
-  return tls_certificate_provider_instance.Empty() &&
-         certificate_validation_context.Empty();
+bool XdsSystemRootCertsEnabled() {
+  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_SYSTEM_ROOT_CERTS");
+  if (!value.has_value()) return false;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
 }
 
-namespace {
-
 // CertificateProviderInstance is deprecated but we are still supporting it for
 // backward compatibility reasons. Note that we still parse the data into the
 // same CertificateProviderPluginInstance struct since the fields are the same.
@@ -262,9 +211,17 @@ CertificateValidationContextParse(
   if (ca_certificate_provider_instance != nullptr) {
     ValidationErrors::ScopedField field(errors,
                                         ".ca_certificate_provider_instance");
-    certificate_validation_context.ca_certificate_provider_instance =
+    certificate_validation_context.ca_certs =
         CertificateProviderPluginInstanceParse(
             context, ca_certificate_provider_instance, errors);
+  } else if (XdsSystemRootCertsEnabled()) {
+    auto* system_root_certs =
+        envoy_extensions_transport_sockets_tls_v3_CertificateValidationContext_system_root_certs(
+            certificate_validation_context_proto);
+    if (system_root_certs != nullptr) {
+      certificate_validation_context.ca_certs =
+          CommonTlsContext::CertificateValidationContext::SystemRootCerts();
+    }
   }
   if (envoy_extensions_transport_sockets_tls_v3_CertificateValidationContext_verify_certificate_spki(
           certificate_validation_context_proto, nullptr) != nullptr) {
@@ -276,11 +233,9 @@ CertificateValidationContextParse(
     ValidationErrors::ScopedField field(errors, ".verify_certificate_hash");
     errors->AddError("feature unsupported");
   }
-  auto* require_signed_certificate_timestamp =
-      envoy_extensions_transport_sockets_tls_v3_CertificateValidationContext_require_signed_certificate_timestamp(
-          certificate_validation_context_proto);
-  if (require_signed_certificate_timestamp != nullptr &&
-      google_protobuf_BoolValue_value(require_signed_certificate_timestamp)) {
+  if (ParseBoolValue(
+          envoy_extensions_transport_sockets_tls_v3_CertificateValidationContext_require_signed_certificate_timestamp(
+              certificate_validation_context_proto))) {
     ValidationErrors::ScopedField field(
         errors, ".require_signed_certificate_timestamp");
     errors->AddError("feature unsupported");
@@ -300,7 +255,7 @@ CertificateValidationContextParse(
 
 }  // namespace
 
-CommonTlsContext CommonTlsContext::Parse(
+CommonTlsContext CommonTlsContextParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_extensions_transport_sockets_tls_v3_CommonTlsContext*
         common_tls_context_proto,
@@ -325,23 +280,26 @@ CommonTlsContext CommonTlsContext::Parse(
                                             errors);
     }
     // If after parsing default_validation_context,
-    // common_tls_context->certificate_validation_context.ca_certificate_provider_instance
-    // is empty, fall back onto
+    // common_tls_context->certificate_validation_context.ca_certs does not
+    // contain a cert provider, fall back onto
     // 'validation_context_certificate_provider_instance' inside
     // 'combined_validation_context'. Note that this way of fetching root
     // certificates is deprecated and will be removed in the future.
     // TODO(yashykt): Remove this once it's no longer needed.
-    const auto* validation_context_certificate_provider_instance =
-        envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_CombinedCertificateValidationContext_validation_context_certificate_provider_instance(
-            combined_validation_context);
-    if (common_tls_context.certificate_validation_context
-            .ca_certificate_provider_instance.Empty() &&
-        validation_context_certificate_provider_instance != nullptr) {
-      ValidationErrors::ScopedField field(
-          errors, ".validation_context_certificate_provider_instance");
-      common_tls_context.certificate_validation_context
-          .ca_certificate_provider_instance = CertificateProviderInstanceParse(
-          context, validation_context_certificate_provider_instance, errors);
+    if (!absl::holds_alternative<
+            CommonTlsContext::CertificateProviderPluginInstance>(
+            common_tls_context.certificate_validation_context.ca_certs)) {
+      const auto* validation_context_certificate_provider_instance =
+          envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_CombinedCertificateValidationContext_validation_context_certificate_provider_instance(
+              combined_validation_context);
+      if (validation_context_certificate_provider_instance != nullptr) {
+        ValidationErrors::ScopedField field(
+            errors, ".validation_context_certificate_provider_instance");
+        common_tls_context.certificate_validation_context.ca_certs =
+            CertificateProviderInstanceParse(
+                context, validation_context_certificate_provider_instance,
+                errors);
+      }
     }
   } else {
     auto* validation_context =

data/src/core/xds/grpc/xds_common_types_parser.h

@@ -0,0 +1,54 @@
+//
+// Copyright 2018 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_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_PARSER_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_PARSER_H
+
+#include "absl/types/optional.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 "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/xds/grpc/xds_common_types.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
+
+namespace grpc_core {
+
+Duration ParseDuration(const google_protobuf_Duration* proto_duration,
+                       ValidationErrors* errors);
+
+inline bool ParseBoolValue(const google_protobuf_BoolValue* bool_value_proto,
+                           bool default_value = false) {
+  if (bool_value_proto == nullptr) return default_value;
+  return google_protobuf_BoolValue_value(bool_value_proto);
+}
+
+CommonTlsContext CommonTlsContextParse(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_extensions_transport_sockets_tls_v3_CommonTlsContext*
+        common_tls_context_proto,
+    ValidationErrors* errors);
+
+absl::optional<XdsExtension> ExtractXdsExtension(
+    const XdsResourceType::DecodeContext& context,
+    const google_protobuf_Any* any, ValidationErrors* errors);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_PARSER_H

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

@@ -0,0 +1,97 @@
+//
+// Copyright 2018 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 "src/core/xds/grpc/xds_endpoint.h"
+
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+
+namespace grpc_core {
+
+std::string XdsEndpointResource::Priority::Locality::ToString() const {
+  std::vector<std::string> endpoint_strings;
+  for (const EndpointAddresses& endpoint : endpoints) {
+    endpoint_strings.emplace_back(endpoint.ToString());
+  }
+  return absl::StrCat("{name=", name->human_readable_string().as_string_view(),
+                      ", lb_weight=", lb_weight, ", endpoints=[",
+                      absl::StrJoin(endpoint_strings, ", "), "]}");
+}
+
+bool XdsEndpointResource::Priority::operator==(const Priority& other) const {
+  if (localities.size() != other.localities.size()) return false;
+  auto it1 = localities.begin();
+  auto it2 = other.localities.begin();
+  while (it1 != localities.end()) {
+    if (*it1->first != *it2->first) return false;
+    if (it1->second != it2->second) return false;
+    ++it1;
+    ++it2;
+  }
+  return true;
+}
+
+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());
+  }
+  return absl::StrCat("[", absl::StrJoin(locality_strings, ", "), "]");
+}
+
+bool XdsEndpointResource::DropConfig::ShouldDrop(
+    const std::string** category_name) {
+  for (size_t i = 0; i < drop_category_list_.size(); ++i) {
+    const auto& drop_category = drop_category_list_[i];
+    // Generate a random number in [0, 1000000).
+    const uint32_t random = [&]() {
+      MutexLock lock(&mu_);
+      return absl::Uniform<uint32_t>(bit_gen_, 0, 1000000);
+    }();
+    if (random < drop_category.parts_per_million) {
+      *category_name = &drop_category.name;
+      return true;
+    }
+  }
+  return false;
+}
+
+std::string XdsEndpointResource::DropConfig::ToString() const {
+  std::vector<std::string> category_strings;
+  for (const DropCategory& category : drop_category_list_) {
+    category_strings.emplace_back(
+        absl::StrCat(category.name, "=", category.parts_per_million));
+  }
+  return absl::StrCat("{[", absl::StrJoin(category_strings, ", "),
+                      "], drop_all=", drop_all_, "}");
+}
+
+std::string XdsEndpointResource::ToString() const {
+  std::vector<std::string> priority_strings;
+  for (size_t i = 0; i < priorities.size(); ++i) {
+    const Priority& priority = priorities[i];
+    priority_strings.emplace_back(
+        absl::StrCat("priority ", i, ": ", priority.ToString()));
+  }
+  return absl::StrCat(
+      "priorities=[", absl::StrJoin(priority_strings, ", "), "], drop_config=",
+      drop_config == nullptr ? "<null>" : drop_config->ToString());
+}
+
+}  // namespace grpc_core

data/src/core/{ext/xds → xds/grpc}/xds_endpoint.h

@@ -14,14 +14,9 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_ENDPOINT_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_ENDPOINT_H
+#ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_ENDPOINT_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_ENDPOINT_H
 
-#include <grpc/support/port_platform.h>
-
-#include <stdint.h>
-
-#include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
@@ -29,18 +24,14 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/random/random.h"
-#include "absl/strings/string_view.h"
-#include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
-#include "upb/reflection/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"
+
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/resolver/endpoint_addresses.h"
+#include "src/core/xds/xds_client/xds_client_stats.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
+#include "src/core/xds/xds_client/xds_resource_type_impl.h"
 
 namespace grpc_core {
 
@@ -130,21 +121,6 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
   std::string ToString() const;
 };
 
-class XdsEndpointResourceType final
-    : public XdsResourceTypeImpl<XdsEndpointResourceType, XdsEndpointResource> {
- public:
-  absl::string_view type_url() const override {
-    return "envoy.config.endpoint.v3.ClusterLoadAssignment";
-  }
-
-  DecodeResult Decode(const XdsResourceType::DecodeContext& context,
-                      absl::string_view serialized_resource) const override;
-
-  void InitUpbSymtab(XdsClient*, upb_DefPool* symtab) const override {
-    envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(symtab);
-  }
-};
-
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_ENDPOINT_H
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_ENDPOINT_H

data/src/core/{ext/xds/xds_endpoint.cc → xds/grpc/xds_endpoint_parser.cc}

@@ -14,9 +14,7 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/xds/xds_endpoint.h"
+#include "src/core/xds/grpc/xds_endpoint_parser.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -27,6 +25,8 @@
 #include <set>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -41,19 +41,19 @@
 #include "google/protobuf/wrappers.upb.h"
 #include "upb/text/encode.h"
 
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/ext/xds/upb_utils.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/gpr/string.h"
 #include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/util/string.h"
+#include "src/core/util/upb_utils.h"
+#include "src/core/xds/grpc/xds_health_status.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
 
 // IWYU pragma: no_include "absl/meta/type_traits.h"
 
@@ -70,102 +70,18 @@ bool XdsDualstackEndpointsEnabled() {
   return parse_succeeded && parsed_value;
 }
 
-}  // namespace
-
-//
-// XdsEndpointResource
-//
-
-std::string XdsEndpointResource::Priority::Locality::ToString() const {
-  std::vector<std::string> endpoint_strings;
-  for (const EndpointAddresses& endpoint : endpoints) {
-    endpoint_strings.emplace_back(endpoint.ToString());
-  }
-  return absl::StrCat("{name=", name->human_readable_string().as_string_view(),
-                      ", lb_weight=", lb_weight, ", endpoints=[",
-                      absl::StrJoin(endpoint_strings, ", "), "]}");
-}
-
-bool XdsEndpointResource::Priority::operator==(const Priority& other) const {
-  if (localities.size() != other.localities.size()) return false;
-  auto it1 = localities.begin();
-  auto it2 = other.localities.begin();
-  while (it1 != localities.end()) {
-    if (*it1->first != *it2->first) return false;
-    if (it1->second != it2->second) return false;
-    ++it1;
-    ++it2;
-  }
-  return true;
-}
-
-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());
-  }
-  return absl::StrCat("[", absl::StrJoin(locality_strings, ", "), "]");
-}
-
-bool XdsEndpointResource::DropConfig::ShouldDrop(
-    const std::string** category_name) {
-  for (size_t i = 0; i < drop_category_list_.size(); ++i) {
-    const auto& drop_category = drop_category_list_[i];
-    // Generate a random number in [0, 1000000).
-    const uint32_t random = [&]() {
-      MutexLock lock(&mu_);
-      return absl::Uniform<uint32_t>(bit_gen_, 0, 1000000);
-    }();
-    if (random < drop_category.parts_per_million) {
-      *category_name = &drop_category.name;
-      return true;
-    }
-  }
-  return false;
-}
-
-std::string XdsEndpointResource::DropConfig::ToString() const {
-  std::vector<std::string> category_strings;
-  for (const DropCategory& category : drop_category_list_) {
-    category_strings.emplace_back(
-        absl::StrCat(category.name, "=", category.parts_per_million));
-  }
-  return absl::StrCat("{[", absl::StrJoin(category_strings, ", "),
-                      "], drop_all=", drop_all_, "}");
-}
-
-std::string XdsEndpointResource::ToString() const {
-  std::vector<std::string> priority_strings;
-  for (size_t i = 0; i < priorities.size(); ++i) {
-    const Priority& priority = priorities[i];
-    priority_strings.emplace_back(
-        absl::StrCat("priority ", i, ": ", priority.ToString()));
-  }
-  return absl::StrCat(
-      "priorities=[", absl::StrJoin(priority_strings, ", "), "], drop_config=",
-      drop_config == nullptr ? "<null>" : drop_config->ToString());
-}
-
-//
-// XdsEndpointResourceType
-//
-
-namespace {
-
 void MaybeLogClusterLoadAssignment(
     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)) {
+  if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer) && ABSL_VLOG_IS_ON(2)) {
     const upb_MessageDef* msg_type =
         envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(
             context.symtab);
     char buf[10240];
     upb_TextEncode(reinterpret_cast<const upb_Message*>(cla), msg_type, nullptr,
                    0, buf, sizeof(buf));
-    gpr_log(GPR_DEBUG, "[xds_client %p] ClusterLoadAssignment: %s",
-            context.client, buf);
+    VLOG(2) << "[xds_client " << context.client
+            << "] ClusterLoadAssignment: " << buf;
   }
 }
 
@@ -224,6 +140,7 @@ absl::optional<EndpointAddresses> EndpointAddressesParse(
   }
   // endpoint
   std::vector<grpc_resolved_address> addresses;
+  absl::string_view hostname;
   {
     ValidationErrors::ScopedField field(errors, ".endpoint");
     const envoy_config_endpoint_v3_Endpoint* endpoint =
@@ -253,13 +170,18 @@ absl::optional<EndpointAddresses> EndpointAddressesParse(
         if (address.has_value()) addresses.push_back(*address);
       }
     }
+    hostname =
+        UpbStringToAbsl(envoy_config_endpoint_v3_Endpoint_hostname(endpoint));
   }
   if (addresses.empty()) return absl::nullopt;
   // Convert to EndpointAddresses.
-  return EndpointAddresses(
-      addresses, ChannelArgs()
-                     .Set(GRPC_ARG_ADDRESS_WEIGHT, weight)
-                     .Set(GRPC_ARG_XDS_HEALTH_STATUS, status->status()));
+  auto args = ChannelArgs()
+                  .Set(GRPC_ARG_ADDRESS_WEIGHT, weight)
+                  .Set(GRPC_ARG_XDS_HEALTH_STATUS, status->status());
+  if (!hostname.empty()) {
+    args = args.Set(GRPC_ARG_ADDRESS_NAME, hostname);
+  }
+  return EndpointAddresses(addresses, args);
 }
 
 struct ParsedLocality {
@@ -408,7 +330,7 @@ absl::StatusOr<std::shared_ptr<const XdsEndpointResource>> EdsResourceParse(
       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);
+        CHECK_NE(parsed_locality->locality.lb_weight, 0u);
         // Make sure prorities is big enough. Note that they might not
         // arrive in priority order.
         if (eds_resource->priorities.size() < parsed_locality->priority + 1) {
@@ -497,17 +419,17 @@ XdsResourceType::DecodeResult XdsEndpointResourceType::Decode(
       envoy_config_endpoint_v3_ClusterLoadAssignment_cluster_name(resource));
   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",
-              context.client, result.name->c_str(),
-              eds_resource.status().ToString().c_str());
+    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+      LOG(ERROR) << "[xds_client " << context.client
+                 << "] invalid ClusterLoadAssignment " << *result.name << ": "
+                 << eds_resource.status();
     }
     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(),
-              (*eds_resource)->ToString().c_str());
+    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+      LOG(INFO) << "[xds_client " << context.client
+                << "] parsed ClusterLoadAssignment " << *result.name << ": "
+                << (*eds_resource)->ToString();
     }
     result.resource = std::move(*eds_resource);
   }

data/src/core/xds/grpc/xds_endpoint_parser.h

@@ -0,0 +1,48 @@
+//
+// Copyright 2018 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_SRC_CORE_XDS_GRPC_XDS_ENDPOINT_PARSER_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_ENDPOINT_PARSER_H
+
+#include "absl/strings/string_view.h"
+#include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
+#include "upb/reflection/def.h"
+
+#include "src/core/xds/grpc/xds_endpoint.h"
+#include "src/core/xds/xds_client/xds_client.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
+#include "src/core/xds/xds_client/xds_resource_type_impl.h"
+
+namespace grpc_core {
+
+class XdsEndpointResourceType final
+    : public XdsResourceTypeImpl<XdsEndpointResourceType, XdsEndpointResource> {
+ public:
+  absl::string_view type_url() const override {
+    return "envoy.config.endpoint.v3.ClusterLoadAssignment";
+  }
+
+  DecodeResult Decode(const XdsResourceType::DecodeContext& context,
+                      absl::string_view serialized_resource) const override;
+
+  void InitUpbSymtab(XdsClient*, upb_DefPool* symtab) const override {
+    envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(symtab);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_ENDPOINT_PARSER_H