grpc 1.60.0 → 1.61.0.pre2

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

@@ -56,6 +56,11 @@ extern TraceFlag grpc_xds_client_refcount_trace;
 
 class XdsClient : public DualRefCounted<XdsClient> {
  public:
+  class ReadDelayHandle : public RefCounted<ReadDelayHandle> {
+   public:
+    static RefCountedPtr<ReadDelayHandle> NoWait() { return nullptr; }
+  };
+
   // Resource watcher interface.  Implemented by callers.
   // Note: Most callers will not use this API directly but rather via a
   // resource-type-specific wrapper API provided by the relevant
@@ -63,11 +68,14 @@ class XdsClient : public DualRefCounted<XdsClient> {
   class ResourceWatcherInterface : public RefCounted<ResourceWatcherInterface> {
    public:
     virtual void OnGenericResourceChanged(
-        std::shared_ptr<const XdsResourceType::ResourceData> resource)
+        std::shared_ptr<const XdsResourceType::ResourceData> resource,
+        RefCountedPtr<ReadDelayHandle> read_delay_handle)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnError(absl::Status status)
+    virtual void OnError(absl::Status status,
+                         RefCountedPtr<ReadDelayHandle> read_delay_handle)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnResourceDoesNotExist()
+    virtual void OnResourceDoesNotExist(
+        RefCountedPtr<ReadDelayHandle> read_delay_handle)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
   };
 
@@ -171,23 +179,23 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
   // Contains a channel to the xds server and all the data related to the
   // channel.  Holds a ref to the xds client object.
-  class ChannelState : public DualRefCounted<ChannelState> {
+  class XdsChannel : public DualRefCounted<XdsChannel> {
    public:
     template <typename T>
     class RetryableCall;
 
-    class AdsCallState;
-    class LrsCallState;
+    class AdsCall;
+    class LrsCall;
 
-    ChannelState(WeakRefCountedPtr<XdsClient> xds_client,
-                 const XdsBootstrap::XdsServer& server);
-    ~ChannelState() override;
+    XdsChannel(WeakRefCountedPtr<XdsClient> xds_client,
+               const XdsBootstrap::XdsServer& server);
+    ~XdsChannel() override;
 
     void Orphan() override;
 
     XdsClient* xds_client() const { return xds_client_.get(); }
-    AdsCallState* ads_calld() const;
-    LrsCallState* lrs_calld() const;
+    AdsCall* ads_call() const;
+    LrsCall* lrs_call() const;
 
     void ResetBackoff();
 
@@ -223,9 +231,9 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
     bool shutting_down_ = false;
 
-    // The retryable XDS calls.
-    OrphanablePtr<RetryableCall<AdsCallState>> ads_calld_;
-    OrphanablePtr<RetryableCall<LrsCallState>> lrs_calld_;
+    // The retryable ADS and LRS calls.
+    OrphanablePtr<RetryableCall<AdsCall>> ads_call_;
+    OrphanablePtr<RetryableCall<LrsCall>> lrs_call_;
 
     // Stores the most recent accepted resource version for each resource type.
     std::map<const XdsResourceType*, std::string /*version*/>
@@ -244,7 +252,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
   };
 
   struct AuthorityState {
-    RefCountedPtr<ChannelState> channel_state;
+    RefCountedPtr<XdsChannel> xds_channel;
     std::map<const XdsResourceType*, std::map<XdsResourceKey, ResourceState>>
         resource_map;
   };
@@ -269,7 +277,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
       LoadReportState>;
 
   struct LoadReportServer {
-    RefCountedPtr<ChannelState> channel_state;
+    RefCountedPtr<XdsChannel> xds_channel;
     LoadReportMap load_report_map;
   };
 
@@ -277,11 +285,12 @@ class XdsClient : public DualRefCounted<XdsClient> {
   void NotifyWatchersOnErrorLocked(
       const std::map<ResourceWatcherInterface*,
                      RefCountedPtr<ResourceWatcherInterface>>& watchers,
-      absl::Status status);
+      absl::Status status, RefCountedPtr<ReadDelayHandle> read_delay_handle);
   // Sends a resource-does-not-exist notification to a specific set of watchers.
   void NotifyWatchersOnResourceDoesNotExist(
       const std::map<ResourceWatcherInterface*,
-                     RefCountedPtr<ResourceWatcherInterface>>& watchers);
+                     RefCountedPtr<ResourceWatcherInterface>>& watchers,
+      RefCountedPtr<ReadDelayHandle> read_delay_handle);
 
   void MaybeRegisterResourceTypeLocked(const XdsResourceType* resource_type)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
@@ -300,7 +309,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
       const XdsBootstrap::XdsServer& xds_server, bool send_all_clusters,
       const std::set<std::string>& clusters) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
