grpc 1.53.0 → 1.54.2

data/src/core/lib/transport/transport.h

@@ -27,6 +27,7 @@
 
 #include <functional>
 #include <string>
+#include <type_traits>
 #include <utility>
 
 #include "absl/status/status.h"
@@ -36,7 +37,6 @@
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
-#include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
@@ -54,6 +54,7 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/status.h"
+#include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
@@ -106,6 +107,8 @@ class Message {
   SliceBuffer* payload() { return &payload_; }
   const SliceBuffer* payload() const { return &payload_; }
 
+  std::string DebugString() const;
+
  private:
   SliceBuffer payload_;
   uint32_t flags_ = 0;
@@ -144,11 +147,70 @@ struct StatusCastImpl<ServerMetadataHandle, absl::Status&> {
   }
 };
 
+// Move only type that tracks call startup.
+// Allows observation of when client_initial_metadata has been processed by the
+// end of the local call stack.
+// Interested observers can call Wait() to obtain a promise that will resolve
+// when all local client_initial_metadata processing has completed.
+// The result of this token is either true on successful completion, or false
+// if the metadata was not sent.
+// To set a successful completion, call Complete(true). For failure, call
+// Complete(false).
+// If Complete is not called, the destructor of a still held token will complete
+// with failure.
+// Transports should hold this token until client_initial_metadata has passed
+// any flow control (eg MAX_CONCURRENT_STREAMS for http2).
+class ClientInitialMetadataOutstandingToken {
+ public:
+  static ClientInitialMetadataOutstandingToken Empty() {
+    return ClientInitialMetadataOutstandingToken();
+  }
+  static ClientInitialMetadataOutstandingToken New(
+      Arena* arena = GetContext<Arena>()) {
+    ClientInitialMetadataOutstandingToken token;
+    token.latch_ = arena->New<Latch<bool>>();
+    return token;
+  }
+
+  ClientInitialMetadataOutstandingToken(
+      const ClientInitialMetadataOutstandingToken&) = delete;
+  ClientInitialMetadataOutstandingToken& operator=(
+      const ClientInitialMetadataOutstandingToken&) = delete;
+  ClientInitialMetadataOutstandingToken(
+      ClientInitialMetadataOutstandingToken&& other) noexcept
+      : latch_(std::exchange(other.latch_, nullptr)) {}
+  ClientInitialMetadataOutstandingToken& operator=(
+      ClientInitialMetadataOutstandingToken&& other) noexcept {
+    latch_ = std::exchange(other.latch_, nullptr);
+    return *this;
+  }
+  ~ClientInitialMetadataOutstandingToken() {
+    if (latch_ != nullptr) latch_->Set(false);
+  }
+  void Complete(bool success) { std::exchange(latch_, nullptr)->Set(success); }
+
+  // Returns a promise that will resolve when this object (or its moved-from
+  // ancestor) is dropped.
+  auto Wait() { return latch_->Wait(); }
+
+ private:
+  ClientInitialMetadataOutstandingToken() = default;
+
+  Latch<bool>* latch_ = nullptr;
+};
+
+using ClientInitialMetadataOutstandingTokenWaitType =
+    decltype(std::declval<ClientInitialMetadataOutstandingToken>().Wait());
+
 struct CallArgs {
   // Initial metadata from the client to the server.
   // During promise setup this can be manipulated by filters (and then
   // passed on to the next filter).
   ClientMetadataHandle client_initial_metadata;
+  // Token indicating that client_initial_metadata is still being processed.
+  // This should be moved around and only destroyed when the transport is
+  // satisfied that the metadata has passed any flow control measures it has.
+  ClientInitialMetadataOutstandingToken client_initial_metadata_outstanding;
   // Initial metadata from the server to the client.
   // Set once when it's available.
   // During promise setup filters can substitute their own latch for this
@@ -331,6 +393,12 @@ struct grpc_transport_stream_op_batch {
   /// Is this stream traced
   bool is_traced : 1;
 
+  bool HasOp() const {
+    return send_initial_metadata || send_trailing_metadata || send_message ||
+           recv_initial_metadata || recv_message || recv_trailing_metadata ||
+           cancel_stream;
+  }
+
   //**************************************************************************
   // remaining fields are initialized and used at the discretion of the
   // current handler of the op
@@ -344,12 +412,6 @@ struct grpc_transport_stream_op_batch_payload {
       : context(context) {}
   struct {
     grpc_metadata_batch* send_initial_metadata = nullptr;
-    // If non-NULL, will be set by the transport to the peer string (a char*).
-    // The transport retains ownership of the string.
-    // Note: This pointer may be used by the transport after the
-    // send_initial_metadata op is completed.  It must remain valid
-    // until the call is destroyed.
-    gpr_atm* peer_string = nullptr;
   } send_initial_metadata;
 
   struct {
@@ -394,12 +456,6 @@ struct grpc_transport_stream_op_batch_payload {
     // uses this to set the success flag of OnReadInitialMetadataDone()
     // callback.
     bool* trailing_metadata_available = nullptr;
-    // If non-NULL, will be set by the transport to the peer string (a char*).
-    // The transport retains ownership of the string.
-    // Note: This pointer may be used by the transport after the
-    // recv_initial_metadata op is completed.  It must remain valid
-    // until the call is destroyed.
-    gpr_atm* peer_string = nullptr;
   } recv_initial_metadata;
 
   struct {
@@ -546,7 +602,7 @@ void grpc_transport_stream_op_batch_finish_with_failure_from_transport(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error);
 
 std::string grpc_transport_stream_op_batch_string(
-    grpc_transport_stream_op_batch* op);
+    grpc_transport_stream_op_batch* op, bool truncate);
 std::string grpc_transport_op_string(grpc_transport_op* op);
 
 // Send a batch of operations on a transport

data/src/core/lib/transport/transport_impl.h

@@ -38,6 +38,13 @@ typedef struct grpc_transport_vtable {
   // layers and initialized by the transport
   size_t sizeof_stream;  // = sizeof(transport stream)
 
+  // HACK: inproc does not handle stream op batch callbacks correctly (receive
+  // ops are required to complete prior to on_complete triggering).
+  // This flag is used to disable coalescing of batches in connected_channel for
+  // that specific transport.
+  // TODO(ctiller): This ought not be necessary once we have promises complete.
+  bool hacky_disable_stream_op_batch_coalescing_in_connected_channel;
+
   // name of this transport implementation
   const char* name;
 

data/src/core/lib/transport/transport_op_string.cc

@@ -18,15 +18,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <algorithm>
 #include <initializer_list>
 #include <memory>
 #include <string>
-#include <vector>
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 
 #include <grpc/support/log.h>
 
@@ -44,105 +41,118 @@
 // representations of various transport data structures
 
 std::string grpc_transport_stream_op_batch_string(
-    grpc_transport_stream_op_batch* op) {
-  std::vector<std::string> out;
+    grpc_transport_stream_op_batch* op, bool truncate) {
+  std::string out;
 
   if (op->send_initial_metadata) {
-    out.push_back(" SEND_INITIAL_METADATA{");
-    out.push_back(op->payload->send_initial_metadata.send_initial_metadata
-                      ->DebugString());
-    out.push_back("}");
+    absl::StrAppend(&out, " SEND_INITIAL_METADATA{");
+    if (truncate) {
+      absl::StrAppend(&out, "Length=",
+                      op->payload->send_initial_metadata.send_initial_metadata
+                          ->TransportSize());
+    } else {
+      absl::StrAppend(&out, op->payload->send_initial_metadata
+                                .send_initial_metadata->DebugString());
+    }
+    absl::StrAppend(&out, "}");
   }
 
   if (op->send_message) {
     if (op->payload->send_message.send_message != nullptr) {
-      out.push_back(absl::StrFormat(
-          " SEND_MESSAGE:flags=0x%08x:len=%d", op->payload->send_message.flags,
-          op->payload->send_message.send_message->Length()));
+      absl::StrAppendFormat(&out, " SEND_MESSAGE:flags=0x%08x:len=%d",
+                            op->payload->send_message.flags,
+                            op->payload->send_message.send_message->Length());
     } else {
       // This can happen when we check a batch after the transport has
       // processed and cleared the send_message op.
-      out.push_back(" SEND_MESSAGE(flag and length unknown, already orphaned)");
+      absl::StrAppend(
+          &out, " SEND_MESSAGE(flag and length unknown, already orphaned)");
     }
   }
 
   if (op->send_trailing_metadata) {
-    out.push_back(" SEND_TRAILING_METADATA{");
-    out.push_back(op->payload->send_trailing_metadata.send_trailing_metadata
-                      ->DebugString());
-    out.push_back("}");
+    absl::StrAppend(&out, " SEND_TRAILING_METADATA{");
+    if (truncate) {
+      absl::StrAppend(&out, "Length=",
+                      op->payload->send_trailing_metadata
+                          .send_trailing_metadata->TransportSize());
+    } else {
+      absl::StrAppend(&out, op->payload->send_trailing_metadata
+                                .send_trailing_metadata->DebugString());
+    }
+    absl::StrAppend(&out, "}");
   }
 
   if (op->recv_initial_metadata) {
-    out.push_back(" RECV_INITIAL_METADATA");
+    absl::StrAppend(&out, " RECV_INITIAL_METADATA");
   }
 
   if (op->recv_message) {
-    out.push_back(" RECV_MESSAGE");
+    absl::StrAppend(&out, " RECV_MESSAGE");
   }
 
   if (op->recv_trailing_metadata) {
-    out.push_back(" RECV_TRAILING_METADATA");
+    absl::StrAppend(&out, " RECV_TRAILING_METADATA");
   }
 
   if (op->cancel_stream) {
-    out.push_back(absl::StrCat(
-        " CANCEL:",
-        grpc_core::StatusToString(op->payload->cancel_stream.cancel_error)));
+    absl::StrAppend(
+        &out, " CANCEL:",
+        grpc_core::StatusToString(op->payload->cancel_stream.cancel_error));
   }
 
-  return absl::StrJoin(out, "");
+  return out;
 }
 
 std::string grpc_transport_op_string(grpc_transport_op* op) {
-  std::vector<std::string> out;
+  std::string out;
 
   if (op->start_connectivity_watch != nullptr) {
-    out.push_back(absl::StrFormat(
-        " START_CONNECTIVITY_WATCH:watcher=%p:from=%s",
+    absl::StrAppendFormat(
+        &out, " START_CONNECTIVITY_WATCH:watcher=%p:from=%s",
         op->start_connectivity_watch.get(),
-        grpc_core::ConnectivityStateName(op->start_connectivity_watch_state)));
+        grpc_core::ConnectivityStateName(op->start_connectivity_watch_state));
   }
 
   if (op->stop_connectivity_watch != nullptr) {
-    out.push_back(absl::StrFormat(" STOP_CONNECTIVITY_WATCH:watcher=%p",
-                                  op->stop_connectivity_watch));
+    absl::StrAppendFormat(&out, " STOP_CONNECTIVITY_WATCH:watcher=%p",
+                          op->stop_connectivity_watch);
   }
 
   if (!op->disconnect_with_error.ok()) {
-    out.push_back(absl::StrCat(
-        " DISCONNECT:", grpc_core::StatusToString(op->disconnect_with_error)));
+    absl::StrAppend(&out, " DISCONNECT:",
+                    grpc_core::StatusToString(op->disconnect_with_error));
   }
 
   if (!op->goaway_error.ok()) {
-    out.push_back(absl::StrCat(" SEND_GOAWAY:",
-                               grpc_core::StatusToString(op->goaway_error)));
+    absl::StrAppend(
+        &out, " SEND_GOAWAY:", grpc_core::StatusToString(op->goaway_error));
   }
 
   if (op->set_accept_stream) {
-    out.push_back(absl::StrFormat(" SET_ACCEPT_STREAM:%p(%p,...)",
-                                  op->set_accept_stream_fn,
-                                  op->set_accept_stream_user_data));
+    absl::StrAppendFormat(&out, " SET_ACCEPT_STREAM:%p(%p,...)",
+                          op->set_accept_stream_fn,
+                          op->set_accept_stream_user_data);
   }
 
   if (op->bind_pollset != nullptr) {
-    out.push_back(" BIND_POLLSET");
+    absl::StrAppend(&out, " BIND_POLLSET");
   }
 
   if (op->bind_pollset_set != nullptr) {
-    out.push_back(" BIND_POLLSET_SET");
+    absl::StrAppend(&out, " BIND_POLLSET_SET");
   }
 
   if (op->send_ping.on_initiate != nullptr || op->send_ping.on_ack != nullptr) {
-    out.push_back(" SEND_PING");
+    absl::StrAppend(&out, " SEND_PING");
   }
 
-  return absl::StrJoin(out, "");
+  return out;
 }
 
 void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
                       grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op) {
   gpr_log(file, line, severity, "OP[%s:%p]: %s", elem->filter->name, elem,
-          grpc_transport_stream_op_batch_string(op).c_str());
+          grpc_transport_stream_op_batch_string(op, false).c_str());
 }

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -76,8 +76,8 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   grpc_event_engine::experimental::RegisterEventEngineChannelArgPreconditioning(
       builder);
   // The order of the handshaker registration is crucial here.
-  // We want TCP connect handshaker to be registered last so that it is added to
-  // the start of the handshaker list.
+  // We want TCP connect handshaker to be registered last so that it is added
+  // to the start of the handshaker list.
   RegisterHttpConnectHandshaker(builder);
   RegisterTCPConnectHandshaker(builder);
   RegisterPriorityLbPolicy(builder);

data/src/core/tsi/alts/frame_protector/alts_frame_protector.cc

@@ -30,6 +30,7 @@
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/memory.h"
 #include "src/core/tsi/alts/crypt/gsec.h"
 #include "src/core/tsi/alts/frame_protector/alts_crypter.h"
 #include "src/core/tsi/alts/frame_protector/frame_handler.h"

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -22,6 +22,7 @@
 
 #include <list>
 
+#include "absl/strings/numbers.h"
 #include "upb/upb.hpp"
 
 #include <grpc/byte_buffer.h>
@@ -29,6 +30,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
@@ -40,6 +42,8 @@
 #define TSI_ALTS_INITIAL_BUFFER_SIZE 256
 
 const int kHandshakerClientOpNum = 4;
+const char kMaxConcurrentStreamsEnvironmentVariable[] =
+    "GRPC_ALTS_MAX_CONCURRENT_HANDSHAKES";
 
 struct alts_handshaker_client {
   const alts_handshaker_client_vtable* vtable;
@@ -419,7 +423,8 @@ HandshakeQueue* g_client_handshake_queue;
 HandshakeQueue* g_server_handshake_queue;
 
 void DoHandshakeQueuesInit(void) {
-  const size_t per_queue_max_outstanding_handshakes = 40;
+  const size_t per_queue_max_outstanding_handshakes =
+      MaxNumberOfConcurrentHandshakes();
   g_client_handshake_queue =
       new HandshakeQueue(per_queue_max_outstanding_handshakes);
   g_server_handshake_queue =
@@ -733,16 +738,14 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
   client->handshake_status_details = grpc_empty_slice();
   client->max_frame_size = max_frame_size;
   client->error = error;
-  grpc_slice slice = grpc_slice_from_copied_string(handshaker_service_url);
   client->call =
       strcmp(handshaker_service_url, ALTS_HANDSHAKER_SERVICE_URL_FOR_TESTING) ==
               0
           ? nullptr
           : grpc_channel_create_pollset_set_call(
                 channel, nullptr, GRPC_PROPAGATE_DEFAULTS, interested_parties,
-                grpc_slice_from_static_string(ALTS_SERVICE_METHOD), &slice,
+                grpc_slice_from_static_string(ALTS_SERVICE_METHOD), nullptr,
                 grpc_core::Timestamp::InfFuture(), nullptr);
-  grpc_core::CSliceUnref(slice);
   GRPC_CLOSURE_INIT(&client->on_handshaker_service_resp_recv, grpc_cb, client,
                     grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&client->on_status_received, on_status_received, client,
@@ -926,3 +929,17 @@ void alts_handshaker_client_destroy(alts_handshaker_client* c) {
     alts_grpc_handshaker_client_unref(client);
   }
 }
+
+size_t MaxNumberOfConcurrentHandshakes() {
+  size_t max_concurrent_handshakes = 40;
+  absl::optional<std::string> env_var_max_concurrent_handshakes =
+      grpc_core::GetEnv(kMaxConcurrentStreamsEnvironmentVariable);
+  if (env_var_max_concurrent_handshakes.has_value()) {
+    size_t effective_max_concurrent_handshakes = 40;
+    if (absl::SimpleAtoi(*env_var_max_concurrent_handshakes,
+                         &effective_max_concurrent_handshakes)) {
+      max_concurrent_handshakes = effective_max_concurrent_handshakes;
+    }
+  }
+  return max_concurrent_handshakes;
+}

data/src/core/tsi/alts/handshaker/alts_handshaker_client.h

@@ -157,4 +157,9 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
 void alts_handshaker_client_handle_response(alts_handshaker_client* client,
                                             bool is_ok);
 
+// Returns the max number of concurrent handshakes that are permitted.
+//
+// Exposed for testing purposes only.
+size_t MaxNumberOfConcurrentHandshakes();
+
 #endif  // GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -351,7 +351,7 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Null peer identity in ALTS context.");
     return TSI_FAILED_PRECONDITION;
   }
-  if (grpc_gcp_Identity_has_attributes(identity)) {
+  if (grpc_gcp_Identity_attributes_size(identity) != 0) {
     size_t iter = kUpb_Map_Begin;
     grpc_gcp_Identity_AttributesEntry* peer_attributes_entry =
         grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);

data/src/core/tsi/ssl_transport_security.cc

@@ -2060,7 +2060,8 @@ tsi_result tsi_create_ssl_client_handshaker_factory_with_options(
       gpr_log(GPR_ERROR, "Failed to load CRL File from directory.");
     } else {
       X509_VERIFY_PARAM* param = X509_STORE_get0_param(cert_store);
-      X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
+      X509_VERIFY_PARAM_set_flags(
+          param, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
       gpr_log(GPR_INFO, "enabled client side CRL checking.");
     }
   }
@@ -2244,7 +2245,8 @@ tsi_result tsi_create_ssl_server_handshaker_factory_with_options(
           gpr_log(GPR_ERROR, "Failed to load CRL File from directory.");
         } else {
           X509_VERIFY_PARAM* param = X509_STORE_get0_param(cert_store);
-          X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
+          X509_VERIFY_PARAM_set_flags(
+              param, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
           gpr_log(GPR_INFO, "enabled server CRL checking.");
         }
       }

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.53.0'
+  VERSION = '1.54.2'
 end

data/third_party/abseil-cpp/absl/base/config.h

@@ -112,7 +112,7 @@
 // LTS releases can be obtained from
 // https://github.com/abseil/abseil-cpp/releases.
 #define ABSL_LTS_RELEASE_VERSION 20230125
-#define ABSL_LTS_RELEASE_PATCH_LEVEL 0
+#define ABSL_LTS_RELEASE_PATCH_LEVEL 2
 
 // Helper macro to convert a CPP variable to a string literal.
 #define ABSL_INTERNAL_DO_TOKEN_STR(x) #x

data/third_party/abseil-cpp/absl/flags/commandlineflag.cc

@@ -0,0 +1,34 @@
+//
+// Copyright 2020 The Abseil 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
+//
+//      https://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.
+
+#include "absl/flags/commandlineflag.h"
+
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/flags/internal/commandlineflag.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+bool CommandLineFlag::IsRetired() const { return false; }
+bool CommandLineFlag::ParseFrom(absl::string_view value, std::string* error) {
+  return ParseFrom(value, flags_internal::SET_FLAGS_VALUE,
+                   flags_internal::kProgrammaticChange, *error);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl