grpc 1.60.0 → 1.62.0

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

@@ -31,11 +31,11 @@
 #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>
 
-#include "src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
@@ -44,6 +44,7 @@
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/load_balancing/outlier_detection/outlier_detection.h"
 
 namespace grpc_core {
 
@@ -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

@@ -40,7 +40,7 @@
 #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/lib/resolver/endpoint_addresses.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
@@ -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

@@ -25,7 +25,7 @@
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 
-#include "src/core/lib/resolver/endpoint_addresses.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 // Channel arg key for xDS health status.
 // Value is an XdsHealthStatus::HealthStatus enum.
@@ -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_lb_policy_registry.cc

@@ -40,7 +40,7 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/load_balancing/lb_policy_registry.h"
+#include "src/core/load_balancing/lb_policy_registry.h"
 
 namespace grpc_core {
 

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));
     }
   };
 

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

@@ -52,7 +52,7 @@
 #include "google/protobuf/wrappers.upb.h"
 #include "re2/re2.h"
 #include "upb/base/string_view.h"
-#include "upb/collections/map.h"
+#include "upb/message/map.h"
 #include "upb/text/encode.h"
 
 #include <grpc/status.h>
@@ -74,8 +74,8 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_writer.h"
-#include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/core/lib/matchers/matchers.h"
+#include "src/core/load_balancing/lb_policy_registry.h"
 
 namespace grpc_core {
 
@@ -288,33 +288,44 @@ std::string XdsRouteConfigResource::Route::ToString() const {
   return absl::StrJoin(contents, "\n");
 }
 
+//
+// XdsRouteConfigResource::Route
+//
+
+std::string XdsRouteConfigResource::VirtualHost::ToString() const {
+  std::vector<std::string> parts;
+  parts.push_back(
+      absl::StrCat("vhost={\n"
+                   "  domains=[",
+                   absl::StrJoin(domains, ", "),
+                   "]\n"
+                   "  routes=[\n"));
+  for (const XdsRouteConfigResource::Route& route : routes) {
+    parts.push_back("    {\n");
+    parts.push_back(route.ToString());
+    parts.push_back("\n    }\n");
+  }
+  parts.push_back("  ]\n");
+  parts.push_back("  typed_per_filter_config={\n");
+  for (const auto& p : typed_per_filter_config) {
+    const std::string& name = p.first;
+    const auto& config = p.second;
+    parts.push_back(absl::StrCat("    ", name, "=", config.ToString(), "\n"));
+  }
+  parts.push_back("  }\n");
+  parts.push_back("}\n");
+  return absl::StrJoin(parts, "");
+}
+
 //
 // XdsRouteConfigResource
 //
 
 std::string XdsRouteConfigResource::ToString() const {
   std::vector<std::string> parts;
+  parts.reserve(virtual_hosts.size());
   for (const VirtualHost& vhost : virtual_hosts) {
-    parts.push_back(
-        absl::StrCat("vhost={\n"
-                     "  domains=[",
-                     absl::StrJoin(vhost.domains, ", "),
-                     "]\n"
-                     "  routes=[\n"));
-    for (const XdsRouteConfigResource::Route& route : vhost.routes) {
-      parts.push_back("    {\n");
-      parts.push_back(route.ToString());
-      parts.push_back("\n    }\n");
-    }
-    parts.push_back("  ]\n");
-    parts.push_back("  typed_per_filter_config={\n");
-    for (const auto& p : vhost.typed_per_filter_config) {
-      const std::string& name = p.first;
-      const auto& config = p.second;
-      parts.push_back(absl::StrCat("    ", name, "=", config.ToString(), "\n"));
-    }
-    parts.push_back("  }\n");
-    parts.push_back("]\n");
+    parts.push_back(vhost.ToString());
   }
   parts.push_back("cluster_specifier_plugins={\n");
   for (const auto& it : cluster_specifier_plugin_map) {
@@ -1137,7 +1148,8 @@ void MaybeLogRouteConfiguration(
     const upb_MessageDef* msg_type =
         envoy_config_route_v3_RouteConfiguration_getmsgdef(context.symtab);
     char buf[10240];
-    upb_TextEncode(route_config, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(reinterpret_cast<const upb_Message*>(route_config), msg_type,
+                   nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] RouteConfiguration: %s", context.client,
             buf);
   }

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

@@ -209,6 +209,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
       return domains == other.domains && routes == other.routes &&
              typed_per_filter_config == other.typed_per_filter_config;
     }
+    std::string ToString() const;
   };
 
   std::vector<VirtualHost> virtual_hosts;