grpc 1.51.0 → 1.52.0.pre2

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

@@ -21,15 +21,15 @@
 
 #include <map>
 #include <memory>
-#include <string>
 #include <utility>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "upb/arena.h"
 #include "upb/def.h"
 
 #include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/json/json.h"
 
 namespace grpc_core {
 
@@ -37,21 +37,27 @@ class XdsClusterSpecifierPluginImpl {
  public:
   virtual ~XdsClusterSpecifierPluginImpl() = default;
 
+  // Returns the config proto message name.
+  virtual absl::string_view ConfigProtoName() const = 0;
+
   // Loads the proto message into the upb symtab.
   virtual void PopulateSymtab(upb_DefPool* symtab) const = 0;
 
   // Returns the LB policy config in JSON form.
-  virtual absl::StatusOr<std::string> GenerateLoadBalancingPolicyConfig(
-      XdsExtension extension, upb_Arena* arena, upb_DefPool* symtab) const = 0;
+  virtual Json GenerateLoadBalancingPolicyConfig(
+      XdsExtension extension, upb_Arena* arena, upb_DefPool* symtab,
+      ValidationErrors* errors) const = 0;
 };
 
 class XdsRouteLookupClusterSpecifierPlugin
     : public XdsClusterSpecifierPluginImpl {
+  absl::string_view ConfigProtoName() const override;
+
   void PopulateSymtab(upb_DefPool* symtab) const override;
 
-  absl::StatusOr<std::string> GenerateLoadBalancingPolicyConfig(
-      XdsExtension extension, upb_Arena* arena,
-      upb_DefPool* symtab) const override;
+  Json GenerateLoadBalancingPolicyConfig(
+      XdsExtension extension, upb_Arena* arena, upb_DefPool* symtab,
+      ValidationErrors* errors) const override;
 };
 
 class XdsClusterSpecifierPluginRegistry {
@@ -74,8 +80,7 @@ class XdsClusterSpecifierPluginRegistry {
     return *this;
   }
 
-  void RegisterPlugin(std::unique_ptr<XdsClusterSpecifierPluginImpl> plugin,
-                      absl::string_view config_proto_type_name);
+  void RegisterPlugin(std::unique_ptr<XdsClusterSpecifierPluginImpl> plugin);
 
   void PopulateSymtab(upb_DefPool* symtab) const;
 

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

@@ -454,7 +454,7 @@ absl::optional<XdsExtension> ExtractXdsExtension(
     ValidationErrors::ScopedField field(errors, ".type_url");
     if (extension.type.empty()) {
       errors->AddError("field not present");
-      return;
+      return false;
     }
     size_t pos = extension.type.rfind('/');
     if (pos == absl::string_view::npos || pos == extension.type.size() - 1) {
@@ -462,9 +462,10 @@ absl::optional<XdsExtension> ExtractXdsExtension(
     } else {
       extension.type = extension.type.substr(pos + 1);
     }
+    return true;
   };
   extension.type = UpbStringToAbsl(google_protobuf_Any_type_url(any));
-  strip_type_prefix();
+  if (!strip_type_prefix()) return absl::nullopt;
   extension.validation_fields.emplace_back(
       errors, absl::StrCat(".value[", extension.type, "]"));
   absl::string_view any_value = UpbStringToAbsl(google_protobuf_Any_value(any));
@@ -478,7 +479,7 @@ absl::optional<XdsExtension> ExtractXdsExtension(
     }
     extension.type =
         UpbStringToAbsl(xds_type_v3_TypedStruct_type_url(typed_struct));
-    strip_type_prefix();
+    if (!strip_type_prefix()) return absl::nullopt;
     extension.validation_fields.emplace_back(
         errors, absl::StrCat(".value[", extension.type, "]"));
     auto* protobuf_struct = xds_type_v3_TypedStruct_value(typed_struct);

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

@@ -44,6 +44,8 @@
 #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"
@@ -150,13 +152,15 @@ absl::optional<ServerAddress> ServerAddressParse(
     const envoy_config_endpoint_v3_LbEndpoint* lb_endpoint,
     ValidationErrors* errors) {
   // health_status
-  // If not HEALTHY or UNKNOWN, skip this endpoint.
   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;
   }
+  auto status = XdsHealthStatus::FromUpb(health_status);
+  if (!status.has_value()) return absl::nullopt;
   // load_balancing_weight
   uint32_t weight = 1;
   {
@@ -217,6 +221,8 @@ absl::optional<ServerAddress> ServerAddressParse(
       attributes;
   attributes[ServerAddressWeightAttribute::kServerAddressWeightAttributeKey] =
       std::make_unique<ServerAddressWeightAttribute>(weight);
+  attributes[XdsEndpointHealthStatusAttribute::kKey] =
+      std::make_unique<XdsEndpointHealthStatusAttribute>(*status);
   return ServerAddress(grpc_address, ChannelArgs(), std::move(attributes));
 }
 

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

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

@@ -0,0 +1,82 @@
+//
+// 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.
+//
+
+#ifndef GRPC_CORE_EXT_XDS_XDS_HEALTH_STATUS_H
+#define GRPC_CORE_EXT_XDS_XDS_HEALTH_STATUS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/resolver/server_address.h"
+
+namespace grpc_core {
+
+class XdsHealthStatus {
+ public:
+  enum HealthStatus { kUnknown, kHealthy, kDraining };
+
+  // Returns an XdsHealthStatus for supported enum values, else nullopt.
+  static absl::optional<XdsHealthStatus> FromUpb(uint32_t status);
+  static absl::optional<XdsHealthStatus> FromString(absl::string_view status);
+
+  explicit XdsHealthStatus(HealthStatus status) : status_(status) {}
+
+  HealthStatus status() const { return status_; }
+
+  bool operator==(const XdsHealthStatus& other) const {
+    return status_ == other.status_;
+  }
+
+  const char* ToString() const;
+
+ private:
+  HealthStatus status_;
+};
+
+bool operator<(const XdsHealthStatus& hs1, const XdsHealthStatus& hs2);
+
+class XdsEndpointHealthStatusAttribute
+    : public ServerAddress::AttributeInterface {
+ public:
+  static const char* kKey;
+
+  explicit XdsEndpointHealthStatusAttribute(XdsHealthStatus status)
+      : status_(status) {}
+
+  XdsHealthStatus status() const { return status_; }
+
+  std::unique_ptr<AttributeInterface> Copy() const override {
+    return std::make_unique<XdsEndpointHealthStatusAttribute>(status_);
+  }
+
+  int Cmp(const AttributeInterface* other) const override;
+
+  std::string ToString() const override;
+
+ private:
+  XdsHealthStatus status_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_HEALTH_STATUS_H

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

@@ -85,9 +85,9 @@ void XdsHttpFaultFilter::PopulateSymtab(upb_DefPool* symtab) const {
 }
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
-XdsHttpFaultFilter::GenerateFilterConfig(XdsExtension extension,
-                                         upb_Arena* arena,
-                                         ValidationErrors* errors) const {
+XdsHttpFaultFilter::GenerateFilterConfig(
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
       absl::get_if<absl::string_view>(&extension.value);
   if (serialized_filter_config == nullptr) {
@@ -96,7 +96,7 @@ XdsHttpFaultFilter::GenerateFilterConfig(XdsExtension extension,
   }
   auto* http_fault = envoy_extensions_filters_http_fault_v3_HTTPFault_parse(
       serialized_filter_config->data(), serialized_filter_config->size(),
-      arena);
+      context.arena);
   if (http_fault == nullptr) {
     errors->AddError("could not parse fault injection filter config");
     return absl::nullopt;
@@ -206,10 +206,11 @@ XdsHttpFaultFilter::GenerateFilterConfig(XdsExtension extension,
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpFaultFilter::GenerateFilterConfigOverride(
-    XdsExtension extension, upb_Arena* arena, ValidationErrors* errors) const {
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) const {
   // HTTPFault filter has the same message type in HTTP connection manager's
   // filter config and in overriding filter config field.
-  return GenerateFilterConfig(std::move(extension), arena, errors);
+  return GenerateFilterConfig(context, std::move(extension), errors);
 }
 
 const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {

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

@@ -22,11 +22,11 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "upb/arena.h"
 #include "upb/def.h"
 
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/gprpp/validation_errors.h"
@@ -39,10 +39,10 @@ class XdsHttpFaultFilter : public XdsHttpFilterImpl {
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
   absl::optional<FilterConfig> GenerateFilterConfig(
-      XdsExtension extension, upb_Arena* arena,
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   absl::optional<FilterConfig> GenerateFilterConfigOverride(
-      XdsExtension extension, upb_Arena* arena,
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   const grpc_channel_filter* channel_filter() const override;
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;

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

@@ -29,8 +29,10 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/ext/xds/xds_cluster.h"
 #include "src/core/ext/xds/xds_http_fault_filter.h"
 #include "src/core/ext/xds/xds_http_rbac_filter.h"
+#include "src/core/ext/xds/xds_http_stateful_session_filter.h"
 
 namespace grpc_core {
 
@@ -51,9 +53,9 @@ void XdsHttpRouterFilter::PopulateSymtab(upb_DefPool* symtab) const {
 }
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
-XdsHttpRouterFilter::GenerateFilterConfig(XdsExtension extension,
-                                          upb_Arena* arena,
-                                          ValidationErrors* errors) const {
+XdsHttpRouterFilter::GenerateFilterConfig(
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
       absl::get_if<absl::string_view>(&extension.value);
   if (serialized_filter_config == nullptr) {
@@ -62,7 +64,7 @@ XdsHttpRouterFilter::GenerateFilterConfig(XdsExtension extension,
   }
   if (envoy_extensions_filters_http_router_v3_Router_parse(
           serialized_filter_config->data(), serialized_filter_config->size(),
-          arena) == nullptr) {
+          context.arena) == nullptr) {
     errors->AddError("could not parse router filter config");
     return absl::nullopt;
   }
@@ -71,8 +73,8 @@ XdsHttpRouterFilter::GenerateFilterConfig(XdsExtension extension,
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpRouterFilter::GenerateFilterConfigOverride(
-    XdsExtension /*extension*/, upb_Arena* /*arena*/,
-    ValidationErrors* errors) const {
+    const XdsResourceType::DecodeContext& /*context*/,
+    XdsExtension /*extension*/, ValidationErrors* errors) const {
   errors->AddError("router filter does not support config override");
   return absl::nullopt;
 }
@@ -86,6 +88,9 @@ XdsHttpFilterRegistry::XdsHttpFilterRegistry(bool register_builtins) {
     RegisterFilter(std::make_unique<XdsHttpRouterFilter>());
     RegisterFilter(std::make_unique<XdsHttpFaultFilter>());
     RegisterFilter(std::make_unique<XdsHttpRbacFilter>());
+    if (XdsHostOverrideEnabled()) {
+      RegisterFilter(std::make_unique<XdsHttpStatefulSessionFilter>());
+    }
   }
 }
 

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

@@ -30,10 +30,10 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "upb/arena.h"
 #include "upb/def.h"
 
 #include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/gprpp/validation_errors.h"
@@ -85,13 +85,13 @@ class XdsHttpFilterImpl {
   // Generates a Config from the xDS filter config proto.
   // Used for the top-level config in the HCM HTTP filter list.
   virtual absl::optional<FilterConfig> GenerateFilterConfig(
-      XdsExtension extension, upb_Arena* arena,
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const = 0;
 
   // Generates a Config from the xDS filter config proto.
   // Used for the typed_per_filter_config override in VirtualHost and Route.
   virtual absl::optional<FilterConfig> GenerateFilterConfigOverride(
-      XdsExtension extension, upb_Arena* arena,
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const = 0;
 
   // C-core channel filter implementation.
@@ -129,10 +129,10 @@ class XdsHttpRouterFilter : public XdsHttpFilterImpl {
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
   absl::optional<FilterConfig> GenerateFilterConfig(
-      XdsExtension extension, upb_Arena* arena,
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   absl::optional<FilterConfig> GenerateFilterConfigOverride(
-      XdsExtension extension, upb_Arena* arena,
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   const grpc_channel_filter* channel_filter() const override { return nullptr; }
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(

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

@@ -434,9 +434,9 @@ void XdsHttpRbacFilter::PopulateSymtab(upb_DefPool* symtab) const {
 }
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
-XdsHttpRbacFilter::GenerateFilterConfig(XdsExtension extension,
-                                        upb_Arena* arena,
-                                        ValidationErrors* errors) const {
+XdsHttpRbacFilter::GenerateFilterConfig(
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
       absl::get_if<absl::string_view>(&extension.value);
   if (serialized_filter_config == nullptr) {
@@ -445,7 +445,7 @@ XdsHttpRbacFilter::GenerateFilterConfig(XdsExtension extension,
   }
   auto* rbac = envoy_extensions_filters_http_rbac_v3_RBAC_parse(
       serialized_filter_config->data(), serialized_filter_config->size(),
-      arena);
+      context.arena);
   if (rbac == nullptr) {
     errors->AddError("could not parse HTTP RBAC filter config");
     return absl::nullopt;
@@ -455,7 +455,8 @@ XdsHttpRbacFilter::GenerateFilterConfig(XdsExtension extension,
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpRbacFilter::GenerateFilterConfigOverride(
-    XdsExtension extension, upb_Arena* arena, ValidationErrors* errors) const {
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
       absl::get_if<absl::string_view>(&extension.value);
   if (serialized_filter_config == nullptr) {
@@ -465,7 +466,7 @@ XdsHttpRbacFilter::GenerateFilterConfigOverride(
   auto* rbac_per_route =
       envoy_extensions_filters_http_rbac_v3_RBACPerRoute_parse(
           serialized_filter_config->data(), serialized_filter_config->size(),
-          arena);
+          context.arena);
   if (rbac_per_route == nullptr) {
     errors->AddError("could not parse RBACPerRoute");
     return absl::nullopt;

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

@@ -22,11 +22,11 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "upb/arena.h"
 #include "upb/def.h"
 
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/gprpp/validation_errors.h"
@@ -39,10 +39,10 @@ class XdsHttpRbacFilter : public XdsHttpFilterImpl {
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
   absl::optional<FilterConfig> GenerateFilterConfig(
-      XdsExtension extension, upb_Arena* arena,
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   absl::optional<FilterConfig> GenerateFilterConfigOverride(
-      XdsExtension extension, upb_Arena* arena,
+      const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
   const grpc_channel_filter* channel_filter() const override;
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;