grpc 1.83.2 → 1.84.0.pre1

data/include/grpc/credentials.h

@@ -60,6 +60,14 @@ grpc_service_account_jwt_access_credentials_create(const char* json_key,
 GRPCAPI grpc_call_credentials* grpc_external_account_credentials_create(
     const char* json_string, const char* scopes_string);
 
+/** Builds Google Distributed Cloud Hosting Service Account credentials.
+- json_string is the JSON string containing the service account key.
+- audience_string is the intended recipient or service.
+  This API is used for experimental purposes for now and may change in the
+ future. */
+GRPCAPI grpc_call_credentials* grpc_gdch_service_account_credentials_create(
+    const char* json_string, const char* audience_string);
+
 /** Creates an Oauth2 Refresh Token credentials object for connecting to Google.
    May return NULL if the input is invalid.
    WARNING: Do NOT use this credentials to connect to a non-google service as
@@ -765,6 +773,8 @@ typedef struct grpc_tls_custom_verification_check_request {
      * This value will only be filled if the cryptographic peer certificate
      * verification was successful */
     const char* verified_root_cert_subject;
+    /* The negotiated key exchange group. */
+    const char* negotiated_key_exchange_group;
   } peer_info;
 } grpc_tls_custom_verification_check_request;
 

data/include/grpc/grpc_security_constants.h

