grpc 1.50.0.pre1 → 1.52.0.pre2

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_resolver.cc

@@ -24,10 +24,10 @@
 #include <memory>
 #include <set>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -35,15 +35,14 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/connectivity_state.h>
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/address_filtering.h"
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
-#include "src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h"
-#include "src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h"
-#include "src/core/ext/filters/client_channel/lb_policy/xds/xds.h"
+#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_attributes.h"
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
@@ -52,7 +51,6 @@
 #include "src/core/ext/xds/xds_client_grpc.h"
 #include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/ext/xds/xds_endpoint.h"
-#include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -80,8 +78,6 @@ namespace grpc_core {
 
 TraceFlag grpc_lb_xds_cluster_resolver_trace(false, "xds_cluster_resolver_lb");
 
-const char* kXdsLocalityNameAttributeKey = "xds_locality_name";
-
 namespace {
 
 constexpr absl::string_view kXdsClusterResolver =
@@ -102,6 +98,8 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
     std::string eds_service_name;
     std::string dns_hostname;
 
+    Json::Array host_override_statuses;
+
     // This is type Json::Object instead of OutlierDetectionConfig, because we
     // don't actually need to validate the contents of the outlier detection
     // config here.  In this case, the JSON is generated by the CDS policy
@@ -117,6 +115,7 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
               type == other.type &&
               eds_service_name == other.eds_service_name &&
               dns_hostname == other.dns_hostname &&
+              host_override_statuses == other.host_override_statuses &&
               outlier_detection_lb_config == other.outlier_detection_lb_config);
     }
 
@@ -149,7 +148,7 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
 
  private:
   std::vector<DiscoveryMechanism> discovery_mechanisms_;
-  Json xds_lb_policy_ = Json::Object{{"ROUND_ROBIN", Json::Object()}};
+  Json xds_lb_policy_;
 };
 
 // Xds Cluster Resolver LB policy.