-  RefCountedPtr<ChannelState> GetOrCreateChannelStateLocked(
+  RefCountedPtr<XdsChannel> GetOrCreateXdsChannelLocked(
       const XdsBootstrap::XdsServer& server, const char* reason)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
@@ -317,12 +326,12 @@ class XdsClient : public DualRefCounted<XdsClient> {
   // Stores resource type objects seen by type URL.
   std::map<absl::string_view /*resource_type*/, const XdsResourceType*>
       resource_types_ ABSL_GUARDED_BY(mu_);
-  upb::SymbolTable symtab_ ABSL_GUARDED_BY(mu_);
+  upb::DefPool def_pool_ ABSL_GUARDED_BY(mu_);
 
   // Map of existing xDS server channels.
   // Key is owned by the bootstrap config.
-  std::map<const XdsBootstrap::XdsServer*, ChannelState*>
-      xds_server_channel_map_ ABSL_GUARDED_BY(mu_);
+  std::map<const XdsBootstrap::XdsServer*, XdsChannel*> xds_server_channel_map_
+      ABSL_GUARDED_BY(mu_);
 
   std::map<std::string /*authority*/, AuthorityState> authority_state_map_
       ABSL_GUARDED_BY(mu_);

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

@@ -155,7 +155,9 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
   MutexLock lock(g_mu);
   if (g_xds_client != nullptr) {
     auto xds_client = g_xds_client->RefIfNonZero(DEBUG_LOCATION, reason);
-    if (xds_client != nullptr) return xds_client;
+    if (xds_client != nullptr) {
+      return xds_client.TakeAsSubclass<GrpcXdsClient>();
+    }
   }
   // Find bootstrap contents.
   auto bootstrap_contents = GetBootstrapContents(g_fallback_bootstrap_config);

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

@@ -38,13 +38,17 @@
 #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/core/v3/extension.upb.h"
 #include "envoy/config/core/v3/health_check.upb.h"
+#include "envoy/config/core/v3/protocol.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 "envoy/extensions/upstreams/http/v3/http_protocol_options.upb.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
+#include "google/protobuf/struct.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 #include "upb/base/string_view.h"
 #include "upb/text/encode.h"
@@ -105,17 +109,14 @@ std::string XdsClusterResource::ToString() const {
     contents.push_back(
         absl::StrCat("common_tls_context=", common_tls_context.ToString()));
   }
+  if (connection_idle_timeout != Duration::Zero()) {
+    contents.push_back(absl::StrCat("connection_idle_timeout=",
+                                    connection_idle_timeout.ToString()));
+  }
   contents.push_back(
       absl::StrCat("max_concurrent_requests=", max_concurrent_requests));
-  if (!override_host_statuses.empty()) {
-    std::vector<const char*> statuses;
-    statuses.reserve(override_host_statuses.size());
-    for (const auto& status : override_host_statuses) {
-      statuses.push_back(status.ToString());
-    }
-    contents.push_back(absl::StrCat("override_host_statuses={",
-                                    absl::StrJoin(statuses, ", "), "}"));
-  }
+  contents.push_back(absl::StrCat("override_host_statuses=",
+                                  override_host_statuses.ToString()));
   return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
 }
 
@@ -407,6 +408,50 @@ void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
   }
 }
 