@@ -44,6 +44,8 @@ extern "C" {
 // https://www.openssl.org/docs/man1.1.0/man3/SSL_get_peer_cert_chain.html.
 #define GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME "x509_pem_cert_chain"
 #define GRPC_SSL_SESSION_REUSED_PROPERTY "ssl_session_reused"
+#define GRPC_SSL_NEGOTIATED_KEY_EXCHANGE_GROUP_PROPERTY_NAME \
+  "ssl_negotiated_key_exchange_group"
 #define GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME "security_level"
 #define GRPC_PEER_DNS_PROPERTY_NAME "peer_dns"
 #define GRPC_PEER_SPIFFE_ID_PROPERTY_NAME "peer_spiffe_id"

data/include/grpc/impl/channel_arg_names.h

@@ -286,6 +286,15 @@
   "grpc.experimental.tcp_min_read_chunk_size"
 #define GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE \
   "grpc.experimental.tcp_max_read_chunk_size"
+/** Channel arg (integer) setting an opt-in upper bound, in bytes, on the
+   adaptive read buffer size that a single TCP endpoint may preallocate for
+   reads. When unset (the default) the read buffer target grows as before,
+   preserving historical behavior. When set, the adaptive read target is
+   clamped to this value so occasional large reads do not leave a permanently
+   high read-buffer high-watermark. Unlike GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE,
+   this does not change per-socket slice sizing. **/
+#define GRPC_ARG_TCP_MAX_READ_BUFFER_SIZE \
+  "grpc.experimental.tcp_max_read_buffer_size"
 /* TCP TX Zerocopy enable state: zero is disabled, non-zero is enabled. By
    default, it is disabled. */
 #define GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED \

data/src/core/call/call_filters.h

@@ -89,7 +89,8 @@
 //   failure (in which case the call will be aborted).
 //   useful for cases where the exact metadata returned needs to be customized.
 // It's also acceptable to return a promise that resolves to the
-// relevant return type listed above.
+// relevant return type listed above (except for OnClientToServerHalfClose
+// and OnServerTrailingMetadata, which must be synchronous).
 //
 // OnFinalize is added to intercept call finalization.
 // It must have one of the signatures:
@@ -1983,7 +1984,8 @@ class CallFilters {
     return flag;
   }
   // Client: Fetch server initial metadata
-  // Returns a promise that resolves to ValueOrFailure<ServerMetadataHandle>
+  // Returns a promise that resolves to
+  // ValueOrFailure<std::optional<ServerMetadataHandle>>
   GRPC_MUST_USE_RESULT auto PullServerInitialMetadata() {
     return Seq(
         [this]() {

data/src/core/call/client_call.cc

@@ -46,6 +46,7 @@
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/surface/call_utils.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
@@ -62,7 +63,9 @@ namespace grpc_core {
 
 namespace {
 
-grpc_call_error ValidateClientBatch(const grpc_op* ops, size_t nops) {
+grpc_call_error ValidateClientBatch(
+    const grpc_op* ops, size_t nops,
+    CallOpInvariantsValidator& call_op_invariants_validator) {
   BitSet<8> got_ops;
   for (size_t op_idx = 0; op_idx < nops; op_idx++) {
     const grpc_op& op = ops[op_idx];
@@ -94,7 +97,7 @@ grpc_call_error ValidateClientBatch(const grpc_op* ops, size_t nops) {
     if (got_ops.is_set(op.op)) return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
     got_ops.set(op.op);
   }
-  return GRPC_CALL_OK;
+  return call_op_invariants_validator.ValidateAndCommit(ops, nops);
 }
 
 }  // namespace
@@ -161,7 +164,8 @@ grpc_call_error ClientCall::StartBatch(const grpc_op* ops, size_t nops,
     EndOpImmediately(cq_, notify_tag, is_notify_tag_closure);
     return GRPC_CALL_OK;
   }
-  const grpc_call_error validation_result = ValidateClientBatch(ops, nops);
+  const grpc_call_error validation_result =
+      ValidateClientBatch(ops, nops, call_op_invariants_validator_);
   if (validation_result != GRPC_CALL_OK) {
     return validation_result;
   }
@@ -325,8 +329,12 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
   }
   if (!is_notify_tag_closure) grpc_cq_begin_op(cq_, notify_tag);
   BatchOpIndex op_index(ops, nops);
-  auto send_message =
-      op_index.OpHandler<GRPC_OP_SEND_MESSAGE>([this](const grpc_op& op) {
+  uint8_t concurrent_ops_to_reset = 0;
+
+  auto send_message = op_index.OpHandler<GRPC_OP_SEND_MESSAGE>(
+      [this, &concurrent_ops_to_reset](const grpc_op& op) {
+        concurrent_ops_to_reset |=
+            CallOpInvariantsValidator::OpBit(GRPC_OP_SEND_MESSAGE);
         SliceBuffer send;
         grpc_slice_buffer_swap(
             &op.data.send_message.send_message->data.raw.slice_buffer,
@@ -344,8 +352,10 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
               return Success{};
             };
           });
-  auto recv_message =
-      op_index.OpHandler<GRPC_OP_RECV_MESSAGE>([this](const grpc_op& op) {
+  auto recv_message = op_index.OpHandler<GRPC_OP_RECV_MESSAGE>(
+      [this, &concurrent_ops_to_reset](const grpc_op& op) {
+        concurrent_ops_to_reset |=
+            CallOpInvariantsValidator::OpBit(GRPC_OP_RECV_MESSAGE);
         return message_receiver_.MakeBatchOp(op, &started_call_initiator_);
       });
   auto recv_initial_metadata =
@@ -382,7 +392,9 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
       AllOk<StatusFlag>(
           TrySeq(std::move(send_message), std::move(send_close_from_client)),
           TrySeq(std::move(recv_initial_metadata), std::move(recv_message))),
-      [self = WeakRef()](StatusFlag x) { return x; });
+      [guard = PrimaryOpsCleanup<ClientCall>(WeakRefAsSubclass<ClientCall>(),
+                                             concurrent_ops_to_reset)](
+          StatusFlag x) { return x; });
   Party::WakeupHold wakeup_hold;
   if (const grpc_op* op = op_index.op(GRPC_OP_SEND_INITIAL_METADATA)) {
     wakeup_hold = StartCall(*op);

data/src/core/call/client_call.h

@@ -133,6 +133,9 @@ class ClientCall final
     UnorderedStart* next;
   };
 
+  template <typename T>
+  friend class PrimaryOpsCleanup;
+
   void CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                    bool is_notify_tag_closure);
   template <typename Batch>
@@ -178,6 +181,7 @@ class ClientCall final
   // otherwise the server trailing metadata from started_call_initiator_ is
   // authoritative.
   SingleSetPtr<absl::Status> cancel_status_;
+  CallOpInvariantsValidator call_op_invariants_validator_;
   MessageReceiver message_receiver_;
   grpc_completion_queue* const cq_;
   const RefCountedPtr<UnstartedCallDestination> call_destination_;

data/src/core/call/interception_chain.cc

@@ -146,9 +146,11 @@ InterceptionChainBuilder::Build(FinalDestination final_destination) {
   }
   Interceptor* previous = top_interceptor_.get();
   while (previous->wrapped_destination_ != nullptr) {
+    previous->Init(args_);
     previous = DownCast<Interceptor*>(previous->wrapped_destination_.get());
   }
   previous->wrapped_destination_ = std::move(terminator);
+  previous->Init(args_);
   return std::move(top_interceptor_);
 }
 

data/src/core/call/interception_chain.h

@@ -93,7 +93,6 @@ class HijackedCall final {
 // preceding filters.  We don't actually have any use-case for seeing
 // the unprocessed initial metadata and deciding to do a PassThrough(),
 // and its presence in this API is confusing.
-
 class Interceptor : public UnstartedCallDestination {
  public:
   using UnstartedCallDestination::UnstartedCallDestination;
@@ -106,6 +105,11 @@ class Interceptor : public UnstartedCallDestination {
   }
 
  protected:
+  // Performs initialization steps after the interception chain has been
+  // constructed.  In particular, wrapped_destination() may be called
+  // from inside this method.
+  virtual void Init(const ChannelArgs& args) {}
+
   virtual void InterceptCall(UnstartedCallHandler unstarted_call_handler) = 0;
 
   // Returns a promise that resolves to a HijackedCall instance.
@@ -141,6 +145,15 @@ class Interceptor : public UnstartedCallDestination {
     wrapped_destination_->StartCall(std::move(unstarted_call_handler));
   }
 
+  // The next call destination in the interception chain.  To be used by
+  // interceptors that need to delegate to their own interception chains.
+  //
+  // Note: This will not return a useful value until Init() has been
+  // called -- do NOT call this from within the ctor.
+  RefCountedPtr<UnstartedCallDestination> wrapped_destination() const {
+    return wrapped_destination_;
+  }
+
  private:
   friend class InterceptionChainBuilder;
 

data/src/core/call/metadata.cc

@@ -44,9 +44,7 @@ absl::Status ServerMetadataToStatus(ServerMetadata& md) {
   absl::string_view message = error_slice != nullptr
                                   ? error_slice->as_string_view()
                                   : absl::string_view();
-  return grpc_error_set_int(
-      absl::Status(static_cast<absl::StatusCode>(grpc_status), message),
-      StatusIntProperty::kRpcStatus, grpc_status);
+  return absl::Status(static_cast<absl::StatusCode>(grpc_status), message);
 }
 
 void SetServerMetadataFromStatus(ServerMetadata& md,

data/src/core/call/metadata_batch.h

@@ -594,6 +594,14 @@ struct GrpcStreamNetworkState {
   static std::string DisplayValue(ValueType x);
 };
 
+// Annotation added to indicate that the LB policy dropped the call.
+struct LbPolicyDrop {
+  static absl::string_view DebugKey() { return "LbPolicyDrop"; }
+  static constexpr bool kRepeatable = false;
+  using ValueType = bool;
+  static absl::string_view DisplayValue(bool x) { return x ? "true" : "false"; }
+};
+
 // Annotation added by a server transport to note the peer making a request.
 struct PeerString {
   static absl::string_view DebugKey() { return "PeerString"; }
@@ -1752,11 +1760,11 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::XEnvoyPeerMetadata, grpc_core::XForwardedForMetadata,
     grpc_core::XForwardedHostMetadata, grpc_core::W3CTraceParentMetadata,
     // Non-encodable things
-    grpc_core::GrpcStreamNetworkState, grpc_core::PeerString,
-    grpc_core::GrpcStatusContext, grpc_core::GrpcStatusFromWire,
-    grpc_core::GrpcCallWasCancelled, grpc_core::WaitForReady,
-    grpc_core::IsTransparentRetry, grpc_core::GrpcTrailersOnly,
-    grpc_core::GrpcTarPit,
+    grpc_core::GrpcStreamNetworkState, grpc_core::LbPolicyDrop,
+    grpc_core::PeerString, grpc_core::GrpcStatusContext,
+    grpc_core::GrpcStatusFromWire, grpc_core::GrpcCallWasCancelled,
+    grpc_core::WaitForReady, grpc_core::IsTransparentRetry,
+    grpc_core::GrpcTrailersOnly, grpc_core::GrpcTarPit,
     grpc_core::GrpcRegisteredMethod GRPC_CUSTOM_CLIENT_METADATA
         GRPC_CUSTOM_SERVER_METADATA>;
 

data/src/core/call/server_call.cc

@@ -33,6 +33,7 @@
 #include <string.h>
 
 #include <atomic>
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
@@ -46,6 +47,7 @@
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/surface/call_utils.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/server/server_interface.h"
 #include "src/core/util/bitset.h"
@@ -57,7 +59,9 @@ namespace grpc_core {
 
 namespace {
 
-grpc_call_error ValidateServerBatch(const grpc_op* ops, size_t nops) {
+grpc_call_error ValidateServerBatch(
+    const grpc_op* ops, size_t nops,
+    CallOpInvariantsValidator& call_op_invariants_validator) {
   BitSet<8> got_ops;
   for (size_t op_idx = 0; op_idx < nops; op_idx++) {
     const grpc_op& op = ops[op_idx];
@@ -96,7 +100,7 @@ grpc_call_error ValidateServerBatch(const grpc_op* ops, size_t nops) {
     if (got_ops.is_set(op.op)) return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
     got_ops.set(op.op);
   }
-  return GRPC_CALL_OK;
+  return call_op_invariants_validator.ValidateAndCommit(ops, nops);
 }
 
 }  // namespace
@@ -120,7 +124,8 @@ grpc_call_error ServerCall::StartBatch(const grpc_op* ops, size_t nops,
     EndOpImmediately(cq_, notify_tag, is_notify_tag_closure);
     return GRPC_CALL_OK;
   }
-  const grpc_call_error validation_result = ValidateServerBatch(ops, nops);
+  const grpc_call_error validation_result =
+      ValidateServerBatch(ops, nops, call_op_invariants_validator_);
   if (validation_result != GRPC_CALL_OK) {
     return validation_result;
   }
@@ -131,23 +136,33 @@ grpc_call_error ServerCall::StartBatch(const grpc_op* ops, size_t nops,
 void ServerCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                              bool is_notify_tag_closure) {
   BatchOpIndex op_index(ops, nops);
+  uint8_t concurrent_ops_to_reset = 0;
   if (!is_notify_tag_closure) grpc_cq_begin_op(cq_, notify_tag);
 
   auto commit_with_send_ops = [&](auto send_ops) {
-    auto recv_message =
-        op_index.OpHandler<GRPC_OP_RECV_MESSAGE>([this](const grpc_op& op) {
+    auto recv_message = op_index.OpHandler<GRPC_OP_RECV_MESSAGE>(
+        [this, &concurrent_ops_to_reset](const grpc_op& op) {
+          concurrent_ops_to_reset |=
+              CallOpInvariantsValidator::OpBit(GRPC_OP_RECV_MESSAGE);
           return message_receiver_.MakeBatchOp(op, &call_handler_);
         });
+    auto self = this->template WeakRefAsSubclass<ServerCall>();
     auto primary_ops =
-        AllOk<StatusFlag>(std::move(send_ops), std::move(recv_message));
+        Map(AllOk<StatusFlag>(std::move(send_ops), std::move(recv_message)),
+            [guard = PrimaryOpsCleanup<ServerCall>(
+                 std::move(self), concurrent_ops_to_reset)](StatusFlag x) {
+              return x;
+            });
+
     if (auto* op = op_index.op(GRPC_OP_RECV_CLOSE_ON_SERVER)) {
       auto recv_trailing_metadata = OpHandler<GRPC_OP_RECV_CLOSE_ON_SERVER>(
-          [this, cancelled = op->data.recv_close_on_server.cancelled]() {
-            return Map(call_handler_.WasCancelled(),
-                       [cancelled, this](bool result) -> Success {
-                         saw_was_cancelled_.store(true,
-                                                  std::memory_order_relaxed);
-                         ResetDeadline();
+          [self = WeakRef(),
+           cancelled = op->data.recv_close_on_server.cancelled]() {
+            return Map(self->call_handler_.WasCancelled(),
+                       [cancelled, self](bool result) -> Success {
+                         self->saw_was_cancelled_.store(
+                             true, std::memory_order_relaxed);
+                         self->ResetDeadline();
                          *cancelled = result ? 1 : 0;
                          return Success{};
                        });
@@ -232,8 +247,10 @@ void ServerCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                     std::move(metadata));
               };
             });
-    auto send_message =
-        op_index.OpHandler<GRPC_OP_SEND_MESSAGE>([this](const grpc_op& op) {
+    auto send_message = op_index.OpHandler<GRPC_OP_SEND_MESSAGE>(
+        [this, &concurrent_ops_to_reset](const grpc_op& op) {
+          concurrent_ops_to_reset |=
+              CallOpInvariantsValidator::OpBit(GRPC_OP_SEND_MESSAGE);
           SliceBuffer send;
           grpc_slice_buffer_swap(
               &op.data.send_message.send_message->data.raw.slice_buffer,

data/src/core/call/server_call.h

@@ -158,12 +158,16 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
   }
 
  private:
+  template <typename T>
+  friend class PrimaryOpsCleanup;
+
   void CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                    bool is_notify_tag_closure);
 
   std::string DebugTag() { return absl::StrFormat("SERVER_CALL[%p]: ", this); }
 
   CallHandler call_handler_;
+  CallOpInvariantsValidator call_op_invariants_validator_;
   std::atomic<bool> sent_server_initial_metadata_batch_{false};
   Latch<void> server_initial_metadata_scheduled_;
   MessageReceiver message_receiver_;

data/src/core/channelz/text_encode.cc

@@ -56,10 +56,15 @@ std::string TextEncode(upb_Message* message,
   auto* def = getmsgdef(def_pool);
   size_t size = upb_TextEncode(message, def, def_pool, 0, buf, sizeof(buf));
   if (size < sizeof(buf)) return std::string(buf, size);
-  char* new_buf = new char[size];
-  upb_TextEncode(message, def, def_pool, 0, new_buf, size);
-  std::string result(new_buf, size);
-  delete[] new_buf;
+  // upb_TextEncode has snprintf() semantics: it always NUL-terminates
+  // within the given capacity, so writing size content bytes requires
+  // a capacity of size + 1. We allocate size + 1 bytes in the string,
+  // let upb_TextEncode write the content and the NUL terminator, and then
+  // resize the string back to size to remove the NUL terminator from the
+  // string's active length.
+  std::string result(size + 1, '\0');
+  upb_TextEncode(message, def, def_pool, 0, result.data(), result.size());
+  result.resize(size);
   return result;
 }
 

data/src/core/channelz/v2tov1/convert.cc

@@ -22,6 +22,8 @@
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/timestamp.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "grpc/channelz/v1/channelz.upb.h"
+#include "grpc/channelz/v1/channelz.upbdefs.h"
 #include "src/core/channelz/v2tov1/property_list.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -29,8 +31,6 @@
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/upb_utils.h"
 #include "src/core/util/uri.h"
-#include "src/proto/grpc/channelz/channelz.upb.h"
-#include "src/proto/grpc/channelz/channelz.upbdefs.h"
 #include "src/proto/grpc/channelz/v2/channelz.upb.h"
 #include "src/proto/grpc/channelz/v2/property_list.upb.h"
 #include "upb/base/status.h"

data/src/core/client_channel/backup_poller.cc

@@ -63,8 +63,7 @@ static bool g_backup_polling_disabled;
 
 void grpc_client_channel_global_init_backup_polling() {
   g_backup_polling_disabled = grpc_core::IsEventEngineClientEnabled() &&
-                              grpc_core::IsEventEngineListenerEnabled() &&
-                              grpc_core::IsEventEngineDnsEnabled();
+                              grpc_core::IsEventEngineListenerEnabled();
   if (g_backup_polling_disabled) {
     return;
   }

data/src/core/client_channel/client_channel.cc

@@ -275,39 +275,6 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
         << subchannel_wrapper_->subchannel_.get()
         << " watcher=" << watcher_.get()
         << " state=" << ConnectivityStateName(state) << " status=" << status;
-    if (!IsSubchannelConnectionScalingEnabled()) {
-      auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
-      if (keepalive_throttling.has_value()) {
-        int new_keepalive_time_ms = -1;
-        if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
-                             &new_keepalive_time_ms)) {
-          Duration new_keepalive_time =
-              Duration::Milliseconds(new_keepalive_time_ms);
-          if (new_keepalive_time >
-              subchannel_wrapper_->client_channel_->keepalive_time_) {
-            subchannel_wrapper_->client_channel_->keepalive_time_ =
-                new_keepalive_time;
-            GRPC_TRACE_LOG(client_channel, INFO)
-                << "client_channel="
-                << subchannel_wrapper_->client_channel_.get()
-                << ": throttling keepalive time to "
-                << subchannel_wrapper_->client_channel_->keepalive_time_;
-            // Propagate the new keepalive time to all subchannels. This is so
-            // that new transports created by any subchannel (and not just the
-            // subchannel that received the GOAWAY), use the new keepalive time.
-            for (auto& [subchannel, _] :
-                 subchannel_wrapper_->client_channel_->subchannel_map_) {
-              subchannel->ThrottleKeepaliveTime(new_keepalive_time);
-            }
-          }
-        } else {
-          LOG(ERROR) << "client_channel="
-                     << subchannel_wrapper_->client_channel_.get()
-                     << ": Illegal keepalive throttling value "
-                     << std::string(keepalive_throttling.value());
-        }
-      }
-    }
     // Propagate status only in state TF.
     // We specifically want to avoid propagating the status for
     // state IDLE that the real subchannel gave us only for the
@@ -586,6 +553,12 @@ absl::StatusOr<RefCountedPtr<Channel>> ClientChannel::Create(
   if (target.empty()) {
     return absl::InternalError("target URI is empty in client channel");
   }
+  auto channel_args_mutator =
+      grpc_channel_args_get_client_channel_creation_mutator();
+  if (channel_args_mutator != nullptr) {
+    channel_args =
+        channel_args_mutator(target.c_str(), channel_args, GRPC_CLIENT_CHANNEL);
+  }
   std::string uri_to_resolve = CoreConfiguration::Get()
                                    .proxy_mapper_registry()
                                    .MapName(target, &channel_args)

data/src/core/client_channel/client_channel_filter.cc

@@ -602,35 +602,6 @@ class ClientChannelFilter::SubchannelWrapper final
           << parent_.get() << " subchannel " << parent_->subchannel_.get()
           << " watcher=" << watcher_.get()
           << " state=" << ConnectivityStateName(state) << " status=" << status;
-      if (!IsSubchannelConnectionScalingEnabled()) {
-        auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
-        if (keepalive_throttling.has_value()) {
-          int new_keepalive_time_ms = -1;
-          if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
-                               &new_keepalive_time_ms)) {
-            Duration new_keepalive_time =
-                Duration::Milliseconds(new_keepalive_time_ms);
-            if (new_keepalive_time > parent_->chand_->keepalive_time_) {
-              parent_->chand_->keepalive_time_ = new_keepalive_time;
-              GRPC_TRACE_LOG(client_channel, INFO)
-                  << "chand=" << parent_->chand_
-                  << ": throttling keepalive time to "
-                  << parent_->chand_->keepalive_time_;
-              // Propagate the new keepalive time to all subchannels. This is
-              // so that new transports created by any subchannel (and not
-              // just the subchannel that received the GOAWAY), use the new
-              // keepalive time.
-              for (auto& [subchannel, _] : parent_->chand_->subchannel_map_) {
-                subchannel->ThrottleKeepaliveTime(new_keepalive_time);
-              }
-            }
-          } else {
-            LOG(ERROR) << "chand=" << parent_->chand_
-                       << ": Illegal keepalive throttling value "
-                       << std::string(keepalive_throttling.value());
-          }
-        }
-      }
       // Propagate status only in state TF.
       // We specifically want to avoid propagating the status for
       // state IDLE that the real subchannel gave us only for the
@@ -1043,7 +1014,7 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
   auto service_config =
       ServiceConfigImpl::Create(channel_args_, *service_config_json);
   if (!service_config.ok()) {
-    *error = absl_status_to_grpc_error(service_config.status());
+    *error = service_config.status();
     return;
   }
   default_service_config_ = std::move(*service_config);
@@ -1555,12 +1526,12 @@ void ClientChannelFilter::UpdateStateLocked(grpc_connectivity_state state,
     if (!status.ok() || state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
       GRPC_CHANNELZ_LOG(channelz_node_)
           << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
-                 state);
+                 state)
+          << " status: " << status.ToString();
     } else {
       GRPC_CHANNELZ_LOG(channelz_node_)
           << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
-                 state)
-          << " status: " << status.ToString();
+                 state);
     }
   }
 }
@@ -1643,11 +1614,11 @@ grpc_error_handle ClientChannelFilter::DoPingLocked(grpc_transport_op* op) {
       },
       // Fail pick.
       [](LoadBalancingPolicy::PickResult::Fail* fail_pick) {
-        return absl_status_to_grpc_error(fail_pick->status);
+        return fail_pick->status;
       },
       // Drop pick.
       [](LoadBalancingPolicy::PickResult::Drop* drop_pick) {
-        return absl_status_to_grpc_error(drop_pick->status);
+        return drop_pick->status;
       });
 }
 
@@ -1683,11 +1654,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
         << "chand=" << this << ": disconnect_with_error: "
         << StatusToString(op->disconnect_with_error);
     DestroyResolverAndLbPolicyLocked();
-    intptr_t value;
-    if (grpc_error_get_int(op->disconnect_with_error,
-                           StatusIntProperty::ChannelConnectivityState,
-                           &value) &&
-        static_cast<grpc_connectivity_state>(value) == GRPC_CHANNEL_IDLE) {
+    if (op->go_idle) {
       if (disconnect_error_.ok()) {  // Ignore if we're shutting down.
         // Enter IDLE state.
         UpdateStateAndPickerLocked(GRPC_CHANNEL_IDLE, absl::Status(),
@@ -1703,7 +1670,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
       UpdateStateAndPickerLocked(
           GRPC_CHANNEL_SHUTDOWN, absl::Status(), "shutdown from API",
           MakeRefCounted<LoadBalancingPolicy::TransientFailurePicker>(
-              grpc_error_to_absl_status(op->disconnect_with_error)));
+              op->disconnect_with_error));
       // TODO(roth): If this happens when we're still waiting for a
       // resolver result, we need to trigger failures for all calls in
       // the resolver queue here.
@@ -1875,8 +1842,8 @@ grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
                           ->GetCallConfig({send_initial_metadata(), arena_,
                                            service_config_call_data});
   if (!filter_chain.ok()) {
-    return absl_status_to_grpc_error(
-        MaybeRewriteIllegalStatusCode(filter_chain.status(), "ConfigSelector"));
+    return MaybeRewriteIllegalStatusCode(filter_chain.status(),
+                                         "ConfigSelector");
   }
   dynamic_filters_ = filter_chain->TakeAsSubclass<const DynamicFilters>();
   // Apply our own method params to the call.
@@ -1946,7 +1913,7 @@ bool ClientChannelFilter::CallData::CheckResolutionLocked(
       GRPC_TRACE_LOG(client_channel_call, INFO)
           << "chand=" << chand() << " calld=" << this
           << ": resolution failed, failing call";
-      *config_selector = absl_status_to_grpc_error(resolver_error);
+      *config_selector = resolver_error;
       return true;
     }
     // Either the resolver has not yet returned a result, or it has
@@ -2482,6 +2449,9 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
 bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
     LoadBalancingPolicy::SubchannelPicker* picker, grpc_error_handle* error) {
   GRPC_CHECK(subchannel_call_ == nullptr);
+  // Adding the call arena to TLS so that LB pickers can access call context
+  // from the arena.
+  promise_detail::Context<Arena> arena_ctx(arena_);
   // Perform LB pick.
   LoadBalancingPolicy::PickArgs pick_args;
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
@@ -2554,8 +2524,8 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
         if (!send_initial_metadata()
                  ->GetOrCreatePointer(WaitForReady())
                  ->value) {
-          *error = absl_status_to_grpc_error(MaybeRewriteIllegalStatusCode(
-              std::move(fail_pick->status), "LB pick"));
+          *error = MaybeRewriteIllegalStatusCode(std::move(fail_pick->status),
+                                                 "LB pick");
           return true;
         }
         // If wait_for_ready is true, then queue to retry when we get a new
@@ -2567,10 +2537,9 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
         GRPC_TRACE_LOG(client_channel_lb_call, INFO)
             << "chand=" << chand_ << " lb_call=" << this
             << ": LB pick dropped: " << drop_pick->status;
-        *error = grpc_error_set_int(
-            absl_status_to_grpc_error(MaybeRewriteIllegalStatusCode(
-                std::move(drop_pick->status), "LB drop")),
-            StatusIntProperty::kLbPolicyDrop, 1);
+        is_drop_ = true;
+        *error = MaybeRewriteIllegalStatusCode(std::move(drop_pick->status),
+                                               "LB drop");
         return true;
       });
 }
@@ -2708,7 +2677,7 @@ void ClientChannelFilter::LoadBalancedCall::RecvTrailingMetadataReady(
       << " call_attempt_tracer_=" << self->call_attempt_tracer_
       << " lb_subchannel_call_tracker_="
       << self->lb_subchannel_call_tracker_.get()
-      << " failure_error_=" << StatusToString(self->failure_error_);
+      << " is_drop_=" << self->is_drop_;
   // Check if we have a tracer or an LB callback to invoke.
   if (self->call_attempt_tracer_ != nullptr ||
       self->lb_subchannel_call_tracker_ != nullptr) {
@@ -2742,11 +2711,9 @@ void ClientChannelFilter::LoadBalancedCall::RecvTrailingMetadataReady(
     self->RecordCallCompletion(status, self->recv_trailing_metadata_,
                                self->transport_stream_stats_, peer_string);
   }
+  // If we dropped the call, indicate that fact in the metadata.
+  if (self->is_drop_) self->recv_trailing_metadata_->Set(LbPolicyDrop(), true);
   // Chain to original callback.
-  if (!self->failure_error_.ok()) {
-    error = self->failure_error_;
-    self->failure_error_ = absl::OkStatus();
-  }
   Closure::Run(DEBUG_LOCATION, self->original_recv_trailing_metadata_ready_,
                error);
 }