grpc 1.54.2 → 1.61.0

data/src/core/lib/load_balancing/delegating_helper.h

@@ -0,0 +1,116 @@
+//
+// Copyright 2023 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_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H
+#define GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/connectivity_state.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/lib/load_balancing/subchannel_interface.h"
+#include "src/core/lib/security/credentials/credentials.h"
+
+namespace grpc_core {
+
+/// A helper for use in parent policies.  All methods delegate to a
+/// parent policy's helper unless otherwise overridden.
+class LoadBalancingPolicy::DelegatingChannelControlHelper
+    : public LoadBalancingPolicy::ChannelControlHelper {
+ public:
+  RefCountedPtr<SubchannelInterface> CreateSubchannel(
+      const grpc_resolved_address& address, const ChannelArgs& per_address_args,
+      const ChannelArgs& args) override {
+    return parent_helper()->CreateSubchannel(address, per_address_args, args);
+  }
+
+  void UpdateState(grpc_connectivity_state state, const absl::Status& status,
+                   RefCountedPtr<SubchannelPicker> picker) override {
+    parent_helper()->UpdateState(state, status, std::move(picker));
+  }
+
+  void RequestReresolution() override {
+    parent_helper()->RequestReresolution();
+  }
+
+  absl::string_view GetAuthority() override {
+    return parent_helper()->GetAuthority();
+  }
+
+  RefCountedPtr<grpc_channel_credentials> GetChannelCredentials() override {
+    return parent_helper()->GetChannelCredentials();
+  }
+
+  RefCountedPtr<grpc_channel_credentials> GetUnsafeChannelCredentials()
+      override {
+    return parent_helper()->GetUnsafeChannelCredentials();
+  }
+
+  grpc_event_engine::experimental::EventEngine* GetEventEngine() override {
+    return parent_helper()->GetEventEngine();
+  }
+
+  void AddTraceEvent(TraceSeverity severity,
+                     absl::string_view message) override {
+    parent_helper()->AddTraceEvent(severity, message);
+  }
+
+ private:
+  /// Returns the parent helper that we should delegate to by default.
+  virtual ChannelControlHelper* parent_helper() const = 0;
+};
+
+/// A delegating helper that owns a ref to the parent policy.
+template <typename ParentPolicy>
+class LoadBalancingPolicy::ParentOwningDelegatingChannelControlHelper
+    : public LoadBalancingPolicy::DelegatingChannelControlHelper {
+ public:
+  explicit ParentOwningDelegatingChannelControlHelper(
+      RefCountedPtr<ParentPolicy> parent)
+      : parent_(std::move(parent)) {}
+
+  ~ParentOwningDelegatingChannelControlHelper() override {
+    parent_.reset(DEBUG_LOCATION, "Helper");
+  }
+
+ protected:
+  ParentPolicy* parent() const {
+    return static_cast<ParentPolicy*>(parent_.get());
+  }
+
+  ChannelControlHelper* parent_helper() const override {
+    return parent_->channel_control_helper();
+  }
+
+ private:
+  RefCountedPtr<LoadBalancingPolicy> parent_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H

data/src/core/lib/load_balancing/lb_policy.h

@@ -35,6 +35,7 @@
 #include "absl/types/variant.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
@@ -48,8 +49,9 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
@@ -147,6 +149,14 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// The LB policy may use the existing metadata to influence its routing
     /// decision, and it may add new metadata elements to be sent with the
     /// call to the chosen backend.
+    // TODO(roth): Before making the LB policy API public, consider
+    // whether this is the right way to expose metadata to the picker.
+    // This approach means that if a pick modifies metadata but then we
+    // discard the pick because the subchannel is not connected, the
+    // metadata change will still have been made.  Maybe we actually
+    // want to somehow provide metadata changes in PickResult::Complete
+    // instead?  Or maybe we use a CallTracer that can add metadata when
+    // the call actually starts on the subchannel?
     MetadataInterface* initial_metadata;
     /// An interface for accessing call state.  Can be used to allocate
     /// memory associated with the call in an efficient way.
@@ -167,6 +177,8 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
   /// Interface for tracking subchannel calls.
   /// Implemented by LB policy and used by the channel.
+  // TODO(roth): Before making this API public, consider whether we
+  // should just replace this with a CallTracer, similar to what Java does.
   class SubchannelCallTrackerInterface {
    public:
     virtual ~SubchannelCallTrackerInterface() = default;
@@ -256,10 +268,6 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// state and logic needed on the control plane (i.e., resolver
   /// updates, connectivity state notifications, etc); the latter should
   /// live in the LB policy object itself.
-  ///
-  /// Currently, pickers are always accessed from within the
-  /// client_channel data plane mutex, so they do not have to be
-  /// thread-safe.
   class SubchannelPicker : public DualRefCounted<SubchannelPicker> {
    public:
     SubchannelPicker();
@@ -271,19 +279,16 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
   /// A proxy object implemented by the client channel and used by the
   /// LB policy to communicate with the channel.
-  // TODO(roth): Once insecure builds go away, add methods for accessing
-  // channel creds.  By default, that should strip off the call creds
-  // attached to the channel creds, but there should also be a "use at
-  // your own risk" option to get the channel creds without stripping
-  // off the attached call creds.
   class ChannelControlHelper {
    public:
     ChannelControlHelper() = default;
     virtual ~ChannelControlHelper() = default;
 
     /// Creates a new subchannel with the specified channel args.
+    /// The args and per_address_args will be merged by the channel.
     virtual RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        ServerAddress address, const ChannelArgs& args) = 0;
+        const grpc_resolved_address& address,
+        const ChannelArgs& per_address_args, const ChannelArgs& args) = 0;
 
     /// Sets the connectivity state and returns a new picker to be used
     /// by the client channel.
@@ -297,6 +302,20 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// Returns the channel authority.
     virtual absl::string_view GetAuthority() = 0;
 
+    /// Returns the channel credentials from the parent channel.  This can
+    /// be used to create a control-plane channel inside an LB policy.
+    virtual RefCountedPtr<grpc_channel_credentials> GetChannelCredentials() = 0;
+
+    /// Returns the UNSAFE ChannelCredentials used to construct the channel,
+    /// including bearer tokens.  LB policies should generally have no use for
+    /// these credentials, and use of them is heavily discouraged.  These must
+    /// be used VERY carefully to avoid sending bearer tokens to untrusted
+    /// servers, as the server could then impersonate the client.  Generally,
+    /// it is safe to use these credentials only when communicating with the
+    /// backends.
+    virtual RefCountedPtr<grpc_channel_credentials>
+    GetUnsafeChannelCredentials() = 0;
+
     /// Returns the EventEngine to use for timers and async work.
     virtual grpc_event_engine::experimental::EventEngine* GetEventEngine() = 0;
 
@@ -306,6 +325,11 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
                                absl::string_view message) = 0;
   };
 
+  class DelegatingChannelControlHelper;
+
+  template <typename ParentPolicy>
+  class ParentOwningDelegatingChannelControlHelper;
+
   /// Interface for configuration data used by an LB policy implementation.
   /// Individual implementations will create a subclass that adds methods to
   /// return the parameters they need.
@@ -320,9 +344,9 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// Data passed to the UpdateLocked() method when new addresses and
   /// config are available.
   struct UpdateArgs {
-    /// A list of addresses, or an error indicating a failure to obtain the
-    /// list of addresses.
-    absl::StatusOr<ServerAddressList> addresses;
+    /// A list of endpoints, each with one or more address, or an error
+    /// indicating a failure to obtain the list of addresses.
+    absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses;
     /// The LB policy config.
     RefCountedPtr<Config> config;
     /// A human-readable note providing context about the name resolution that
@@ -366,6 +390,19 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// whether the LB policy accepted the update; if non-OK, informs
   /// polling-based resolvers that they should go into backoff delay and
   /// eventually reattempt the resolution.
+  ///
+  /// The first time that UpdateLocked() is called, the LB policy will
+  /// generally not be able to determine the appropriate connectivity
+  /// state by the time UpdateLocked() returns (e.g., it will need to
+  /// wait for connectivity state notifications from each subchannel,
+  /// which will be delivered asynchronously).  In this case, the LB
+  /// policy should not call the helper's UpdateState() method until it
+  /// does have a clear picture of the connectivity state (e.g., it
+  /// should wait for all subchannels to report connectivity state
+  /// before calling the helper's UpdateState() method), although it is
+  /// expected to do so within some short period of time.  The parent of
+  /// the LB policy will assume that the policy's initial state is
+  /// CONNECTING and that picks should be queued.
   virtual absl::Status UpdateLocked(UpdateArgs) = 0;  // NOLINT
 
   /// Tries to enter a READY connectivity state.

data/src/core/lib/load_balancing/lb_policy_registry.cc

@@ -19,7 +19,6 @@
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
 
 #include <algorithm>
-#include <initializer_list>
 #include <map>
 #include <string>
 #include <utility>
@@ -31,6 +30,7 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/load_balancing/lb_policy.h"
@@ -83,7 +83,7 @@ bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
   if (factory == nullptr) return false;
   // If requested, check if the load balancing policy allows an empty config.
   if (requires_config != nullptr) {
-    auto config = factory->ParseLoadBalancingConfig(Json());
+    auto config = factory->ParseLoadBalancingConfig(Json::FromObject({}));
     *requires_config = !config.ok();
   }
   return true;
@@ -94,23 +94,23 @@ bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
 absl::StatusOr<Json::Object::const_iterator>
 LoadBalancingPolicyRegistry::ParseLoadBalancingConfigHelper(
     const Json& lb_config_array) const {
-  if (lb_config_array.type() != Json::Type::ARRAY) {
+  if (lb_config_array.type() != Json::Type::kArray) {
     return absl::InvalidArgumentError("type should be array");
   }
   // Find the first LB policy that this client supports.
   std::vector<absl::string_view> policies_tried;
-  for (const Json& lb_config : lb_config_array.array_value()) {
-    if (lb_config.type() != Json::Type::OBJECT) {
+  for (const Json& lb_config : lb_config_array.array()) {
+    if (lb_config.type() != Json::Type::kObject) {
       return absl::InvalidArgumentError("child entry should be of type object");
     }
-    if (lb_config.object_value().empty()) {
+    if (lb_config.object().empty()) {
       return absl::InvalidArgumentError("no policy found in child entry");
     }
-    if (lb_config.object_value().size() > 1) {
+    if (lb_config.object().size() > 1) {
       return absl::InvalidArgumentError("oneOf violation");
     }
-    auto it = lb_config.object_value().begin();
-    if (it->second.type() != Json::Type::OBJECT) {
+    auto it = lb_config.object().begin();
+    if (it->second.type() != Json::Type::kObject) {
       return absl::InvalidArgumentError("child entry should be of type object");
     }
     // If we support this policy, then select it.

data/src/core/lib/load_balancing/subchannel_interface.h

@@ -97,6 +97,9 @@ class SubchannelInterface : public DualRefCounted<SubchannelInterface> {
   // Registers a new data watcher.
   virtual void AddDataWatcher(
       std::unique_ptr<DataWatcherInterface> watcher) = 0;
+
+  // Cancels a data watch.
+  virtual void CancelDataWatcher(DataWatcherInterface* watcher) = 0;
 };
 
 // A class that delegates to another subchannel, to be used in cases
@@ -125,6 +128,9 @@ class DelegatingSubchannel : public SubchannelInterface {
   void AddDataWatcher(std::unique_ptr<DataWatcherInterface> watcher) override {
     wrapped_subchannel_->AddDataWatcher(std::move(watcher));
   }
+  void CancelDataWatcher(DataWatcherInterface* watcher) override {
+    wrapped_subchannel_->CancelDataWatcher(watcher);
+  }
 
  private:
   RefCountedPtr<SubchannelInterface> wrapped_subchannel_;

data/src/core/lib/matchers/matchers.cc

@@ -16,7 +16,6 @@
 
 #include "src/core/lib/matchers/matchers.h"
 
-#include <initializer_list>
 #include <utility>
 
 #include "absl/status/status.h"
@@ -159,12 +158,11 @@ std::string StringMatcher::ToString() const {
 absl::StatusOr<HeaderMatcher> HeaderMatcher::Create(
     absl::string_view name, Type type, absl::string_view matcher,
     int64_t range_start, int64_t range_end, bool present_match,
-    bool invert_match) {
+    bool invert_match, bool case_sensitive) {
   if (static_cast<int>(type) < 5) {
     // Only for EXACT, PREFIX, SUFFIX, SAFE_REGEX and CONTAINS.
-    absl::StatusOr<StringMatcher> string_matcher =
-        StringMatcher::Create(static_cast<StringMatcher::Type>(type), matcher,
-                              /*case_sensitive=*/true);
+    absl::StatusOr<StringMatcher> string_matcher = StringMatcher::Create(
+        static_cast<StringMatcher::Type>(type), matcher, case_sensitive);
     if (!string_matcher.ok()) {
       return string_matcher.status();
     }

data/src/core/lib/matchers/matchers.h

@@ -113,7 +113,8 @@ class HeaderMatcher {
                                               int64_t range_start = 0,
                                               int64_t range_end = 0,
                                               bool present_match = false,
-                                              bool invert_match = false);
+                                              bool invert_match = false,
+                                              bool case_sensitive = true);
 
   HeaderMatcher() = default;
   HeaderMatcher(const HeaderMatcher& other);

data/src/core/lib/promise/activity.cc

@@ -18,7 +18,6 @@
 
 #include <stddef.h>
 
-#include <initializer_list>
 #include <vector>
 
 #include "absl/strings/str_cat.h"
@@ -83,6 +82,26 @@ class FreestandingActivity::Handle final : public Wakeable {
     Unref();
   }
 
+  void WakeupAsync(WakeupMask) override ABSL_LOCKS_EXCLUDED(mu_) {
+    mu_.Lock();
+    // Note that activity refcount can drop to zero, but we could win the lock
+    // against DropActivity, so we need to only increase activities refcount if
+    // it is non-zero.
+    if (activity_ && activity_->RefIfNonzero()) {
+      FreestandingActivity* activity = activity_;
+      mu_.Unlock();
+      // Activity still exists and we have a reference: wake it up, which will
+      // drop the ref.
+      activity->WakeupAsync(0);
+    } else {
+      // Could not get the activity - it's either gone or going. No need to wake
+      // it up!
+      mu_.Unlock();
+    }
+    // Drop the ref to the handle (we have one ref = one wakeup semantics).
+    Unref();
+  }
+
   void Drop(WakeupMask) override { Unref(); }
 
   std::string ActivityDebugTag(WakeupMask) const override {

data/src/core/lib/promise/activity.h

@@ -56,6 +56,9 @@ class Wakeable {
   // WakeupMask comes from the activity that created this Wakeable and specifies
   // the set of promises that should be awoken.
   virtual void Wakeup(WakeupMask wakeup_mask) = 0;
+  // Per Wakeup, but guarantee that the activity will be woken up out-of-line.
+  // Useful if there may be mutexes or the like held by the current thread.
+  virtual void WakeupAsync(WakeupMask wakeup_mask) = 0;
   // Drop this wakeable without waking up the underlying activity.
   virtual void Drop(WakeupMask wakeup_mask) = 0;
 
@@ -69,6 +72,7 @@ class Wakeable {
 namespace promise_detail {
 struct Unwakeable final : public Wakeable {
   void Wakeup(WakeupMask) override {}
+  void WakeupAsync(WakeupMask) override {}
   void Drop(WakeupMask) override {}
   std::string ActivityDebugTag(WakeupMask) const override;
 };
@@ -96,6 +100,8 @@ class Waker {
   // Wake the underlying activity.
   void Wakeup() { Take().Wakeup(); }
 
+  void WakeupAsync() { Take().WakeupAsync(); }
+
   template <typename H>
   friend H AbslHashValue(H h, const Waker& w) {
     return H::combine(H::combine(std::move(h), w.wakeable_and_arg_.wakeable),
@@ -125,6 +131,7 @@ class Waker {
     WakeupMask wakeup_mask;
 
     void Wakeup() { wakeable->Wakeup(wakeup_mask); }
+    void WakeupAsync() { wakeable->WakeupAsync(wakeup_mask); }
     void Drop() { wakeable->Drop(wakeup_mask); }
     std::string ActivityDebugTag() const {
       return wakeable == nullptr ? "<unknown>"
@@ -494,7 +501,7 @@ class PromiseActivity final
   // the activity to an external threadpool to run. If the activity is already
   // running on this thread, a note is taken of such and the activity is
   // repolled if it doesn't complete.
-  void Wakeup(WakeupMask) final {
+  void Wakeup(WakeupMask m) final {
     // If there is an active activity, but hey it's us, flag that and we'll loop
     // in RunLoop (that's calling from above here!).
     if (Activity::is_current()) {
@@ -503,6 +510,10 @@ class PromiseActivity final
       WakeupComplete();
       return;
     }
+    WakeupAsync(m);
+  }
+
+  void WakeupAsync(WakeupMask) final {
     if (!wakeup_scheduled_.exchange(true, std::memory_order_acq_rel)) {
       // Can't safely run, so ask to run later.
       this->ScheduleWakeup();

data/src/core/lib/promise/all_ok.h

@@ -0,0 +1,80 @@
+// Copyright 2021 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_SRC_CORE_LIB_PROMISE_ALL_OK_H
+#define GRPC_SRC_CORE_LIB_PROMISE_ALL_OK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <tuple>
+#include <variant>
+
+#include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/promise/detail/join_state.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/status_flag.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+// Traits object to pass to JoinState
+template <typename Result>
+struct AllOkTraits {
+  template <typename T>
+  using ResultType = Result;
+  template <typename T>
+  static bool IsOk(const T& x) {
+    return IsStatusOk(x);
+  }
+  static Empty Unwrapped(StatusFlag) { return Empty{}; }
+  static Empty Unwrapped(absl::Status) { return Empty{}; }
+  template <typename R, typename T>
+  static R EarlyReturn(T&& x) {
+    return StatusCast<R>(std::forward<T>(x));
+  }
+  template <typename... A>
+  static Result FinalReturn(A&&...) {
+    return Result{};
+  }
+};
+
+// Implementation of AllOk combinator.
+template <typename Result, typename... Promises>
+class AllOk {
+ public:
+  explicit AllOk(Promises... promises) : state_(std::move(promises)...) {}
+  auto operator()() { return state_.PollOnce(); }
+
+ private:
+  JoinState<AllOkTraits<Result>, Promises...> state_;
+};
+
+}  // namespace promise_detail
+
+// Run all promises.
+// If any fail, cancel the rest and return the failure.
+// If all succeed, return Ok.
+template <typename Result, typename... Promises>
+auto AllOk(Promises... promises) {
+  return promise_detail::AllOk<Result, Promises...>(std::move(promises)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_ALL_OK_H

data/src/core/lib/promise/arena_promise.h

@@ -19,6 +19,7 @@
 
 #include <stdlib.h>
 
+#include <cstddef>
 #include <memory>
 #include <type_traits>
 #include <utility>
@@ -34,7 +35,10 @@ namespace grpc_core {
 
 namespace arena_promise_detail {
 
-using ArgType = std::aligned_storage_t<sizeof(void*)>;
+struct ArgType {
+  alignas(std::max_align_t) char buffer[sizeof(void*)];
+};
+
 template <typename T>
 T*& ArgAsPtr(ArgType* arg) {
   static_assert(sizeof(ArgType) >= sizeof(T**),

data/src/core/lib/promise/cancel_callback.h

@@ -17,8 +17,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <utility>
-
 #include "src/core/lib/promise/detail/promise_like.h"
 
 namespace grpc_core {

data/src/core/lib/promise/context.h

@@ -17,7 +17,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <type_traits>
 #include <utility>
 
 #include <grpc/support/log.h>