+void ParseUpstreamConfig(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_core_v3_TypedExtensionConfig* upstream_config,
+    XdsClusterResource* cds_update, ValidationErrors* errors) {
+  ValidationErrors::ScopedField field(errors, ".typed_config");
+  const auto* typed_config =
+      envoy_config_core_v3_TypedExtensionConfig_typed_config(upstream_config);
+  auto extension = ExtractXdsExtension(context, typed_config, errors);
+  if (!extension.has_value()) return;
+  if (extension->type !=
+      "envoy.extensions.upstreams.http.v3.HttpProtocolOptions") {
+    ValidationErrors::ScopedField field(errors, ".type_url");
+    errors->AddError("unsupported upstream config type");
+    return;
+  }
+  absl::string_view* serialized_http_protocol_options =
+      absl::get_if<absl::string_view>(&extension->value);
+  if (serialized_http_protocol_options == nullptr) {
+    errors->AddError("can't decode HttpProtocolOptions");
+    return;
+  }
+  const auto* http_protocol_options =
+      envoy_extensions_upstreams_http_v3_HttpProtocolOptions_parse(
+          serialized_http_protocol_options->data(),
+          serialized_http_protocol_options->size(), context.arena);
+  if (http_protocol_options == nullptr) {
+    errors->AddError("can't decode HttpProtocolOptions");
+    return;
+  }
+  ValidationErrors::ScopedField field2(errors, ".common_http_protocol_options");
+  const auto* common_http_protocol_options =
+      envoy_extensions_upstreams_http_v3_HttpProtocolOptions_common_http_protocol_options(
+          http_protocol_options);
+  if (common_http_protocol_options != nullptr) {
+    const auto* idle_timeout =
+        envoy_config_core_v3_HttpProtocolOptions_idle_timeout(
+            common_http_protocol_options);
+    if (idle_timeout != nullptr) {
+      ValidationErrors::ScopedField field(errors, ".idle_timeout");
+      cds_update->connection_idle_timeout = ParseDuration(idle_timeout, errors);
+    }
+  }
+}
+
 absl::StatusOr<std::shared_ptr<const XdsClusterResource>> CdsResourceParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_cluster_v3_Cluster* cluster) {
@@ -474,6 +519,13 @@ absl::StatusOr<std::shared_ptr<const XdsClusterResource>> CdsResourceParse(
     cds_update->lrs_load_reporting_server.emplace(
         static_cast<const GrpcXdsBootstrap::GrpcXdsServer&>(context.server));
   }
+  // Protocol options.
+  auto* upstream_config =
+      envoy_config_cluster_v3_Cluster_upstream_config(cluster);
+  if (upstream_config != nullptr) {
+    ValidationErrors::ScopedField field(&errors, ".upstream_config");
+    ParseUpstreamConfig(context, upstream_config, cds_update.get(), &errors);
+  }
   // The Cluster resource encodes the circuit breaking parameters in a list of
   // Thresholds messages, where each message specifies the parameters for a
   // particular RoutingPriority. we will look only at the first entry in the
@@ -625,6 +677,7 @@ absl::StatusOr<std::shared_ptr<const XdsClusterResource>> CdsResourceParse(
   // Validate override host status.
   const auto* common_lb_config =
       envoy_config_cluster_v3_Cluster_common_lb_config(cluster);
+  bool override_host_status_found = false;
   if (common_lb_config != nullptr) {
     ValidationErrors::ScopedField field(&errors, ".common_lb_config");
     const auto* override_host_status =
@@ -638,9 +691,48 @@ absl::StatusOr<std::shared_ptr<const XdsClusterResource>> CdsResourceParse(
       for (size_t i = 0; i < size; ++i) {
         auto status = XdsHealthStatus::FromUpb(statuses[i]);
         if (status.has_value()) {
-          cds_update->override_host_statuses.insert(*status);
+          cds_update->override_host_statuses.Add(*status);
+        }
+      }
+      override_host_status_found = true;
+    }
+  }
+  // If the field is not set, we default to [UNKNOWN, HEALTHY].
+  if (!override_host_status_found) {
+    cds_update->override_host_statuses.Add(
+        XdsHealthStatus(XdsHealthStatus::kUnknown));
+    cds_update->override_host_statuses.Add(
+        XdsHealthStatus(XdsHealthStatus::kHealthy));
+  }
+  // Record telemetry labels (if any).
+  const envoy_config_core_v3_Metadata* metadata =
+      envoy_config_cluster_v3_Cluster_metadata(cluster);
+  if (metadata != nullptr) {
+    google_protobuf_Struct* telemetry_labels_struct;
+    if (envoy_config_core_v3_Metadata_filter_metadata_get(
+            metadata,
+            StdStringToUpbString(
+                absl::string_view("com.google.csm.telemetry_labels")),
+            &telemetry_labels_struct)) {
+      auto telemetry_labels =
+          std::make_shared<std::map<std::string, std::string>>();
+      size_t iter = kUpb_Map_Begin;
+      const google_protobuf_Struct_FieldsEntry* fields_entry;
+      while ((fields_entry = google_protobuf_Struct_fields_next(
+                  telemetry_labels_struct, &iter)) != nullptr) {
+        // Adds any entry whose value is a string to telemetry_labels.
+        const google_protobuf_Value* value =
+            google_protobuf_Struct_FieldsEntry_value(fields_entry);
+        if (google_protobuf_Value_has_string_value(value)) {
+          telemetry_labels->emplace(
+              UpbStringToStdString(
+                  google_protobuf_Struct_FieldsEntry_key(fields_entry)),
+              UpbStringToStdString(google_protobuf_Value_string_value(value)));
         }
       }
+      if (!telemetry_labels->empty()) {
+        cds_update->telemetry_labels = std::move(telemetry_labels);
+      }
     }
   }
   // Return result.
@@ -658,7 +750,8 @@ void MaybeLogCluster(const XdsResourceType::DecodeContext& context,
     const upb_MessageDef* msg_type =
         envoy_config_cluster_v3_Cluster_getmsgdef(context.symtab);
     char buf[10240];
-    upb_TextEncode(cluster, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(reinterpret_cast<const upb_Message*>(cluster), msg_type,
+                   nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] Cluster: %s", context.client, buf);
   }
 }

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

@@ -31,6 +31,7 @@
 #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 "envoy/extensions/upstreams/http/v3/http_protocol_options.upbdefs.h"
 #include "upb/reflection/def.h"
 
 #include <grpc/support/json.h>
@@ -89,18 +90,24 @@ struct XdsClusterResource : public XdsResourceType::ResourceData {
   // Tls Context used by clients
   CommonTlsContext common_tls_context;
 
+  // Connection idle timeout.  Currently used only for SSA.
+  Duration connection_idle_timeout = Duration::Hours(1);
+
   // Maximum number of outstanding requests can be made to the upstream
   // cluster.
   uint32_t max_concurrent_requests = 1024;
 
   absl::optional<OutlierDetectionConfig> outlier_detection;
 
-  std::set<XdsHealthStatus> override_host_statuses;
+  XdsHealthStatusSet override_host_statuses;
+
+  std::shared_ptr<std::map<std::string, std::string>> telemetry_labels;
 
   bool operator==(const XdsClusterResource& other) const {
     return type == other.type && lb_policy_config == other.lb_policy_config &&
            lrs_load_reporting_server == other.lrs_load_reporting_server &&
            common_tls_context == other.common_tls_context &&
+           connection_idle_timeout == other.connection_idle_timeout &&
            max_concurrent_requests == other.max_concurrent_requests &&
            outlier_detection == other.outlier_detection &&
            override_host_statuses == other.override_host_statuses;
@@ -126,6 +133,7 @@ class XdsClusterResourceType
     envoy_extensions_clusters_aggregate_v3_ClusterConfig_getmsgdef(symtab);
     envoy_extensions_transport_sockets_tls_v3_UpstreamTlsContext_getmsgdef(
         symtab);
+    envoy_extensions_upstreams_http_v3_HttpProtocolOptions_getmsgdef(symtab);
   }
 };
 

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

@@ -26,9 +26,9 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/variant.h"
-#include "upb/base/status.h"
+#include "upb/base/status.hpp"
 #include "upb/json/encode.h"
-#include "upb/upb.hpp"
+#include "upb/mem/arena.hpp"
 
 #include <grpc/support/json.h>
 #include <grpc/support/log.h>
@@ -70,8 +70,9 @@ Json XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
     errors->AddError("could not parse plugin config");
     return {};
   }
-  const auto* plugin_config =
-      grpc_lookup_v1_RouteLookupClusterSpecifier_route_lookup_config(specifier);
+  const auto* plugin_config = reinterpret_cast<const upb_Message*>(
+      grpc_lookup_v1_RouteLookupClusterSpecifier_route_lookup_config(
+          specifier));
   if (plugin_config == nullptr) {
     ValidationErrors::ScopedField field(errors, ".route_lookup_config");
     errors->AddError("field not present");
@@ -98,7 +99,10 @@ Json XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
             {"routeLookupConfig", std::move(*json)},
             {"childPolicy",
              Json::FromArray({
-                 Json::FromObject({{"cds_experimental", Json::FromObject({})}}),
+                 Json::FromObject({{"cds_experimental",
+                                    Json::FromObject({
+                                        {"isDynamic", Json::FromBool(true)},
+                                    })}}),
              })},
             {"childPolicyConfigTargetFieldName", Json::FromString("cluster")},
         })}})});

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