@@ -214,31 +213,26 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
         discovery_mechanism_.reset(DEBUG_LOCATION, "EndpointWatcher");
       }
       void OnResourceChanged(XdsEndpointResource update) override {
-        Ref().release();  // ref held by callback
+        RefCountedPtr<EndpointWatcher> self = Ref();
         discovery_mechanism_->parent()->work_serializer()->Run(
-            // TODO(yashykt): When we move to C++14, capture update with
-            // std::move
-            [this, update]() mutable {
-              OnResourceChangedHelper(std::move(update));
-              Unref();
+            [self = std::move(self), update = std::move(update)]() mutable {
+              self->OnResourceChangedHelper(std::move(update));
             },
             DEBUG_LOCATION);
       }
       void OnError(absl::Status status) override {
-        Ref().release();  // ref held by callback
+        RefCountedPtr<EndpointWatcher> self = Ref();
         discovery_mechanism_->parent()->work_serializer()->Run(
-            [this, status]() {
-              OnErrorHelper(status);
-              Unref();
+            [self = std::move(self), status = std::move(status)]() mutable {
+              self->OnErrorHelper(std::move(status));
             },
             DEBUG_LOCATION);
       }
       void OnResourceDoesNotExist() override {
-        Ref().release();  // ref held by callback
+        RefCountedPtr<EndpointWatcher> self = Ref();
         discovery_mechanism_->parent()->work_serializer()->Run(
-            [this]() {
-              OnResourceDoesNotExistHelper();
-              Unref();
+            [self = std::move(self)]() {
+              self->OnResourceDoesNotExistHelper();
             },
             DEBUG_LOCATION);
       }
@@ -378,11 +372,12 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
         ServerAddress address, const ChannelArgs& args) override;
     void UpdateState(grpc_connectivity_state state, const absl::Status& status,
-                     std::unique_ptr<SubchannelPicker> picker) override;
+                     RefCountedPtr<SubchannelPicker> picker) override;
     // This is a no-op, because we get the addresses from the xds
     // client, which is a watch-based API.
     void RequestReresolution() override {}
     absl::string_view GetAuthority() override;
+    grpc_event_engine::experimental::EventEngine* GetEventEngine() override;
     void AddTraceEvent(TraceSeverity severity,
                        absl::string_view message) override;
 
@@ -439,7 +434,7 @@ XdsClusterResolverLb::Helper::CreateSubchannel(ServerAddress address,
 
 void XdsClusterResolverLb::Helper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
-    std::unique_ptr<SubchannelPicker> picker) {
+    RefCountedPtr<SubchannelPicker> picker) {
   if (xds_cluster_resolver_policy_->shutting_down_ ||
       xds_cluster_resolver_policy_->child_policy_ == nullptr) {
     return;
@@ -459,6 +454,12 @@ absl::string_view XdsClusterResolverLb::Helper::GetAuthority() {
   return xds_cluster_resolver_policy_->channel_control_helper()->GetAuthority();
 }
 
+grpc_event_engine::experimental::EventEngine*
+XdsClusterResolverLb::Helper::GetEventEngine() {
+  return xds_cluster_resolver_policy_->channel_control_helper()
+      ->GetEventEngine();
+}
+
 void XdsClusterResolverLb::Helper::AddTraceEvent(TraceSeverity severity,
                                                  absl::string_view message) {
   if (xds_cluster_resolver_policy_->shutting_down_) return;
@@ -515,7 +516,7 @@ void XdsClusterResolverLb::LogicalDNSDiscoveryMechanism::Start() {
   resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(
       target.c_str(), args, parent()->interested_parties(),
       parent()->work_serializer(),
-      absl::make_unique<ResolverResultHandler>(
+      std::make_unique<ResolverResultHandler>(
           Ref(DEBUG_LOCATION, "LogicalDNSDiscoveryMechanism")));
   if (resolver_ == nullptr) {
     parent()->OnResourceDoesNotExist(
@@ -840,12 +841,12 @@ ServerAddressList XdsClusterResolverLb::CreateChildPolicyAddressesLocked() {
                       kHierarchicalPathAttributeKey,
                       MakeHierarchicalPathAttribute(hierarchical_path))
                   .WithAttribute(kXdsLocalityNameAttributeKey,
-                                 absl::make_unique<XdsLocalityAttribute>(
-                                     locality_name->Ref()))
+                                 std::make_unique<XdsLocalityAttribute>(
+                                     locality_name->Ref(), locality.lb_weight))
                   .WithAttribute(
                       ServerAddressWeightAttribute::
                           kServerAddressWeightAttributeKey,
-                      absl::make_unique<ServerAddressWeightAttribute>(weight)));
+                      std::make_unique<ServerAddressWeightAttribute>(weight)));
         }
       }
     }
@@ -872,62 +873,23 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
     for (size_t priority = 0;
          priority < discovery_entry.latest_update->priorities.size();
          ++priority) {
-      const auto& priority_entry =
-          discovery_entry.latest_update->priorities[priority];
+      // Determine what xDS LB policy to use.
       Json child_policy;
       if (!discovery_entry.discovery_mechanism->override_child_policy()
                .empty()) {
         child_policy =
             discovery_entry.discovery_mechanism->override_child_policy();
       } else {
-        const auto& xds_lb_policy = config_->xds_lb_policy().object_value();
-        if (xds_lb_policy.find("ROUND_ROBIN") != xds_lb_policy.end()) {
-          const auto& localities = priority_entry.localities;
-          Json::Object weighted_targets;
-          for (const auto& p : localities) {
-            XdsLocalityName* locality_name = p.first;
-            const auto& locality = p.second;
-            // Add weighted target entry.
-            weighted_targets[locality_name->AsHumanReadableString()] =
-                Json::Object{
-                    {"weight", locality.lb_weight},
-                    {"childPolicy",
-                     Json::Array{
-                         Json::Object{
-                             {"round_robin", Json::Object()},
-                         },
-                     }},
-                };
-          }
-          // Construct locality-picking policy.
-          // Start with field from our config and add the "targets" field.
-          child_policy = Json::Array{
-              Json::Object{
-                  {"weighted_target_experimental",
-                   Json::Object{
-                       {"targets", Json::Object()},
-                   }},
-              },
-          };
-          Json::Object& config =
-              *(*child_policy.mutable_array())[0].mutable_object();
-          auto it = config.begin();
-          GPR_ASSERT(it != config.end());
-          (*it->second.mutable_object())["targets"] =
-              std::move(weighted_targets);
-        } else {
-          auto it = xds_lb_policy.find("RING_HASH");
-          GPR_ASSERT(it != xds_lb_policy.end());
-          Json::Object ring_hash_experimental_policy =
-              it->second.object_value();
-          child_policy = Json::Array{
-              Json::Object{
-                  {"ring_hash_experimental", ring_hash_experimental_policy},
-              },
-          };
-        }
+        child_policy = config_->xds_lb_policy();
       }
-      // Wrap it in the drop policy.
+      // Wrap the xDS LB policy in the xds_override_host policy.
+      Json::Array xds_override_host_config = {Json::Object{
+          {"xds_override_host_experimental",
+           Json::Object{
+               {"overrideHostStatus", discovery_config.host_override_statuses},
+               {"childPolicy", std::move(child_policy)},
+           }}}};
+      // Wrap it in the xds_cluster_impl policy.
       Json::Array drop_categories;
       if (discovery_entry.latest_update->drop_config != nullptr) {
         for (const auto& category :
@@ -940,7 +902,7 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
       }
       Json::Object xds_cluster_impl_config = {
           {"clusterName", discovery_config.cluster_name},
-          {"childPolicy", std::move(child_policy)},
+          {"childPolicy", std::move(xds_override_host_config)},
           {"dropCategories", std::move(drop_categories)},
           {"maxConcurrentRequests", discovery_config.max_concurrent_requests},
       };
@@ -952,27 +914,19 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
         xds_cluster_impl_config["lrsLoadReportingServer"] =
             discovery_config.lrs_load_reporting_server->ToJson();
       }
-      Json locality_picking_policy;
-      if (XdsOutlierDetectionEnabled()) {
-        Json::Object outlier_detection_config;
-        if (discovery_entry.config().outlier_detection_lb_config.has_value()) {
-          outlier_detection_config =
-              discovery_entry.config().outlier_detection_lb_config.value();
-        }
-        outlier_detection_config["childPolicy"] = Json::Array{Json::Object{
-            {"xds_cluster_impl_experimental",
-             std::move(xds_cluster_impl_config)},
-        }};
-        locality_picking_policy = Json::Array{Json::Object{
-            {"outlier_detection_experimental",
-             std::move(outlier_detection_config)},
-        }};
-      } else {
-        locality_picking_policy = Json::Array{Json::Object{
-            {"xds_cluster_impl_experimental",
-             std::move(xds_cluster_impl_config)},
-        }};
+      // Wrap it in the outlier_detection policy.
+      Json::Object outlier_detection_config;
+      if (discovery_entry.config().outlier_detection_lb_config.has_value()) {
+        outlier_detection_config =
+            discovery_entry.config().outlier_detection_lb_config.value();
       }
+      outlier_detection_config["childPolicy"] = Json::Array{Json::Object{
+          {"xds_cluster_impl_experimental", std::move(xds_cluster_impl_config)},
+      }};
+      Json locality_picking_policy = Json::Array{Json::Object{
+          {"outlier_detection_experimental",
+           std::move(outlier_detection_config)},
+      }};
       // Add priority entry, with the appropriate child name.
       std::string child_name = discovery_entry.GetChildPolicyName(priority);
       priority_priorities.emplace_back(child_name);
@@ -1015,7 +969,7 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
         "config");
     channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-        absl::make_unique<TransientFailurePicker>(status));
+        MakeRefCounted<TransientFailurePicker>(status));
     return nullptr;
   }
   return std::move(*config);
