grpc 1.46.2 → 1.48.0.pre1

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

@@ -18,25 +18,25 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <inttypes.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-
+#include <algorithm>
+#include <memory>
+#include <string>
 #include <vector>
 
-#include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 /* These routines are here to facilitate debugging - they produce string
    representations of various transport data structures */
@@ -54,10 +54,9 @@ std::string grpc_transport_stream_op_batch_string(
 
   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.send_message->flags(),
-                          op->payload->send_message.send_message->length()));
+      out.push_back(absl::StrFormat(
+          " 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.
@@ -108,14 +107,14 @@ std::string grpc_transport_op_string(grpc_transport_op* op) {
                                   op->stop_connectivity_watch));
   }
 
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(op->disconnect_with_error)) {
     out.push_back(absl::StrCat(
         " DISCONNECT:", grpc_error_std_string(op->disconnect_with_error)));
   }
 
-  if (op->goaway_error != GRPC_ERROR_NONE) {
-    out.push_back(absl::StrCat(" SEND_GOAWAY:%s",
-                               grpc_error_std_string(op->goaway_error)));
+  if (!GRPC_ERROR_IS_NONE(op->goaway_error)) {
+    out.push_back(
+        absl::StrCat(" SEND_GOAWAY:", grpc_error_std_string(op->goaway_error)));
   }
 
   if (op->set_accept_stream) {

data/src/core/lib/uri/uri_parser.cc

@@ -18,19 +18,27 @@
 
 #include "src/core/lib/uri/uri_parser.h"
 
-#include <string.h>
+#include <ctype.h>
+#include <stddef.h>
 
+#include <algorithm>
+#include <functional>
 #include <map>
 #include <string>
+#include <utility>
 
+#include "absl/status/status.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
+#include "absl/strings/strip.h"
 
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/string.h"
-
 namespace grpc_core {
 
 namespace {

data/src/core/lib/uri/uri_parser.h

@@ -19,8 +19,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stddef.h>
-
 #include <map>
 #include <string>
 #include <vector>

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -22,6 +22,8 @@
 
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/surface/builtins.h"
+#include "src/core/lib/transport/http_connect_handshaker.h"
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
 
 extern void grpc_register_extra_plugins(void);
 
@@ -33,6 +35,8 @@ void grpc_lb_policy_grpclb_init(void);
 void grpc_lb_policy_grpclb_shutdown(void);
 void grpc_lb_policy_priority_init(void);
 void grpc_lb_policy_priority_shutdown(void);
+void grpc_lb_policy_outlier_detection_init(void);
+void grpc_lb_policy_outlier_detection_shutdown(void);
 void grpc_lb_policy_weighted_target_init(void);
 void grpc_lb_policy_weighted_target_shutdown(void);
 void grpc_lb_policy_pick_first_init(void);
@@ -58,6 +62,8 @@ void grpc_register_built_in_plugins(void) {
   grpc_register_plugin(grpc_core::RlsLbPluginInit,
                        grpc_core::RlsLbPluginShutdown);
 #endif  // !GRPC_NO_RLS
+  grpc_register_plugin(grpc_lb_policy_outlier_detection_init,
+                       grpc_lb_policy_outlier_detection_shutdown);
   grpc_register_plugin(grpc_lb_policy_priority_init,
                        grpc_lb_policy_priority_shutdown);
   grpc_register_plugin(grpc_lb_policy_weighted_target_init,
@@ -101,6 +107,11 @@ extern void RegisterBinderResolver(CoreConfiguration::Builder* builder);
 #endif
 
 void BuildCoreConfiguration(CoreConfiguration::Builder* 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.
+  RegisterHttpConnectHandshaker(builder);
+  RegisterTCPConnectHandshaker(builder);
   BuildClientChannelConfiguration(builder);
   SecurityRegisterHandshakerFactories(builder);
   RegisterClientAuthorityFilter(builder);

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

@@ -391,7 +391,7 @@ static void on_handshaker_service_resp_recv(void* arg,
     return;
   }
   bool success = true;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_INFO,
             "ALTS handshaker on_handshaker_service_resp_recv error: %s",
             grpc_error_std_string(error).c_str());

data/src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.cc

@@ -174,7 +174,7 @@ static tsi_result alts_zero_copy_grpc_protector_protect(
 
 static tsi_result alts_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices) {
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
     gpr_log(GPR_ERROR,
@@ -215,6 +215,14 @@ static tsi_result alts_zero_copy_grpc_protector_unprotect(
       return status;
     }
   }
+  if (min_progress_size != nullptr) {
+    if (protector->parsed_frame_size > kZeroCopyFrameLengthFieldSize) {
+      *min_progress_size =
+          protector->parsed_frame_size - protector->protected_sb.length;
+    } else {
+      *min_progress_size = 1;
+    }
+  }
   return TSI_OK;
 }
 

data/src/core/tsi/fake_transport_security.cc

@@ -143,6 +143,11 @@ static uint32_t read_frame_size(const grpc_slice_buffer* sb) {
   return load32_little_endian(frame_size_buffer);
 }
 
+uint32_t tsi_fake_zero_copy_grpc_protector_next_frame_size(
+    const grpc_slice_buffer* protected_slices) {
+  return read_frame_size(protected_slices);
+}
+
 static void tsi_fake_frame_reset(tsi_fake_frame* frame, int needs_draining) {
   frame->offset = 0;
   frame->needs_draining = needs_draining;
@@ -432,7 +437,7 @@ static tsi_result fake_zero_copy_grpc_protector_protect(
 
 static tsi_result fake_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices) {
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
@@ -462,6 +467,13 @@ static tsi_result fake_zero_copy_grpc_protector_unprotect(
     impl->parsed_frame_size = 0;
     grpc_slice_buffer_reset_and_unref_internal(&impl->header_sb);
   }
+  if (min_progress_size != nullptr) {
+    if (impl->parsed_frame_size > TSI_FAKE_FRAME_HEADER_SIZE) {
+      *min_progress_size = impl->parsed_frame_size - impl->protected_sb.length;
+    } else {
+      *min_progress_size = 1;
+    }
+  }
   return TSI_OK;
 }
 

data/src/core/tsi/fake_transport_security.h

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/transport_security_interface.h"
 
 /* Value for the TSI_CERTIFICATE_TYPE_PEER_PROPERTY property for FAKE certs. */
@@ -44,4 +45,9 @@ tsi_frame_protector* tsi_create_fake_frame_protector(
 tsi_zero_copy_grpc_protector* tsi_create_fake_zero_copy_grpc_protector(
     size_t* max_protected_frame_size);
 
+/* Given a buffer containing slices encrypted by a fake_zero_copy_protector
+ * it parses these protected slices to return the total frame size of the first
+ * contained frame */
+uint32_t tsi_fake_zero_copy_grpc_protector_next_frame_size(
+    const grpc_slice_buffer* protected_slices);
 #endif /* GRPC_CORE_TSI_FAKE_TRANSPORT_SECURITY_H */

data/src/core/tsi/ssl/session_cache/ssl_session.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
 #include <openssl/ssl.h>
 
 #include <grpc/slice.h>

data/src/core/tsi/ssl/session_cache/ssl_session_boringssl.cc

@@ -22,6 +22,8 @@
 
 #ifdef OPENSSL_IS_BORINGSSL
 
+#include "absl/memory/memory.h"
+
 // BoringSSL allows SSL_SESSION to outlive SSL and SSL_CTX objects which are
 // re-created by gRPC on every certificate rotation or subchannel creation.
 // BoringSSL guarantees that SSL_SESSION is immutable so it's safe to share

data/src/core/tsi/ssl/session_cache/ssl_session_openssl.cc

@@ -24,6 +24,8 @@
 
 #ifndef OPENSSL_IS_BORINGSSL
 
+#include "absl/memory/memory.h"
+
 // OpenSSL invalidates SSL_SESSION on SSL destruction making it pointless
 // to cache sessions. The workaround is to serialize (relatively expensive)
 // session into binary blob and re-create it from blob on every handshake.

data/src/core/tsi/ssl_transport_security.cc

@@ -1566,7 +1566,7 @@ static tsi_result ssl_handshaker_write_output_buffer(tsi_handshaker* self,
                                                      size_t* bytes_written) {
   tsi_ssl_handshaker* impl = reinterpret_cast<tsi_ssl_handshaker*>(self);
   tsi_result status = TSI_OK;
-  int offset = *bytes_written;
+  size_t offset = *bytes_written;
   do {
     size_t to_send_size = impl->outgoing_bytes_buffer_size - offset;
     status = ssl_handshaker_get_bytes_to_send_to_peer(

data/src/core/tsi/transport_security_grpc.cc

@@ -51,13 +51,14 @@ tsi_result tsi_zero_copy_grpc_protector_protect(
 
 tsi_result tsi_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices) {
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size) {
   if (self == nullptr || self->vtable == nullptr ||
       protected_slices == nullptr || unprotected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   if (self->vtable->unprotect == nullptr) return TSI_UNIMPLEMENTED;
-  return self->vtable->unprotect(self, protected_slices, unprotected_slices);
+  return self->vtable->unprotect(self, protected_slices, unprotected_slices,
+                                 min_progress_size);
 }
 
 void tsi_zero_copy_grpc_protector_destroy(tsi_zero_copy_grpc_protector* self) {

data/src/core/tsi/transport_security_grpc.h

@@ -47,12 +47,14 @@ tsi_result tsi_zero_copy_grpc_protector_protect(
 /* Outputs unprotected bytes.
    - protected_slices is the bytes of protected frames.
    - unprotected_slices is the unprotected output data.
+   - if min_progress_size is not null, it returns the size of the last
+     incomplete frame which could not be fully unprotected.
    - This method returns TSI_OK in case of success. Success includes cases where
      there is not enough data to output in which case unprotected_slices has 0
      bytes.  */
 tsi_result tsi_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices);
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size);
 
 /* Destroys the tsi_zero_copy_grpc_protector object.  */
 void tsi_zero_copy_grpc_protector_destroy(tsi_zero_copy_grpc_protector* self);
@@ -68,7 +70,8 @@ struct tsi_zero_copy_grpc_protector_vtable {
                         grpc_slice_buffer* protected_slices);
   tsi_result (*unprotect)(tsi_zero_copy_grpc_protector* self,
                           grpc_slice_buffer* protected_slices,
-                          grpc_slice_buffer* unprotected_slices);
+                          grpc_slice_buffer* unprotected_slices,
+                          int* min_progress_size);
   void (*destroy)(tsi_zero_copy_grpc_protector* self);
   tsi_result (*max_frame_size)(tsi_zero_copy_grpc_protector* self,
                                size_t* max_frame_size);

data/src/ruby/ext/grpc/ext-export-truffleruby.clang

@@ -0,0 +1,2 @@
+_Init_grpc_c
+_rb_tr_abi_version

data/src/ruby/ext/grpc/ext-export-truffleruby.gcc

@@ -0,0 +1,7 @@
+grpc_1.0 { 
+  global: 
+    Init_grpc_c;
+    rb_tr_abi_version;
+  local: 
+    *;
+};

data/src/ruby/ext/grpc/ext-export.clang

@@ -1 +1,2 @@
 _Init_grpc_c
+_ruby_abi_version

data/src/ruby/ext/grpc/ext-export.gcc

@@ -1,6 +1,7 @@
 grpc_1.0 { 
   global: 
     Init_grpc_c;
+    ruby_abi_version;
   local: 
     *;
 };

data/src/ruby/ext/grpc/extconf.rb

@@ -20,6 +20,8 @@ bsd = RUBY_PLATFORM =~ /bsd/
 darwin = RUBY_PLATFORM =~ /darwin/
 linux = RUBY_PLATFORM =~ /linux/
 cross_compiling = ENV['RCD_HOST_RUBY_VERSION'] # set by rake-compiler-dock in build containers
+# TruffleRuby uses the Sulong LLVM runtime, which is different from Apple's.
+apple_toolchain = darwin && RUBY_ENGINE != 'truffleruby'
 
 grpc_root = File.expand_path(File.join(File.dirname(__FILE__), '../../../..'))
 
@@ -27,30 +29,53 @@ grpc_config = ENV['GRPC_CONFIG'] || 'opt'
 
 ENV['MACOSX_DEPLOYMENT_TARGET'] = '10.10'
 
-if ENV['AR'].nil? || ENV['AR'].size == 0
-    ENV['AR'] = RbConfig::CONFIG['AR']
+def env_unset?(name)
+  ENV[name].nil? || ENV[name].size == 0
 end
-if ENV['CC'].nil? || ENV['CC'].size == 0
-    ENV['CC'] = RbConfig::CONFIG['CC']
+
+def rbconfig_set?(name)
+  RbConfig::CONFIG[name] && RbConfig::CONFIG[name].size > 0
 end
-if ENV['CXX'].nil? || ENV['CXX'].size == 0
-    ENV['CXX'] = RbConfig::CONFIG['CXX']
+
+def inherit_rbconfig(name)
+  ENV[name] = RbConfig::CONFIG[name] if env_unset?(name) && rbconfig_set?(name)
 end
-if ENV['LD'].nil? || ENV['LD'].size == 0
-    ENV['LD'] = ENV['CC']
+
+def env_append(name, string)
+  ENV[name] ||= ''
+  ENV[name] += ' ' + string
+end
+
+inherit_rbconfig 'AR'
+inherit_rbconfig 'CC'
+inherit_rbconfig 'CXX'
+inherit_rbconfig 'RANLIB'
+inherit_rbconfig 'STRIP'
+inherit_rbconfig 'CPPFLAGS'
+inherit_rbconfig 'LDFLAGS'
+
+ENV['LD'] = ENV['CC'] if env_unset?('LD')
+ENV['LDXX'] = ENV['CXX'] if env_unset?('LDXX')
+
+if RUBY_ENGINE == 'truffleruby'
+  # ensure we can find the system's OpenSSL
+  env_append 'CPPFLAGS', RbConfig::CONFIG['cppflags']
 end
 
-if darwin && !cross_compiling
+if apple_toolchain && !cross_compiling
   ENV['AR'] = 'libtool'
   ENV['ARFLAGS'] = '-o'
 end
 
-ENV['EMBED_OPENSSL'] = 'true'
-ENV['EMBED_ZLIB'] = 'true'
+# Don't embed on TruffleRuby (constant-time crypto is unsafe with Sulong, slow build times)
+ENV['EMBED_OPENSSL'] = (RUBY_ENGINE != 'truffleruby').to_s
+# Don't embed on TruffleRuby (the system zlib is already linked for the zlib C extension, slow build times)
+ENV['EMBED_ZLIB'] = (RUBY_ENGINE != 'truffleruby').to_s
+
 ENV['EMBED_CARES'] = 'true'
 
 ENV['ARCH_FLAGS'] = RbConfig::CONFIG['ARCH_FLAG']
-if darwin && !cross_compiling
+if apple_toolchain && !cross_compiling
   if RUBY_PLATFORM =~ /arm64/
     ENV['ARCH_FLAGS'] = '-arch arm64'
   else
@@ -58,9 +83,11 @@ if darwin && !cross_compiling
   end
 end
 
-ENV['CPPFLAGS'] = '-DGPR_BACKWARDS_COMPATIBILITY_MODE'
-ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_NAME_SUFFIX="\"RUBY\"" '
-ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"1.46.2\"" '
+env_append 'CPPFLAGS', '-DGPR_BACKWARDS_COMPATIBILITY_MODE'
+env_append 'CPPFLAGS', '-DGRPC_XDS_USER_AGENT_NAME_SUFFIX="\"RUBY\""'
+
+require_relative '../../lib/grpc/version'
+env_append 'CPPFLAGS', '-DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"' + GRPC::VERSION + '\""'
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])
 grpc_lib_dir = File.join(output_dir, 'libs', grpc_config)
@@ -85,8 +112,9 @@ end
 $CFLAGS << ' -I' + File.join(grpc_root, 'include')
 
 ext_export_file = File.join(grpc_root, 'src', 'ruby', 'ext', 'grpc', 'ext-export')
+ext_export_file += '-truffleruby' if RUBY_ENGINE == 'truffleruby'
 $LDFLAGS << ' -Wl,--version-script="' + ext_export_file + '.gcc"' if linux
-$LDFLAGS << ' -Wl,-exported_symbols_list,"' + ext_export_file + '.clang"' if darwin
+$LDFLAGS << ' -Wl,-exported_symbols_list,"' + ext_export_file + '.clang"' if apple_toolchain
 
 $LDFLAGS << ' ' + File.join(grpc_lib_dir, 'libgrpc.a') unless windows
 if grpc_config == 'gcov'
@@ -99,10 +127,13 @@ if grpc_config == 'dbg'
 end
 
 $LDFLAGS << ' -Wl,-wrap,memcpy' if linux
-$LDFLAGS << ' -static-libgcc -static-libstdc++' if linux
+# Do not statically link standard libraries on TruffleRuby as this does not work when compiling to bitcode
+if linux && RUBY_ENGINE != 'truffleruby'
+  $LDFLAGS << ' -static-libgcc -static-libstdc++'
+end
 $LDFLAGS << ' -static' if windows
 
-$CFLAGS << ' -std=c99 '
+$CFLAGS << ' -std=c11 '
 $CFLAGS << ' -Wall '
 $CFLAGS << ' -Wextra '
 $CFLAGS << ' -pedantic '
@@ -112,7 +143,7 @@ puts 'Generating Makefile for ' + output
 create_makefile(output)
 
 strip_tool = RbConfig::CONFIG['STRIP']
-strip_tool += ' -x' if darwin
+strip_tool += ' -x' if apple_toolchain
 
 if grpc_config == 'opt'
   File.open('Makefile.new', 'w') do |o|

data/src/ruby/ext/grpc/rb_grpc_imports.generated.h

@@ -278,7 +278,7 @@ extern grpc_resource_quota_resize_type grpc_resource_quota_resize_import;
 typedef void(*grpc_resource_quota_set_max_threads_type)(grpc_resource_quota* resource_quota, int new_max_threads);
 extern grpc_resource_quota_set_max_threads_type grpc_resource_quota_set_max_threads_import;
 #define grpc_resource_quota_set_max_threads grpc_resource_quota_set_max_threads_import
-typedef grpc_slice(*grpc_dump_xds_configs_type)();
+typedef grpc_slice(*grpc_dump_xds_configs_type)(void);
 extern grpc_dump_xds_configs_type grpc_dump_xds_configs_import;
 #define grpc_dump_xds_configs grpc_dump_xds_configs_import
 typedef const grpc_arg_pointer_vtable*(*grpc_resource_quota_arg_vtable_type)(void);

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

@@ -43,7 +43,7 @@ module GRPC
                    debug_error_string = nil)
       exception_message = "#{code}:#{details}"
       if debug_error_string
-        exception_message += ". debug_error_string:#{debug_error_string}"
+        exception_message += ". debug_error_string:{#{debug_error_string}}"
       end
       super(exception_message)
       @code = code

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

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.46.2'
+  VERSION = '1.48.0.pre1'
 end

data/src/ruby/spec/generic/client_stub_spec.rb

@@ -498,31 +498,10 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
                            /Header values must be of type string or array/)
       end
 
-      def run_server_streamer_against_client_with_unmarshal_error(
-        expected_input, replys)
-        wakey_thread do |notifier|
-          c = expect_server_to_be_invoked(notifier)
-          expect(c.remote_read).to eq(expected_input)
-          begin
-            replys.each { |r| c.remote_send(r) }
-          rescue GRPC::Core::CallError
-            # An attempt to write to the client might fail. This is ok
-            # because the client call is expected to fail when
-            # unmarshalling the first response, and to cancel the call,
-            # and there is a race as for when the server-side call will
-            # start to fail.
-            p 'remote_send failed (allowed because call expected to cancel)'
-          ensure
-            c.send_status(OK, 'OK', true)
-            close_active_server_call(c)
-          end
-        end
-      end
-
       it 'the call terminates when there is an unmarshalling error' do
         server_port = create_test_server
         host = "localhost:#{server_port}"
-        th = run_server_streamer_against_client_with_unmarshal_error(
+        th = run_server_streamer_handle_client_cancellation(
           @sent_msg, @replys)
         stub = GRPC::ClientStub.new(host, :this_channel_is_insecure)
 
@@ -597,7 +576,8 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
       it 'raises GRPC::Cancelled after the call has been cancelled' do
         server_port = create_test_server
         host = "localhost:#{server_port}"
-        th = run_server_streamer(@sent_msg, @replys, @pass)
+        th = run_server_streamer_handle_client_cancellation(
+          @sent_msg, @replys)
         stub = GRPC::ClientStub.new(host, :this_channel_is_insecure)
         resp = get_responses(stub, run_start_call_first: false)
         expect(resp.next).to eq('reply_1')
@@ -1037,6 +1017,26 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
     end
   end
 
+  def run_server_streamer_handle_client_cancellation(
+    expected_input, replys)
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
+      expect(c.remote_read).to eq(expected_input)
+      begin
+        replys.each { |r| c.remote_send(r) }
+      rescue GRPC::Core::CallError
+        # An attempt to write to the client might fail. This is ok
+        # because the client call is expected to cancel the call,
+        # and there is a race as for when the server-side call will
+        # start to fail.
+        p 'remote_send failed (allowed because call expected to cancel)'
+      ensure
+        c.send_status(OK, 'OK', true)
+        close_active_server_call(c)
+      end
+    end
+  end
+
   def run_request_response(expected_input, resp, status,
                            expected_metadata: {},
                            server_initial_md: {},

data/third_party/abseil-cpp/absl/algorithm/container.h

@@ -166,7 +166,7 @@ container_algorithm_internal::ContainerDifferenceType<const C> c_distance(
 // c_all_of()
 //
 // Container-based version of the <algorithm> `std::all_of()` function to
-// test a condition on all elements within a container.
+// test if all elements within a container satisfy a condition.
 template <typename C, typename Pred>
 bool c_all_of(const C& c, Pred&& pred) {
   return std::all_of(container_algorithm_internal::c_begin(c),