grpc 1.83.1 → 1.84.0

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

@@ -16,26 +16,13 @@
 
 #include "src/core/xds/grpc/xds_lb_policy_registry.h"
 
-#include <grpc/support/json.h>
-#include <grpc/support/port_platform.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <optional>
 #include <string>
 #include <utility>
 #include <variant>
 
 #include "envoy/config/core/v3/extension.upb.h"
-#include "envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.upb.h"
-#include "envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.upb.h"
-#include "envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.upb.h"
-#include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
-#include "google/protobuf/wrappers.upb.h"
-#include "src/core/client_channel/client_channel_service_config.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
-#include "src/core/load_balancing/weighted_round_robin/weighted_round_robin.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_common_types.h"
@@ -44,285 +31,6 @@
 
 namespace grpc_core {
 
-namespace {
-
-class RoundRobinLbPolicyConfigFactory final
-    : public XdsLbPolicyRegistry::ConfigFactory {
- public:
-  Json::Object ConvertXdsLbPolicyConfig(
-      const XdsLbPolicyRegistry* /*registry*/,
-      const XdsResourceType::DecodeContext& /*context*/,
-      absl::string_view /*configuration*/, ValidationErrors* /*errors*/,
-      int /*recursion_depth*/) override {
-    return Json::Object{{"round_robin", Json::FromObject({})}};
-  }
-
-  absl::string_view type() override { return Type(); }
-
-  static absl::string_view Type() {
-    return "envoy.extensions.load_balancing_policies.round_robin.v3.RoundRobin";
-  }
-};
-
-class ClientSideWeightedRoundRobinLbPolicyConfigFactory final
-    : public XdsLbPolicyRegistry::ConfigFactory {
- public:
-  Json::Object ConvertXdsLbPolicyConfig(
-      const XdsLbPolicyRegistry* /*registry*/,
-      const XdsResourceType::DecodeContext& context,
-      absl::string_view configuration, ValidationErrors* errors,
-      int /*recursion_depth*/) override {
-    const auto* resource =
-        envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_parse(
-            configuration.data(), configuration.size(), context.arena);
-    if (resource == nullptr) {
-      errors->AddError(
-          "can't decode ClientSideWeightedRoundRobin LB policy config");
-      return {};
-    }
-    Json::Object config;
-    // enable_oob_load_report
-    if (ParseBoolValue(
-            envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_enable_oob_load_report(
-                resource))) {
-      config["enableOobLoadReport"] = Json::FromBool(true);
-    }
-    // oob_reporting_period
-    auto* duration_proto =
-        envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_oob_reporting_period(
-            resource);
-    if (duration_proto != nullptr) {
-      ValidationErrors::ScopedField field(errors, ".oob_reporting_period");
-      Duration duration = ParseDuration(duration_proto, errors);
-      config["oobReportingPeriod"] = Json::FromString(duration.ToJsonString());
-    }
-    // blackout_period
-    duration_proto =
-        envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_blackout_period(
-            resource);
-    if (duration_proto != nullptr) {
-      ValidationErrors::ScopedField field(errors, ".blackout_period");
-      Duration duration = ParseDuration(duration_proto, errors);
-      config["blackoutPeriod"] = Json::FromString(duration.ToJsonString());
-    }
-    // weight_update_period
-    duration_proto =
-        envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_weight_update_period(
-            resource);
-    if (duration_proto != nullptr) {
-      ValidationErrors::ScopedField field(errors, ".weight_update_period");
-      Duration duration = ParseDuration(duration_proto, errors);
-      config["weightUpdatePeriod"] = Json::FromString(duration.ToJsonString());
-    }
-    // weight_expiration_period
-    duration_proto =
-        envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_weight_expiration_period(
-            resource);
-    if (duration_proto != nullptr) {
-      ValidationErrors::ScopedField field(errors, ".weight_expiration_period");
-      Duration duration = ParseDuration(duration_proto, errors);
-      config["weightExpirationPeriod"] =
-          Json::FromString(duration.ToJsonString());
-    }
-    // error_utilization_penalty
-    auto* error_utilization_penalty =
-        envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_error_utilization_penalty(
-            resource);
-    if (error_utilization_penalty != nullptr) {
-      ValidationErrors::ScopedField field(errors, ".error_utilization_penalty");
-      const float value =
-          google_protobuf_FloatValue_value(error_utilization_penalty);
-      if (value < 0.0) {
-        errors->AddError("value must be non-negative");
-      }
-      config["errorUtilizationPenalty"] = Json::FromNumber(value);
-    }
-    // metric_names_for_computing_utilization
-    if (WrrCustomMetricsEnabled()) {
-      size_t size;
-      auto metric_names_for_computing_utilization =
-          envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_metric_names_for_computing_utilization(
-              resource, &size);
-      if (metric_names_for_computing_utilization != nullptr && size != 0) {
-        Json::Array metric_names;
-        for (size_t i = 0; i < size; ++i) {
-          metric_names.emplace_back(Json::FromString(
-              UpbStringToStdString(metric_names_for_computing_utilization[i])));
-        }
-        config["metricNamesForComputingUtilization"] =
-            Json::FromArray(std::move(metric_names));
-      }
-    }
-    return Json::Object{
-        {"weighted_round_robin", Json::FromObject(std::move(config))}};
-  }
-
-  absl::string_view type() override { return Type(); }
-
-  static absl::string_view Type() {
-    return "envoy.extensions.load_balancing_policies.client_side_weighted_"
-           "round_robin.v3.ClientSideWeightedRoundRobin";
-  }
-};
-
-class RingHashLbPolicyConfigFactory final
-    : public XdsLbPolicyRegistry::ConfigFactory {
- public:
-  Json::Object ConvertXdsLbPolicyConfig(
-      const XdsLbPolicyRegistry* /*registry*/,
-      const XdsResourceType::DecodeContext& context,
-      absl::string_view configuration, ValidationErrors* errors,
-      int /*recursion_depth*/) override {
-    const auto* resource =
-        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_parse(
-            configuration.data(), configuration.size(), context.arena);
-    if (resource == nullptr) {
-      errors->AddError("can't decode RingHash LB policy config");
-      return {};
-    }
-    if (envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_hash_function(
-            resource) !=
-            envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_XX_HASH &&
-        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_hash_function(
-            resource) !=
-            envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_DEFAULT_HASH) {
-      ValidationErrors::ScopedField field(errors, ".hash_function");
-      errors->AddError("unsupported value (must be XX_HASH)");
-    }
-    uint64_t max_ring_size =
-        ParseUInt64Value(
-            envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_maximum_ring_size(
-                resource))
-            .value_or(8388608);
-    if (max_ring_size == 0 || max_ring_size > 8388608) {
-      ValidationErrors::ScopedField field(errors, ".maximum_ring_size");
-      errors->AddError("value must be in the range [1, 8388608]");
-    }
-    uint64_t min_ring_size =
-        ParseUInt64Value(
-            envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_minimum_ring_size(
-                resource))
-            .value_or(1024);
-    {
-      ValidationErrors::ScopedField field(errors, ".minimum_ring_size");
-      if (min_ring_size == 0 || min_ring_size > 8388608) {
-        errors->AddError("value must be in the range [1, 8388608]");
-      }
-      if (min_ring_size > max_ring_size) {
-        errors->AddError("cannot be greater than maximum_ring_size");
-      }
-    }
-    return Json::Object{
-        {"ring_hash_experimental",
-         Json::FromObject({
-             {"minRingSize", Json::FromNumber(min_ring_size)},
-             {"maxRingSize", Json::FromNumber(max_ring_size)},
-         })},
-    };
-  }
-
-  absl::string_view type() override { return Type(); }
-
-  static absl::string_view Type() {
-    return "envoy.extensions.load_balancing_policies.ring_hash.v3.RingHash";
-  }
-};
-
-class WrrLocalityLbPolicyConfigFactory final
-    : public XdsLbPolicyRegistry::ConfigFactory {
- public:
-  Json::Object ConvertXdsLbPolicyConfig(
-      const XdsLbPolicyRegistry* registry,
-      const XdsResourceType::DecodeContext& context,
-      absl::string_view configuration, ValidationErrors* errors,
-      int recursion_depth) override {
-    const auto* resource =
-        envoy_extensions_load_balancing_policies_wrr_locality_v3_WrrLocality_parse(
-            configuration.data(), configuration.size(), context.arena);
-    if (resource == nullptr) {
-      errors->AddError("can't decode WrrLocality LB policy config");
-      return {};
-    }
-    ValidationErrors::ScopedField field(errors, ".endpoint_picking_policy");
-    const auto* endpoint_picking_policy =
-        envoy_extensions_load_balancing_policies_wrr_locality_v3_WrrLocality_endpoint_picking_policy(
-            resource);
-    if (endpoint_picking_policy == nullptr) {
-      errors->AddError("field not present");
-      return {};
-    }
-    auto child_policy = registry->ConvertXdsLbPolicyConfig(
-        context, endpoint_picking_policy, errors, recursion_depth + 1);
-    return Json::Object{
-        {"xds_wrr_locality_experimental",
-         Json::FromObject(
-             {{"childPolicy", Json::FromArray(std::move(child_policy))}})}};
-  }
-
-  absl::string_view type() override { return Type(); }
-
-  static absl::string_view Type() {
-    return "envoy.extensions.load_balancing_policies.wrr_locality.v3."
-           "WrrLocality";
-  }
-};
-
-class PickFirstLbPolicyConfigFactory final
-    : public XdsLbPolicyRegistry::ConfigFactory {
- public:
-  Json::Object ConvertXdsLbPolicyConfig(
-      const XdsLbPolicyRegistry* /*registry*/,
-      const XdsResourceType::DecodeContext& context,
-      absl::string_view configuration, ValidationErrors* errors,
-      int /*recursion_depth*/) override {
-    const auto* resource =
-        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_parse(
-            configuration.data(), configuration.size(), context.arena);
-    if (resource == nullptr) {
-      errors->AddError("can't decode PickFirst LB policy config");
-      return {};
-    }
-    bool shuffle_address_list =
-        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_shuffle_address_list(
-            resource);
-    return Json::Object{
-        {"pick_first",
-         Json::FromObject({
-             {"shuffleAddressList", Json::FromBool(shuffle_address_list)},
-         })}};
-  }
-
-  absl::string_view type() override { return Type(); }
-
-  static absl::string_view Type() {
-    return "envoy.extensions.load_balancing_policies.pick_first.v3.PickFirst";
-  }
-};
-
-}  // namespace
-
-//
-// XdsLbPolicyRegistry
-//
-
-XdsLbPolicyRegistry::XdsLbPolicyRegistry() {
-  policy_config_factories_.emplace(
-      RingHashLbPolicyConfigFactory::Type(),
-      std::make_unique<RingHashLbPolicyConfigFactory>());
-  policy_config_factories_.emplace(
-      RoundRobinLbPolicyConfigFactory::Type(),
-      std::make_unique<RoundRobinLbPolicyConfigFactory>());
-  policy_config_factories_.emplace(
-      ClientSideWeightedRoundRobinLbPolicyConfigFactory::Type(),
-      std::make_unique<ClientSideWeightedRoundRobinLbPolicyConfigFactory>());
-  policy_config_factories_.emplace(
-      WrrLocalityLbPolicyConfigFactory::Type(),
-      std::make_unique<WrrLocalityLbPolicyConfigFactory>());
-  policy_config_factories_.emplace(
-      PickFirstLbPolicyConfigFactory::Type(),
-      std::make_unique<PickFirstLbPolicyConfigFactory>());
-}
-
 Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_cluster_v3_LoadBalancingPolicy* lb_policy,

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

@@ -17,10 +17,9 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_LB_POLICY_REGISTRY_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_LB_POLICY_REGISTRY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <map>
 #include <memory>
+#include <utility>
 
 #include "envoy/config/cluster/v3/cluster.upb.h"
 #include "src/core/util/json/json.h"
@@ -45,7 +44,12 @@ class XdsLbPolicyRegistry final {
     virtual absl::string_view type() = 0;
   };
 
-  XdsLbPolicyRegistry();
+  XdsLbPolicyRegistry() = default;
+
+  template <typename T>
+  void RegisterFactory(std::unique_ptr<T> factory) {
+    policy_config_factories_.emplace(T::Type(), std::move(factory));
+  }
 
   // Converts an xDS cluster load balancing policy message to gRPC's JSON
   // format. An error is returned if none of the lb policies in the list are

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

@@ -66,6 +66,8 @@ std::string XdsListenerResource::HttpConnectionManager::HttpFilter::ToString()
   StrAppend(result, config_proto_type);
   StrAppend(result, ", config=");
   StrAppend(result, JsonDump(config));
+  StrAppend(result, ", disabled=");
+  StrAppend(result, disabled ? "true" : "false");
   StrAppend(result, ", filter_config=");
   StrAppend(result,
             filter_config == nullptr ? "null" : filter_config->ToString());

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

@@ -35,6 +35,7 @@
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_http_filter.h"
 #include "src/core/xds/grpc/xds_route_config.h"
+#include "src/core/xds/grpc/xds_tls_context.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "src/core/xds/xds_client/xds_resource_type_impl.h"
 
@@ -55,11 +56,13 @@ struct XdsListenerResource : public XdsResourceType::ResourceData {
       absl::string_view config_proto_type;
       Json config;
       RefCountedPtr<const FilterConfig> filter_config;
+      bool disabled = false;
 
       bool operator==(const HttpFilter& other) const {
         if (name != other.name) return false;
         if (config_proto_type != other.config_proto_type) return false;
         if (config != other.config) return false;
+        if (disabled != other.disabled) return false;
         if (filter_config == nullptr) return other.filter_config == nullptr;
         if (other.filter_config == nullptr) return false;
         return *filter_config == *other.filter_config;
@@ -137,6 +140,8 @@ struct XdsListenerResource : public XdsResourceType::ResourceData {
         return *data == *other.data;
       }
     };
+    // TODO(roth): Unify this with Rbac::CidrRange, possibly as part of
+    // addressing https://github.com/grpc/grpc/issues/34172.
     struct CidrRange {
       grpc_resolved_address address;
       uint32_t prefix_len;

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

@@ -50,6 +50,7 @@
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_common_types_parser.h"
 #include "src/core/xds/grpc/xds_route_config_parser.h"
+#include "src/core/xds/grpc/xds_tls_context_parser.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "upb/text/encode.h"
 #include "absl/log/log.h"
@@ -288,14 +289,14 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
                 http_filter);
         auto extension = ExtractXdsExtension(context, typed_config, errors);
         if (!extension.has_value()) continue;
-        const XdsHttpFilterImpl* filter_impl =
+        const XdsHttpFilterFactory* factory =
             http_filter_registry.GetFilterForTopLevelType(extension->type);
-        if (filter_impl == nullptr) {
+        if (factory == nullptr) {
           if (!is_optional) errors->AddError("unsupported filter type");
           continue;
         }
-        if ((is_client && !filter_impl->IsSupportedOnClients()) ||
-            (!is_client && !filter_impl->IsSupportedOnServers())) {
+        if ((is_client && !factory->IsSupportedOnClients()) ||
+            (!is_client && !factory->IsSupportedOnServers())) {
           if (!is_optional) {
             errors->AddError(absl::StrCat("filter is not supported on ",
                                           is_client ? "clients" : "servers"));
@@ -305,16 +306,19 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
         http_connection_manager.http_filters.emplace_back();
         auto& entry = http_connection_manager.http_filters.back();
         entry.name = std::string(name);
-        entry.config_proto_type = filter_impl->ConfigProtoName();
+        entry.config_proto_type = factory->ConfigProtoName();
+        entry.disabled =
+            envoy_extensions_filters_network_http_connection_manager_v3_HttpFilter_disabled(
+                http_filter);
         if (!is_client) {
-          std::optional<Json> filter_config = filter_impl->GenerateFilterConfig(
-              name, context, *extension, errors);
+          std::optional<Json> filter_config =
+              factory->GenerateFilterConfig(name, context, *extension, errors);
           if (filter_config.has_value()) {
             entry.config = std::move(*filter_config);
           }
         }
         entry.filter_config =
-            filter_impl->ParseTopLevelConfig(name, context, *extension, errors);
+            factory->ParseTopLevelConfig(name, context, *extension, errors);
       }
     }
     if (errors->size() == original_error_size &&
@@ -326,19 +330,19 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
     // to take care of the case where there are two terminal filters in the list
     // out of which only one gets added in the final list.
     for (const auto& http_filter : http_connection_manager.http_filters) {
-      const XdsHttpFilterImpl* filter_impl =
+      const XdsHttpFilterFactory* factory =
           http_filter_registry.GetFilterForTopLevelType(
               http_filter.config_proto_type);
       if (&http_filter != &http_connection_manager.http_filters.back()) {
         // Filters before the last filter must not be terminal.
-        if (filter_impl->IsTerminalFilter()) {
+        if (factory->IsTerminalFilter()) {
           errors->AddError(absl::StrCat(
               "terminal filter for config type ", http_filter.config_proto_type,
               " must be the last filter in the chain"));
         }
       } else {
         // The last filter must be terminal.
-        if (!filter_impl->IsTerminalFilter()) {
+        if (!factory->IsTerminalFilter()) {
           errors->AddError(absl::StrCat("non-terminal filter for config type ",
                                         http_filter.config_proto_type,
                                         " is the last filter in the chain"));
@@ -668,6 +672,7 @@ std::optional<FilterChain> FilterChainParse(
   return filter_chain;
 }
 
+// TODO(roth): Merge this with ParseXdsAddress() to avoid duplication.
 std::optional<std::string> AddressParse(
     const envoy_config_core_v3_Address* address_proto,
     ValidationErrors* errors) {

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

@@ -17,9 +17,11 @@
 
 #include <memory>
 
-#include "src/core/xds/grpc/xds_common_types_parser.h"
+#include "src/core/util/unique_type_name.h"
+#include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_matcher.h"
 #include "src/core/xds/grpc/xds_matcher_action.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
 #include "xds/type/matcher/v3/matcher.upb.h"
 
 namespace grpc_core {

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

@@ -23,10 +23,10 @@
 #include "envoy/config/core/v3/address.upbdefs.h"
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upb.h"
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upbdefs.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/util/upb_utils.h"
 #include "src/core/util/validation_errors.h"
-#include "src/core/xds/grpc/xds_cluster_parser.h"
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_common_types_parser.h"
 #include "upb/base/string_view.h"
@@ -39,6 +39,11 @@
 
 namespace grpc_core {
 
+// TODO(roth): Remove this once the feature passes interop tests.
+bool XdsHttpConnectEnabled() {
+  return IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_HTTP_CONNECT");
+}
+
 namespace {
 
 std::unique_ptr<XdsMetadataValue> ParseGcpAuthnAudience(

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

@@ -24,6 +24,8 @@
 
 namespace grpc_core {
 
+bool XdsHttpConnectEnabled();
+
 XdsMetadataMap ParseXdsMetadataMap(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_core_v3_Metadata* metadata, ValidationErrors* errors);

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

@@ -38,6 +38,8 @@ std::string XdsRouteConfigResource::FilterConfigOverride::ToString() const {
   StrAppend(result, config_proto_type);
   StrAppend(result, ", config=");
   StrAppend(result, JsonDump(config));
+  StrAppend(result, ", disabled=");
+  StrAppend(result, disabled ? "true" : "false");
   StrAppend(result, ", filter_config=");
   StrAppend(result,
             filter_config == nullptr ? "null" : filter_config->ToString());

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

@@ -42,11 +42,13 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
     absl::string_view config_proto_type;
     Json config;
     RefCountedPtr<const FilterConfig> filter_config;
+    bool disabled = false;
 
     bool operator==(const FilterConfigOverride& other) const {
       if (config_proto_type != other.config_proto_type) return false;
       if (config != other.config) return false;
-      if (filter_config == nullptr) return other.filter_config != nullptr;
+      if (disabled != other.disabled) return false;
+      if (filter_config == nullptr) return other.filter_config == nullptr;
       if (other.filter_config == nullptr) return false;
       return *filter_config == *other.filter_config;
     }