grpc 1.63.0 → 1.66.0

data/src/core/load_balancing/ring_hash/ring_hash.cc

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/load_balancing/ring_hash/ring_hash.h"
 
 #include <inttypes.h>
@@ -31,6 +29,8 @@
 
 #include "absl/base/attributes.h"
 #include "absl/container/inlined_vector.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -40,10 +40,9 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/json.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/client_channel/client_channel_internal.h"
-#include "src/core/load_balancing/pick_first/pick_first.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -61,18 +60,17 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/json/json.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/load_balancing/delegating_helper.h"
 #include "src/core/load_balancing/lb_policy.h"
 #include "src/core/load_balancing/lb_policy_factory.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/load_balancing/pick_first/pick_first.h"
 #include "src/core/resolver/endpoint_addresses.h"
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 
-TraceFlag grpc_lb_ring_hash_trace(false, "ring_hash_lb");
-
 UniqueTypeName RequestHashAttribute::TypeName() {
   static UniqueTypeName::Factory kFactory("request_hash");
   return kFactory.Create();
@@ -170,7 +168,7 @@ class RingHash final : public LoadBalancingPolicy {
 
     size_t index() const { return index_; }
 
-    void UpdateLocked(size_t index);
+    absl::Status UpdateLocked(size_t index);
 
     grpc_connectivity_state connectivity_state() const {
       return connectivity_state_;
@@ -197,7 +195,7 @@ class RingHash final : public LoadBalancingPolicy {
     class Helper;
 
     void CreateChildPolicy();
-    void UpdateChildPolicyLocked();
+    absl::Status UpdateChildPolicyLocked();
 
     // Called when the child policy reports a connectivity state update.
     void OnStateUpdate(grpc_connectivity_state new_state,
@@ -302,8 +300,7 @@ class RingHash final : public LoadBalancingPolicy {
 
 RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
   auto* call_state = static_cast<ClientChannelLbCallState*>(args.call_state);
-  auto* hash_attribute = static_cast<RequestHashAttribute*>(
-      call_state->GetCallAttribute(RequestHashAttribute::TypeName()));
+  auto* hash_attribute = call_state->GetCallAttribute<RequestHashAttribute>();
   if (hash_attribute == nullptr) {
     return PickResult::Fail(absl::InternalError("hash attribute not present"));
   }
@@ -499,9 +496,10 @@ void RingHash::RingHashEndpoint::Orphan() {
   Unref();
 }
 
-void RingHash::RingHashEndpoint::UpdateLocked(size_t index) {
+absl::Status RingHash::RingHashEndpoint::UpdateLocked(size_t index) {
   index_ = index;
-  if (child_policy_ != nullptr) UpdateChildPolicyLocked();
+  if (child_policy_ == nullptr) return absl::OkStatus();
+  return UpdateChildPolicyLocked();
 }
 
 void RingHash::RingHashEndpoint::ResetBackoffLocked() {
@@ -517,7 +515,7 @@ void RingHash::RingHashEndpoint::RequestConnectionLocked() {
 }
 
 void RingHash::RingHashEndpoint::CreateChildPolicy() {
-  GPR_ASSERT(child_policy_ == nullptr);
+  CHECK(child_policy_ == nullptr);
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer = ring_hash_->work_serializer();
   lb_policy_args.args =
@@ -529,52 +527,57 @@ void RingHash::RingHashEndpoint::CreateChildPolicy() {
   child_policy_ =
       CoreConfiguration::Get().lb_policy_registry().CreateLoadBalancingPolicy(
           "pick_first", std::move(lb_policy_args));
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
     const EndpointAddresses& endpoint = ring_hash_->endpoints_[index_];
-    gpr_log(GPR_INFO,
-            "[RH %p] endpoint %p (index %" PRIuPTR " of %" PRIuPTR
-            ", %s): created child policy %p",
-            ring_hash_.get(), this, index_, ring_hash_->endpoints_.size(),
-            endpoint.ToString().c_str(), child_policy_.get());
+    LOG(INFO) << "[RH " << ring_hash_.get() << "] endpoint " << this
+              << " (index " << index_ << " of " << ring_hash_->endpoints_.size()
+              << ", " << endpoint.ToString() << "): created child policy "
+              << child_policy_.get();
   }
   // Add our interested_parties pollset_set to that of the newly created
   // child policy. This will make the child policy progress upon activity on
   // this policy, which in turn is tied to the application's call.
   grpc_pollset_set_add_pollset_set(child_policy_->interested_parties(),
                                    ring_hash_->interested_parties());
-  UpdateChildPolicyLocked();
+  // If the child policy returns a non-OK status, request re-resolution.
+  // Note that this will initially cause fixed backoff delay in the
+  // resolver instead of exponential delay.  However, once the
+  // resolver returns the initial re-resolution, we will be able to
+  // return non-OK from UpdateLocked(), which will trigger
+  // exponential backoff instead.
+  absl::Status status = UpdateChildPolicyLocked();
+  if (!status.ok()) {
+    ring_hash_->channel_control_helper()->RequestReresolution();
+  }
 }
 
-void RingHash::RingHashEndpoint::UpdateChildPolicyLocked() {
+absl::Status RingHash::RingHashEndpoint::UpdateChildPolicyLocked() {
   // Construct pick_first config.
   auto config =
       CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
           Json::FromArray(
               {Json::FromObject({{"pick_first", Json::FromObject({})}})}));
-  GPR_ASSERT(config.ok());
+  CHECK(config.ok());
   // Update child policy.
   LoadBalancingPolicy::UpdateArgs update_args;
   update_args.addresses =
       std::make_shared<SingleEndpointIterator>(ring_hash_->endpoints_[index_]);
   update_args.args = ring_hash_->args_;
   update_args.config = std::move(*config);
-  // TODO(roth): If the child reports a non-OK status with the update,
-  // we need to propagate that back to the resolver somehow.
-  (void)child_policy_->UpdateLocked(std::move(update_args));
+  return child_policy_->UpdateLocked(std::move(update_args));
 }
 
 void RingHash::RingHashEndpoint::OnStateUpdate(
     grpc_connectivity_state new_state, const absl::Status& status,
     RefCountedPtr<SubchannelPicker> picker) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-    gpr_log(
-        GPR_INFO,
-        "[RH %p] connectivity changed for endpoint %p (%s, child_policy=%p): "
-        "prev_state=%s new_state=%s (%s)",
-        ring_hash_.get(), this,
-        ring_hash_->endpoints_[index_].ToString().c_str(), child_policy_.get(),
-        ConnectivityStateName(connectivity_state_),
-        ConnectivityStateName(new_state), status.ToString().c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
+    LOG(INFO) << "[RH " << ring_hash_.get()
+              << "] connectivity changed for endpoint " << this << " ("
+              << ring_hash_->endpoints_[index_].ToString()
+              << ", child_policy=" << child_policy_.get()
+              << "): prev_state=" << ConnectivityStateName(connectivity_state_)
+              << " new_state=" << ConnectivityStateName(new_state) << " ("
+              << status << ")";
   }
   if (child_policy_ == nullptr) return;  // Already orphaned.
   // Update state.
@@ -594,20 +597,20 @@ void RingHash::RingHashEndpoint::OnStateUpdate(
 //
 
 RingHash::RingHash(Args args) : LoadBalancingPolicy(std::move(args)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-    gpr_log(GPR_INFO, "[RH %p] Created", this);
+  if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
+    LOG(INFO) << "[RH " << this << "] Created";
   }
 }
 
 RingHash::~RingHash() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-    gpr_log(GPR_INFO, "[RH %p] Destroying Ring Hash policy", this);
+  if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
+    LOG(INFO) << "[RH " << this << "] Destroying Ring Hash policy";
   }
 }
 
 void RingHash::ShutdownLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-    gpr_log(GPR_INFO, "[RH %p] Shutting down", this);
+  if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
+    LOG(INFO) << "[RH " << this << "] Shutting down";
   }
   shutdown_ = true;
   endpoint_map_.clear();
@@ -622,8 +625,8 @@ void RingHash::ResetBackoffLocked() {
 absl::Status RingHash::UpdateLocked(UpdateArgs args) {
   // Check address list.
   if (args.addresses.ok()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-      gpr_log(GPR_INFO, "[RH %p] received update", this);
+    if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
+      LOG(INFO) << "[RH " << this << "] received update";
     }
     // De-dup endpoints, taking weight into account.
     endpoints_.clear();
@@ -638,11 +641,10 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
             endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
         int prev_weight_arg =
             prev_endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-          gpr_log(GPR_INFO,
-                  "[RH %p] merging duplicate endpoint for %s, combined "
-                  "weight %d",
-                  this, key.ToString().c_str(), weight_arg + prev_weight_arg);
+        if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
+          LOG(INFO) << "[RH " << this << "] merging duplicate endpoint for "
+                    << key.ToString() << ", combined weight "
+                    << weight_arg + prev_weight_arg;
         }
         prev_endpoint = EndpointAddresses(
             prev_endpoint.addresses(),
@@ -653,9 +655,9 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
       }
     });
   } else {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-      gpr_log(GPR_INFO, "[RH %p] received update with addresses error: %s",
-              this, args.addresses.status().ToString().c_str());
+    if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
+      LOG(INFO) << "[RH " << this << "] received update with addresses error: "
+                << args.addresses.status();
     }
     // If we already have an endpoint list, then keep using the existing
     // list, but still report back that the update was not accepted.
@@ -668,13 +670,18 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
       this, static_cast<RingHashLbConfig*>(args.config.get()));
   // Update endpoint map.
   std::map<EndpointAddressSet, OrphanablePtr<RingHashEndpoint>> endpoint_map;
+  std::vector<std::string> errors;
   for (size_t i = 0; i < endpoints_.size(); ++i) {
     const EndpointAddresses& addresses = endpoints_[i];
     const EndpointAddressSet address_set(addresses.addresses());
     // If present in old map, retain it; otherwise, create a new one.
     auto it = endpoint_map_.find(address_set);
     if (it != endpoint_map_.end()) {
-      it->second->UpdateLocked(i);
+      absl::Status status = it->second->UpdateLocked(i);
+      if (!status.ok()) {
+        errors.emplace_back(absl::StrCat("endpoint ", address_set.ToString(),
+                                         ": ", status.ToString()));
+      }
       endpoint_map.emplace(address_set, std::move(it->second));
     } else {
       endpoint_map.emplace(address_set, MakeOrphanable<RingHashEndpoint>(
@@ -696,6 +703,10 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
   // Return a new picker.
   UpdateAggregatedConnectivityStateLocked(/*entered_transient_failure=*/false,
                                           absl::OkStatus());
+  if (!errors.empty()) {
+    return absl::UnavailableError(absl::StrCat(
+        "errors from children: [", absl::StrJoin(errors, "; "), "]"));
+  }
   return absl::OkStatus();
 }
 
@@ -754,15 +765,14 @@ void RingHash::UpdateAggregatedConnectivityStateLocked(
     state = GRPC_CHANNEL_TRANSIENT_FAILURE;
     start_connection_attempt = true;
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-    gpr_log(GPR_INFO,
-            "[RH %p] setting connectivity state to %s (num_idle=%" PRIuPTR
-            ", num_connecting=%" PRIuPTR ", num_ready=%" PRIuPTR
-            ", num_transient_failure=%" PRIuPTR ", size=%" PRIuPTR
-            ") -- start_connection_attempt=%d",
-            this, ConnectivityStateName(state), num_idle, num_connecting,
-            num_ready, num_transient_failure, endpoints_.size(),
-            start_connection_attempt);
+  if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
+    LOG(INFO) << "[RH " << this << "] setting connectivity state to "
+              << ConnectivityStateName(state) << " (num_idle=" << num_idle
+              << ", num_connecting=" << num_connecting
+              << ", num_ready=" << num_ready
+              << ", num_transient_failure=" << num_transient_failure
+              << ", size=" << endpoints_.size()
+              << ") -- start_connection_attempt=" << start_connection_attempt;
   }
   // In TRANSIENT_FAILURE, report the last reported failure.
   // Otherwise, report OK.
@@ -818,7 +828,7 @@ void RingHash::UpdateAggregatedConnectivityStateLocked(
     for (size_t i = 0; i < endpoints_.size(); ++i) {
       auto it =
           endpoint_map_.find(EndpointAddressSet(endpoints_[i].addresses()));
-      GPR_ASSERT(it != endpoint_map_.end());
+      CHECK(it != endpoint_map_.end());
       if (it->second->connectivity_state() == GRPC_CHANNEL_CONNECTING) {
         first_idle_index = endpoints_.size();
         break;
@@ -831,14 +841,13 @@ void RingHash::UpdateAggregatedConnectivityStateLocked(
     if (first_idle_index != endpoints_.size()) {
       auto it = endpoint_map_.find(
           EndpointAddressSet(endpoints_[first_idle_index].addresses()));
-      GPR_ASSERT(it != endpoint_map_.end());
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-        gpr_log(GPR_INFO,
-                "[RH %p] triggering internal connection attempt for endpoint "
-                "%p (%s) (index %" PRIuPTR " of %" PRIuPTR ")",
-                this, it->second.get(),
-                endpoints_[first_idle_index].ToString().c_str(),
-                first_idle_index, endpoints_.size());
+      CHECK(it != endpoint_map_.end());
+      if (GRPC_TRACE_FLAG_ENABLED(ring_hash_lb)) {
+        LOG(INFO) << "[RH " << this
+                  << "] triggering internal connection attempt for endpoint "
+                  << it->second.get() << " ("
+                  << endpoints_[first_idle_index].ToString() << ") (index "
+                  << first_idle_index << " of " << endpoints_.size() << ")";
       }
       it->second->RequestConnectionLocked();
     }

data/src/core/load_balancing/ring_hash/ring_hash.h

@@ -17,16 +17,16 @@
 #ifndef GRPC_SRC_CORE_LOAD_BALANCING_RING_HASH_RING_HASH_H
 #define GRPC_SRC_CORE_LOAD_BALANCING_RING_HASH_RING_HASH_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_args.h"
-#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/service_config/service_config_call_data.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
 
 namespace grpc_core {