@@ -1052,7 +1006,7 @@ XdsClusterResolverLb::CreateChildPolicyLocked(const ChannelArgs& args) {
   lb_policy_args.work_serializer = work_serializer();
   lb_policy_args.args = args;
   lb_policy_args.channel_control_helper =
-      absl::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
+      std::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       CoreConfiguration::Get().lb_policy_registry().CreateLoadBalancingPolicy(
           "priority_experimental", std::move(lb_policy_args));
@@ -1090,8 +1044,9 @@ XdsClusterResolverLbConfig::DiscoveryMechanism::JsonLoader(const JsonArgs&) {
           .OptionalField("max_concurrent_requests",
                          &DiscoveryMechanism::max_concurrent_requests)
           .OptionalField("outlierDetection",
-                         &DiscoveryMechanism::outlier_detection_lb_config,
-                         "outlier_detection")
+                         &DiscoveryMechanism::outlier_detection_lb_config)
+          .OptionalField("overrideHostStatus",
+                         &DiscoveryMechanism::host_override_statuses)
           .Finish();
   return loader;
 }
@@ -1140,8 +1095,7 @@ const JsonLoaderInterface* XdsClusterResolverLbConfig::JsonLoader(
   return loader;
 }
 
-void XdsClusterResolverLbConfig::JsonPostLoad(const Json& json,
-                                              const JsonArgs& args,
+void XdsClusterResolverLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
                                               ValidationErrors* errors) {
   // Validate discoveryMechanisms.
   {
@@ -1154,37 +1108,14 @@ void XdsClusterResolverLbConfig::JsonPostLoad(const Json& json,
   {
     ValidationErrors::ScopedField field(errors, ".xdsLbPolicy");
     auto it = json.object_value().find("xdsLbPolicy");
-    if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::ARRAY) {
-        errors->AddError("is not an array");
-      } else {
-        const Json::Array& array = it->second.array_value();
-        for (size_t i = 0; i < array.size(); ++i) {
-          ValidationErrors::ScopedField field(errors,
-                                              absl::StrCat("[", i, "]"));
-          if (array[i].type() != Json::Type::OBJECT) {
-            errors->AddError("is not an object");
-            continue;
-          }
-          const Json::Object& policy = array[i].object_value();
-          auto policy_it = policy.find("ROUND_ROBIN");
-          if (policy_it != policy.end()) {
-            ValidationErrors::ScopedField field(errors, "[\"ROUND_ROBIN\"]");
-            if (policy_it->second.type() != Json::Type::OBJECT) {
-              errors->AddError("is not an object");
-            }
-            break;
-          }
-          {
-            ValidationErrors::ScopedField field(errors, "[\"RING_HASH\"]");
-            policy_it = policy.find("RING_HASH");
-            if (policy_it != policy.end()) {
-              LoadFromJson<RingHashConfig>(policy_it->second, args, errors);
-              xds_lb_policy_ = array[i];
-            }
-          }
-        }
-      }
+    if (it == json.object_value().end()) {
+      errors->AddError("field not present");
+    } else {
+      auto lb_config = CoreConfiguration::Get()
+                           .lb_policy_registry()
+                           .ParseLoadBalancingConfig(it->second);
+      if (!lb_config.ok()) errors->AddError(lb_config.status().message());
+      xds_lb_policy_ = it->second;
     }
   }
 }
@@ -1217,15 +1148,8 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
           "requires configuration. "
           "Please use loadBalancingConfig field of service config instead.");
     }
-    class XdsJsonArgs : public JsonArgs {
-     public:
-      bool IsEnabled(absl::string_view key) const override {
-        if (key == "outlier_detection") return XdsOutlierDetectionEnabled();
-        return true;
-      }
-    };
     return LoadRefCountedFromJson<XdsClusterResolverLbConfig>(
-        json, XdsJsonArgs(),
+        json, JsonArgs(),
         "errors validating xds_cluster_resolver LB policy config");
   }
 
@@ -1294,7 +1218,7 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
 
 void RegisterXdsClusterResolverLbPolicy(CoreConfiguration::Builder* builder) {
   builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
-      absl::make_unique<XdsClusterResolverLbFactory>());
+      std::make_unique<XdsClusterResolverLbFactory>());
 }
 
 }  // namespace grpc_core