@@ -38,10 +38,9 @@
 #include "google/protobuf/struct.upb.h"
 #include "google/protobuf/struct.upbdefs.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "upb/base/status.h"
+#include "upb/base/status.hpp"
 #include "upb/json/encode.h"
 #include "upb/mem/arena.h"
-#include "upb/upb.hpp"
 #include "xds/type/v3/typed_struct.upb.h"
 
 #include <grpc/support/json.h>
@@ -385,13 +384,16 @@ CommonTlsContext CommonTlsContext::Parse(
           CertificateProviderInstanceParse(
               context, tls_certificate_certificate_provider_instance, errors);
     } else {
-      if (envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_has_tls_certificates(
-              common_tls_context_proto)) {
+      size_t size;
+      envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_tls_certificates(
+          common_tls_context_proto, &size);
+      if (size != 0) {
         ValidationErrors::ScopedField field(errors, ".tls_certificates");
         errors->AddError("feature unsupported");
       }
-      if (envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_has_tls_certificate_sds_secret_configs(
-              common_tls_context_proto)) {
+      envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_tls_certificate_sds_secret_configs(
+          common_tls_context_proto, &size);
+      if (size != 0) {
         ValidationErrors::ScopedField field(
             errors, ".tls_certificate_sds_secret_configs");
         errors->AddError("feature unsupported");
@@ -422,16 +424,18 @@ absl::StatusOr<Json> ParseProtobufStructToJson(
     const google_protobuf_Struct* resource) {
   upb::Status status;
   const auto* msg_def = google_protobuf_Struct_getmsgdef(context.symtab);
-  size_t json_size = upb_JsonEncode(resource, msg_def, context.symtab, 0,
-                                    nullptr, 0, status.ptr());
+  size_t json_size =
+      upb_JsonEncode(reinterpret_cast<const upb_Message*>(resource), msg_def,
+                     context.symtab, 0, nullptr, 0, status.ptr());
   if (json_size == static_cast<size_t>(-1)) {
     return absl::InvalidArgumentError(
         absl::StrCat("error encoding google::Protobuf::Struct as JSON: ",
                      upb_Status_ErrorMessage(status.ptr())));
   }
   void* buf = upb_Arena_Malloc(context.arena, json_size + 1);
-  upb_JsonEncode(resource, msg_def, context.symtab, 0,
-                 reinterpret_cast<char*>(buf), json_size + 1, status.ptr());
+  upb_JsonEncode(reinterpret_cast<const upb_Message*>(resource), msg_def,
+                 context.symtab, 0, reinterpret_cast<char*>(buf), json_size + 1,
+                 status.ptr());
   auto json = JsonParse(reinterpret_cast<char*>(buf));
   if (!json.ok()) {
     // This should never happen.

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

@@ -142,8 +142,9 @@ std::string XdsEndpointResource::ToString() const {
     priority_strings.emplace_back(
         absl::StrCat("priority ", i, ": ", priority.ToString()));
   }
-  return absl::StrCat("priorities=[", absl::StrJoin(priority_strings, ", "),
-                      "], drop_config=", drop_config->ToString());
+  return absl::StrCat(
+      "priorities=[", absl::StrJoin(priority_strings, ", "), "], drop_config=",
+      drop_config == nullptr ? "<null>" : drop_config->ToString());
 }
 
 //
@@ -161,7 +162,8 @@ void MaybeLogClusterLoadAssignment(
         envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(
             context.symtab);
     char buf[10240];
-    upb_TextEncode(cla, msg_type, nullptr, 0, buf, sizeof(buf));
+    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);
   }
@@ -447,7 +449,6 @@ absl::StatusOr<std::shared_ptr<const XdsEndpointResource>> EdsResourceParse(
     }
   }
   // policy
-  eds_resource->drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
   const auto* policy = envoy_config_endpoint_v3_ClusterLoadAssignment_policy(
       cluster_load_assignment);
   if (policy != nullptr) {
@@ -456,6 +457,10 @@ absl::StatusOr<std::shared_ptr<const XdsEndpointResource>> EdsResourceParse(
     const auto* const* drop_overload =
         envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_drop_overloads(
             policy, &drop_size);
+    if (drop_size > 0) {
+      eds_resource->drop_config =
+          MakeRefCounted<XdsEndpointResource::DropConfig>();
+    }
     for (size_t i = 0; i < drop_size; ++i) {
       ValidationErrors::ScopedField field(
           &errors, absl::StrCat(".drop_overloads[", i, "]"));

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

@@ -62,6 +62,7 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
     std::map<XdsLocalityName*, Locality, XdsLocalityName::Less> localities;
 
     bool operator==(const Priority& other) const;
+    bool operator!=(const Priority& other) const { return !(*this == other); }
     std::string ToString() const;
   };
   using PriorityList = std::vector<Priority>;
@@ -121,7 +122,10 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
   RefCountedPtr<DropConfig> drop_config;
 
   bool operator==(const XdsEndpointResource& other) const {
-    return priorities == other.priorities && *drop_config == *other.drop_config;
+    if (priorities != other.priorities) return false;
+    if (drop_config == nullptr) return other.drop_config == nullptr;
+    if (other.drop_config == nullptr) return false;
+    return *drop_config == *other.drop_config;
   }
   std::string ToString() const;
 };

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

@@ -20,6 +20,8 @@
 
 #include <string>
 
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 #include "envoy/config/core/v3/health_check.upb.h"
 
 namespace grpc_core {
@@ -58,8 +60,16 @@ const char* XdsHealthStatus::ToString() const {
   }
 }
 
-bool operator<(const XdsHealthStatus& hs1, const XdsHealthStatus& hs2) {
-  return hs1.status() < hs2.status();
+std::string XdsHealthStatusSet::ToString() const {
+  std::vector<const char*> set;
+  set.reserve(3);
+  for (const auto& status :
+       {XdsHealthStatus::kUnknown, XdsHealthStatus::kHealthy,
+        XdsHealthStatus::kDraining}) {
+    const XdsHealthStatus health_status(status);
+    if (Contains(health_status)) set.push_back(health_status.ToString());
+  }
+  return absl::StrCat("{", absl::StrJoin(set, ", "), "}");
 }
 
 }  // namespace grpc_core

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

@@ -70,6 +70,8 @@ class XdsHealthStatusSet {
     return status_mask_ == other.status_mask_;
   }
 
+  bool Empty() const { return status_mask_ == 0; }
+
   void Clear() { status_mask_ = 0; }
 
   void Add(XdsHealthStatus status) { status_mask_ |= (0x1 << status.status()); }
@@ -78,12 +80,12 @@ class XdsHealthStatusSet {
     return status_mask_ & (0x1 << status.status());
   }
 
+  std::string ToString() const;
+
  private:
   int status_mask_ = 0;
 };
 
-bool operator<(const XdsHealthStatus& hs1, const XdsHealthStatus& hs2);
-
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_XDS_XDS_HEALTH_STATUS_H

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

@@ -40,7 +40,7 @@
 #include "envoy/type/matcher/v3/string.upb.h"
 #include "envoy/type/v3/range.upb.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "upb/collections/map.h"
+#include "upb/message/map.h"
 
 #include <grpc/support/json.h>
 
@@ -486,8 +486,10 @@ Json ParseHttpRbacToJson(const XdsResourceType::DecodeContext& context,
           ValidationErrors::ScopedField field(errors, ".audit_condition");
           errors->AddError("invalid audit condition");
       }
-      if (envoy_config_rbac_v3_RBAC_AuditLoggingOptions_has_logger_configs(
-              audit_logging_options)) {
+      size_t size;
+      envoy_config_rbac_v3_RBAC_AuditLoggingOptions_logger_configs(
+          audit_logging_options, &size);
+      if (size != 0) {
         inner_rbac_json.emplace("audit_loggers",
                                 ParseAuditLoggerConfigsToJson(
                                     context, audit_logging_options, errors));

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

@@ -291,8 +291,9 @@ void MaybeLogHttpConnectionManager(
         envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_getmsgdef(
             context.symtab);
     char buf[10240];
-    upb_TextEncode(http_connection_manager_config, msg_type, nullptr, 0, buf,
-                   sizeof(buf));
+    upb_TextEncode(
+        reinterpret_cast<const upb_Message*>(http_connection_manager_config),
+        msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] HttpConnectionManager: %s",
             context.client, buf);
   }
@@ -332,11 +333,15 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
   }
   // original_ip_detection_extensions -- must be empty as per
   // https://github.com/grpc/proposal/blob/master/A41-xds-rbac.md
-  if (envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_has_original_ip_detection_extensions(
-          http_connection_manager_proto)) {
-    ValidationErrors::ScopedField field(errors,
-                                        ".original_ip_detection_extensions");
-    errors->AddError("must be empty");
+  {
+    size_t size;
+    envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_original_ip_detection_extensions(
+        http_connection_manager_proto, &size);
+    if (size != 0) {
+      ValidationErrors::ScopedField field(errors,
+                                          ".original_ip_detection_extensions");
+      errors->AddError("must be empty");
+    }
   }
   // common_http_protocol_options
   const envoy_config_core_v3_HttpProtocolOptions* options =
@@ -1091,7 +1096,8 @@ void MaybeLogListener(const XdsResourceType::DecodeContext& context,
     const upb_MessageDef* msg_type =
         envoy_config_listener_v3_Listener_getmsgdef(context.symtab);
     char buf[10240];
-    upb_TextEncode(listener, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(reinterpret_cast<const upb_Message*>(listener), msg_type,
+                   nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] Listener: %s", context.client, buf);
   }
 }

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

@@ -42,16 +42,18 @@ class XdsResourceTypeImpl : public XdsResourceType {
   class WatcherInterface : public XdsClient::ResourceWatcherInterface {
    public:
     virtual void OnResourceChanged(
-        std::shared_ptr<const ResourceType> resource) = 0;
+        std::shared_ptr<const ResourceType> resource,
+        RefCountedPtr<XdsClient::ReadDelayHandle> read_delay_handle) = 0;
 
    private:
     // Get result from XdsClient generic watcher interface, perform
     // down-casting, and invoke the caller's OnResourceChanged() method.
     void OnGenericResourceChanged(
-        std::shared_ptr<const XdsResourceType::ResourceData> resource)
-        override {
+        std::shared_ptr<const XdsResourceType::ResourceData> resource,
+        RefCountedPtr<XdsClient::ReadDelayHandle> read_delay_handle) override {
       OnResourceChanged(
-          std::static_pointer_cast<const ResourceType>(std::move(resource)));
+          std::static_pointer_cast<const ResourceType>(std::move(resource)),
+          std::move(read_delay_handle));
     }
   };