grpc 1.66.0-x86-mingw32 → 1.67.0-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 821b62a1e5dbe92c9af50d75a7c616a84b25388571889e2ee4cea3385d518b2a
-  data.tar.gz: 108e039b701aeed8692ed7d6d674238ddc36244eb47153d5cb7f31a271bdf25f
+  metadata.gz: d4b533aa4380c88b3831c39e56fc35129bf952c44080ac49d9e45f96c6ede990
+  data.tar.gz: ee9d5a8650a0358ca077b6ea1ebfa0a521b22752b5e9afc9797fe7a5a62be17e
 SHA512:
-  metadata.gz: c65c4a2b041fdc0e0b8a6f921e0a84882fa735244278366c34efe39db24395bc784457d8a209eba1c27a6d04f188e333dcc1ed8a419035b117e31699185b395a
-  data.tar.gz: 9db0b4a83755d38690bf2bb304e5f9761dc7b55adf2985873e60d453960f735dfd194c2b9bc5f364755c0e19f1c588bcfd8e0d88637fcbdcd7dd44a0eeab2a7b
+  metadata.gz: 80f017e8951aacad837b0f3f89089ba6c2b039cd0e778e9fad2b874bc90849ef5869f194e972a86a310721a7fbc8443914f9d07a880f75278541b7dc66e2a3ee
+  data.tar.gz: cfc6cf9b556f670c11ee5b028e4e999187a0ad0d0d9c9d4010e77b7b8d748cc553daa35dafab23c59646dd83f32f2036ec279225475327b799cf6c654ed3e226

data/src/ruby/ext/grpc/rb_call.c

@@ -809,7 +809,7 @@ struct call_run_batch_args {
 };
 
 static void cancel_call_unblock_func(void* arg) {
-  gpr_log(GPR_DEBUG, "GRPC_RUBY: cancel_call_unblock_func");
+  grpc_absl_log(GPR_DEBUG, "GRPC_RUBY: cancel_call_unblock_func");
   grpc_call* call = (grpc_call*)arg;
   grpc_call_cancel(call, NULL);
 }

data/src/ruby/ext/grpc/rb_call_credentials.c

@@ -60,30 +60,32 @@ static VALUE grpc_rb_call_credentials_callback(VALUE args) {
   VALUE callback_func = rb_ary_entry(args, 0);
   VALUE callback_args = rb_ary_entry(args, 1);
   VALUE md_ary_obj = rb_ary_entry(args, 2);
-  if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-    VALUE callback_func_str = rb_funcall(callback_func, rb_intern("to_s"), 0);
-    VALUE callback_args_str = rb_funcall(callback_args, rb_intern("to_s"), 0);
-    VALUE callback_source_info =
-        rb_funcall(callback_func, rb_intern("source_location"), 0);
-    if (callback_source_info != Qnil) {
-      VALUE source_filename = rb_ary_entry(callback_source_info, 0);
-      VALUE source_line_number = rb_funcall(
-          rb_ary_entry(callback_source_info, 1), rb_intern("to_s"), 0);
-      gpr_log(GPR_DEBUG,
-              "GRPC_RUBY: grpc_rb_call_credentials invoking user callback:|%s| "
-              "source_filename:%s line_number:%s with arguments:|%s|",
-              StringValueCStr(callback_func_str),
-              StringValueCStr(source_filename),
-              StringValueCStr(source_line_number),
-              StringValueCStr(callback_args_str));
-    } else {
-      gpr_log(GPR_DEBUG,
-              "GRPC_RUBY: grpc_rb_call_credentials invoking user callback:|%s| "
-              "(failed to get source filename and line) with arguments:|%s|",
-              StringValueCStr(callback_func_str),
-              StringValueCStr(callback_args_str));
-    }
+
+  VALUE callback_func_str = rb_funcall(callback_func, rb_intern("to_s"), 0);
+  VALUE callback_args_str = rb_funcall(callback_args, rb_intern("to_s"), 0);
+  VALUE callback_source_info =
+      rb_funcall(callback_func, rb_intern("source_location"), 0);
+
+  grpc_absl_log_str(
+      GPR_DEBUG, "GRPC_RUBY: grpc_rb_call_credentials invoking user callback:",
+      StringValueCStr(callback_func_str));
+
+  if (callback_source_info != Qnil) {
+    VALUE source_filename = rb_ary_entry(callback_source_info, 0);
+    VALUE source_line_number =
+        rb_funcall(rb_ary_entry(callback_source_info, 1), rb_intern("to_s"), 0);
+    grpc_absl_log_str(GPR_DEBUG, "GRPC_RUBY: source_filename: ",
+                      StringValueCStr(source_filename));
+    grpc_absl_log_str(GPR_DEBUG, "GRPC_RUBY: source_line_number: ",
+                      StringValueCStr(source_line_number));
+    grpc_absl_log_str(GPR_DEBUG, "GRPC_RUBY: Arguments: ",
+                      StringValueCStr(callback_args_str));
+  } else {
+    grpc_absl_log_str(
+        GPR_DEBUG, "(failed to get source filename and line) with arguments: ",
+        StringValueCStr(callback_args_str));
   }
+
   VALUE metadata =
       rb_funcall(callback_func, rb_intern("call"), 1, callback_args);
   grpc_metadata_array* md_ary = NULL;
@@ -112,10 +114,15 @@ static VALUE grpc_rb_call_credentials_callback_rescue(VALUE args,
   VALUE rb_exception_info =
       rb_funcall(exception_object, rb_intern("inspect"), 0);
   (void)args;
-  gpr_log(GPR_DEBUG,
-          "GRPC_RUBY call credentials callback failed, exception inspect:|%s| "
-          "backtrace:|%s|",
-          StringValueCStr(rb_exception_info), StringValueCStr(backtrace_str));
+
+  grpc_absl_log_str(
+      GPR_DEBUG,
+      "GRPC_RUBY call credentials callback failed, exception inspect: ",
+      StringValueCStr(rb_exception_info));
+  grpc_absl_log_str(GPR_DEBUG,
+                    "GRPC_RUBY call credentials callback failed, backtrace: ",
+                    StringValueCStr(backtrace_str));
+
   rb_hash_aset(result, rb_str_new2("metadata"), Qnil);
   rb_hash_aset(result, rb_str_new2("status"),
                INT2NUM(GRPC_STATUS_UNAUTHENTICATED));

data/src/ruby/ext/grpc/rb_channel.c

@@ -655,7 +655,7 @@ static void* run_poll_channels_loop_no_gil(void* arg) {
   watch_state_op* op = NULL;
   bg_watched_channel* bg = NULL;
   (void)arg;
-  gpr_log(GPR_DEBUG, "GRPC_RUBY: run_poll_channels_loop_no_gil - begin");
+  grpc_absl_log(GPR_DEBUG, "GRPC_RUBY: run_poll_channels_loop_no_gil - begin");
 
   gpr_mu_lock(&global_connection_polling_mu);
   gpr_cv_broadcast(&global_connection_polling_cv);
@@ -685,9 +685,10 @@ static void* run_poll_channels_loop_no_gil(void* arg) {
     gpr_mu_unlock(&global_connection_polling_mu);
   }
   grpc_completion_queue_destroy(g_channel_polling_cq);
-  gpr_log(GPR_DEBUG,
-          "GRPC_RUBY: run_poll_channels_loop_no_gil - exit connection polling "
-          "loop");
+  grpc_absl_log(
+      GPR_DEBUG,
+      "GRPC_RUBY: run_poll_channels_loop_no_gil - exit connection polling "
+      "loop");
   return NULL;
 }
 
@@ -701,9 +702,10 @@ static void* run_poll_channels_loop_unblocking_func_wrapper(void* arg) {
   (void)arg;
 
   gpr_mu_lock(&global_connection_polling_mu);
-  gpr_log(GPR_DEBUG,
-          "GRPC_RUBY: run_poll_channels_loop_unblocking_func - begin aborting "
-          "connection polling");
+  grpc_absl_log(
+      GPR_DEBUG,
+      "GRPC_RUBY: run_poll_channels_loop_unblocking_func - begin aborting "
+      "connection polling");
   // early out after first time through
   if (g_abort_channel_polling) {
     gpr_mu_unlock(&global_connection_polling_mu);
@@ -721,21 +723,23 @@ static void* run_poll_channels_loop_unblocking_func_wrapper(void* arg) {
     bg = bg->next;
   }
 
-  gpr_log(GPR_DEBUG, "GRPC_RUBY: cq shutdown on global polling cq. pid: %d",
-          getpid());
+  grpc_absl_log_int(
+      GPR_DEBUG,
+      "GRPC_RUBY: cq shutdown on global polling cq. pid: ", getpid());
   grpc_completion_queue_shutdown(g_channel_polling_cq);
   gpr_cv_broadcast(&global_connection_polling_cv);
   gpr_mu_unlock(&global_connection_polling_mu);
-  gpr_log(GPR_DEBUG,
-          "GRPC_RUBY: run_poll_channels_loop_unblocking_func - end aborting "
-          "connection polling");
+  grpc_absl_log(
+      GPR_DEBUG,
+      "GRPC_RUBY: run_poll_channels_loop_unblocking_func - end aborting "
+      "connection polling");
   return NULL;
 }
 
 // Poll channel connectivity states in background thread without the GIL.
 static VALUE run_poll_channels_loop(void* arg) {
   (void)arg;
-  gpr_log(
+  grpc_absl_log(
       GPR_DEBUG,
       "GRPC_RUBY: run_poll_channels_loop - create connection polling thread");
   rb_thread_call_without_gvl(run_poll_channels_loop_no_gil, NULL,
@@ -777,7 +781,8 @@ void grpc_rb_channel_polling_thread_start() {
   g_channel_polling_thread = rb_thread_create(run_poll_channels_loop, NULL);
 
   if (!RTEST(g_channel_polling_thread)) {
-    gpr_log(GPR_ERROR, "GRPC_RUBY: failed to spawn channel polling thread");
+    grpc_absl_log(GPR_ERROR,
+                  "GRPC_RUBY: failed to spawn channel polling thread");
     rb_thread_call_without_gvl(set_abort_channel_polling_without_gil, NULL,
                                NULL, NULL);
     return;
@@ -786,8 +791,9 @@ void grpc_rb_channel_polling_thread_start() {
 
 void grpc_rb_channel_polling_thread_stop() {
   if (!RTEST(g_channel_polling_thread)) {
-    gpr_log(GPR_ERROR,
-            "GRPC_RUBY: channel polling thread stop: thread was not started");
+    grpc_absl_log(
+        GPR_ERROR,
+        "GRPC_RUBY: channel polling thread stop: thread was not started");
     return;
   }
   rb_thread_call_without_gvl(run_poll_channels_loop_unblocking_func_wrapper,

data/src/ruby/ext/grpc/rb_event_thread.c

@@ -156,8 +156,9 @@ void grpc_rb_event_queue_thread_start() {
 void grpc_rb_event_queue_thread_stop() {
   GRPC_RUBY_ASSERT(g_one_time_init_done);
   if (!RTEST(g_event_thread)) {
-    gpr_log(GPR_ERROR,
-            "GRPC_RUBY: call credentials thread stop: thread not running");
+    grpc_absl_log(
+        GPR_ERROR,
+        "GRPC_RUBY: call credentials thread stop: thread not running");
     return;
   }
   rb_thread_call_without_gvl(grpc_rb_event_unblocking_func_wrapper, NULL, NULL,

data/src/ruby/ext/grpc/rb_grpc.c

@@ -328,9 +328,9 @@ static void grpc_ruby_init_threads() {
   // in gpr_once_init. In general, it appears to be unsafe to call
   // into the ruby library while holding a non-ruby mutex, because a gil yield
   // could end up trying to lock onto that same mutex and deadlocking.
-  gpr_log(GPR_DEBUG,
-          "GRPC_RUBY: grpc_ruby_init_threads g_bg_thread_init_done=%d",
-          g_bg_thread_init_done);
+  grpc_absl_log_int(GPR_DEBUG,
+                    "GRPC_RUBY: grpc_ruby_init_threads g_bg_thread_init_done=",
+                    g_bg_thread_init_done);
   rb_mutex_lock(g_bg_thread_init_rb_mu);
   if (!g_bg_thread_init_done) {
     grpc_rb_event_queue_thread_start();
@@ -347,11 +347,12 @@ void grpc_ruby_init() {
   grpc_ruby_fork_guard();
   grpc_init();
   grpc_ruby_init_threads();
-  // (only gpr_log after logging has been initialized)
-  gpr_log(GPR_DEBUG,
-          "GRPC_RUBY: grpc_ruby_init - g_enable_fork_support=%d prev "
-          "g_grpc_ruby_init_count:%" PRId64,
-          g_enable_fork_support, g_grpc_ruby_init_count++);
+  // (only log after logging has been initialized)
+  grpc_absl_log_int(GPR_DEBUG,
+                    "GRPC_RUBY: grpc_ruby_init - g_enable_fork_support=",
+                    g_enable_fork_support);
+  grpc_absl_log_int(GPR_DEBUG,
+                    "prev g_grpc_ruby_init_count:", g_grpc_ruby_init_count++);
 }
 
 // fork APIs, useable on linux with env var: GRPC_ENABLE_FORK_SUPPORT=1

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

@@ -253,12 +253,10 @@ gpr_malloc_aligned_type gpr_malloc_aligned_import;
 gpr_free_aligned_type gpr_free_aligned_import;
 gpr_cpu_num_cores_type gpr_cpu_num_cores_import;
 gpr_cpu_current_cpu_type gpr_cpu_current_cpu_import;
-gpr_log_type gpr_log_import;
-gpr_should_log_type gpr_should_log_import;
-gpr_log_message_type gpr_log_message_import;
-gpr_set_log_verbosity_type gpr_set_log_verbosity_import;
+grpc_absl_log_type grpc_absl_log_import;
+grpc_absl_log_int_type grpc_absl_log_int_import;
+grpc_absl_log_str_type grpc_absl_log_str_import;
 gpr_log_verbosity_init_type gpr_log_verbosity_init_import;
-gpr_set_log_function_type gpr_set_log_function_import;
 gpr_format_message_type gpr_format_message_import;
 gpr_strdup_type gpr_strdup_import;
 gpr_asprintf_type gpr_asprintf_import;
@@ -541,12 +539,10 @@ void grpc_rb_load_imports(HMODULE library) {
   gpr_free_aligned_import = (gpr_free_aligned_type) GetProcAddress(library, "gpr_free_aligned");
   gpr_cpu_num_cores_import = (gpr_cpu_num_cores_type) GetProcAddress(library, "gpr_cpu_num_cores");
   gpr_cpu_current_cpu_import = (gpr_cpu_current_cpu_type) GetProcAddress(library, "gpr_cpu_current_cpu");
-  gpr_log_import = (gpr_log_type) GetProcAddress(library, "gpr_log");
-  gpr_should_log_import = (gpr_should_log_type) GetProcAddress(library, "gpr_should_log");
-  gpr_log_message_import = (gpr_log_message_type) GetProcAddress(library, "gpr_log_message");
-  gpr_set_log_verbosity_import = (gpr_set_log_verbosity_type) GetProcAddress(library, "gpr_set_log_verbosity");
+  grpc_absl_log_import = (grpc_absl_log_type) GetProcAddress(library, "grpc_absl_log");
+  grpc_absl_log_int_import = (grpc_absl_log_int_type) GetProcAddress(library, "grpc_absl_log_int");
+  grpc_absl_log_str_import = (grpc_absl_log_str_type) GetProcAddress(library, "grpc_absl_log_str");
   gpr_log_verbosity_init_import = (gpr_log_verbosity_init_type) GetProcAddress(library, "gpr_log_verbosity_init");
-  gpr_set_log_function_import = (gpr_set_log_function_type) GetProcAddress(library, "gpr_set_log_function");
   gpr_format_message_import = (gpr_format_message_type) GetProcAddress(library, "gpr_format_message");
   gpr_strdup_import = (gpr_strdup_type) GetProcAddress(library, "gpr_strdup");
   gpr_asprintf_import = (gpr_asprintf_type) GetProcAddress(library, "gpr_asprintf");

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

@@ -735,24 +735,18 @@ extern gpr_cpu_num_cores_type gpr_cpu_num_cores_import;
 typedef unsigned(*gpr_cpu_current_cpu_type)(void);
 extern gpr_cpu_current_cpu_type gpr_cpu_current_cpu_import;
 #define gpr_cpu_current_cpu gpr_cpu_current_cpu_import
-typedef void(*gpr_log_type)(const char* file, int line, gpr_log_severity severity, const char* format, ...) GPR_PRINT_FORMAT_CHECK(4, 5);
-extern gpr_log_type gpr_log_import;
-#define gpr_log gpr_log_import
-typedef int(*gpr_should_log_type)(gpr_log_severity severity);
-extern gpr_should_log_type gpr_should_log_import;
-#define gpr_should_log gpr_should_log_import
-typedef void(*gpr_log_message_type)(const char* file, int line, gpr_log_severity severity, const char* message);
-extern gpr_log_message_type gpr_log_message_import;
-#define gpr_log_message gpr_log_message_import
-typedef void(*gpr_set_log_verbosity_type)(gpr_log_severity deprecated_setting);
-extern gpr_set_log_verbosity_type gpr_set_log_verbosity_import;
-#define gpr_set_log_verbosity gpr_set_log_verbosity_import
+typedef void(*grpc_absl_log_type)(const char* file, int line, gpr_log_severity severity, const char* message_str);
+extern grpc_absl_log_type grpc_absl_log_import;
+#define grpc_absl_log grpc_absl_log_import
+typedef void(*grpc_absl_log_int_type)(const char* file, int line, gpr_log_severity severity, const char* message_str, intptr_t num);
+extern grpc_absl_log_int_type grpc_absl_log_int_import;
+#define grpc_absl_log_int grpc_absl_log_int_import
+typedef void(*grpc_absl_log_str_type)(const char* file, int line, gpr_log_severity severity, const char* message_str1, const char* message_str2);
+extern grpc_absl_log_str_type grpc_absl_log_str_import;
+#define grpc_absl_log_str grpc_absl_log_str_import
 typedef void(*gpr_log_verbosity_init_type)(void);
 extern gpr_log_verbosity_init_type gpr_log_verbosity_init_import;
 #define gpr_log_verbosity_init gpr_log_verbosity_init_import
-typedef void(*gpr_set_log_function_type)(gpr_log_func deprecated_setting);
-extern gpr_set_log_function_type gpr_set_log_function_import;
-#define gpr_set_log_function gpr_set_log_function_import
 typedef char*(*gpr_format_message_type)(int messageid);
 extern gpr_format_message_type gpr_format_message_import;
 #define gpr_format_message gpr_format_message_import

data/src/ruby/ext/grpc/rb_server.c

@@ -68,9 +68,9 @@ static void grpc_rb_server_shutdown_and_notify_internal(grpc_rb_server* server,
           server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME), NULL, NULL);
     }
     if (ev.type != GRPC_OP_COMPLETE) {
-      gpr_log(GPR_DEBUG,
-              "GRPC_RUBY: bad grpc_server_shutdown_and_notify result:%d",
-              ev.type);
+      grpc_absl_log_int(
+          GPR_DEBUG,
+          "GRPC_RUBY: bad grpc_server_shutdown_and_notify result:", ev.type);
     }
   }
 }
@@ -192,7 +192,7 @@ struct server_request_call_args {
 
 static void shutdown_server_unblock_func(void* arg) {
   grpc_rb_server* server = (grpc_rb_server*)arg;
-  gpr_log(GPR_DEBUG, "GRPC_RUBY: shutdown_server_unblock_func");
+  grpc_absl_log(GPR_DEBUG, "GRPC_RUBY: shutdown_server_unblock_func");
   GRPC_RUBY_ASSERT(server->wrapped != NULL);
   grpc_event event;
   void* tag = &event;
@@ -202,10 +202,12 @@ static void shutdown_server_unblock_func(void* arg) {
   // cancelled all calls.
   event = grpc_completion_queue_pluck(server->queue, tag,
                                       gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
-  gpr_log(GPR_DEBUG,
-          "GRPC_RUBY: shutdown_server_unblock_func pluck event.type: %d "
-          "event.success: %d",
-          event.type, event.success);
+  grpc_absl_log_int(
+      GPR_DEBUG,
+      "GRPC_RUBY: shutdown_server_unblock_func pluck event.type: ", event.type);
+  grpc_absl_log_int(
+      GPR_DEBUG,
+      "GRPC_RUBY: shutdown_server_unblock_func event.success: ", event.success);
 }
 
 static VALUE grpc_rb_server_request_call_try(VALUE value_args) {

data/src/ruby/lib/grpc/generic/active_call.rb

@@ -44,8 +44,8 @@ module GRPC
     include Core::CallOps
     extend Forwardable
     attr_reader :deadline, :metadata_sent, :metadata_to_send, :peer, :peer_cert
-    def_delegators :@call, :cancel, :metadata, :write_flag, :write_flag=,
-                   :trailing_metadata, :status
+    def_delegators :@call, :cancel, :cancel_with_status, :metadata,
+                   :write_flag, :write_flag=, :trailing_metadata, :status
 
     # client_invoke begins a client invocation.
     #
@@ -620,6 +620,8 @@ module GRPC
     # @param metadata [Hash] metadata to be sent to the server. If a value is
     # a list, multiple metadata for its key are sent
     def start_call(metadata = {})
+      # TODO(apolcyn): we should cancel and clean up the call in case this
+      # send initial MD op fails.
       merge_metadata_to_send(metadata) && send_initial_metadata
     end
 
@@ -665,9 +667,10 @@ module GRPC
 
     # Operation limits access to an ActiveCall's methods for use as
     # a Operation on the client.
-    Operation = view_class(:cancel, :cancelled?, :deadline, :execute,
-                           :metadata, :status, :start_call, :wait, :write_flag,
-                           :write_flag=, :trailing_metadata)
+    # TODO(apolcyn): expose peer getter
+    Operation = view_class(:cancel, :cancel_with_status, :cancelled?, :deadline,
+                           :execute, :metadata, :status, :start_call, :wait,
+                           :write_flag, :write_flag=, :trailing_metadata)
 
     # InterceptableView further limits access to an ActiveCall's methods
     # for use in interceptors on the client, exposing only the deadline

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

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

data/src/ruby/spec/call_spec.rb

@@ -90,88 +90,101 @@ describe GRPC::Core::Call do
 
   describe '#status' do
     it 'can save the status and read it back' do
-      call = make_test_call
-      sts = Struct::Status.new(OK, 'OK')
-      expect { call.status = sts }.not_to raise_error
-      expect(call.status).to eq(sts)
+      make_test_call do |call|
+        sts = Struct::Status.new(OK, 'OK')
+        expect { call.status = sts }.not_to raise_error
+        expect(call.status).to eq(sts)
+      end
     end
 
     it 'must be set to a status' do
-      call = make_test_call
-      bad_sts = Object.new
-      expect { call.status = bad_sts }.to raise_error(TypeError)
+      make_test_call do |call|
+        bad_sts = Object.new
+        expect { call.status = bad_sts }.to raise_error(TypeError)
+      end
     end
 
     it 'can be set to nil' do
-      call = make_test_call
-      expect { call.status = nil }.not_to raise_error
+      make_test_call do |call|
+        expect { call.status = nil }.not_to raise_error
+      end
     end
   end
 
   describe '#metadata' do
     it 'can save the metadata hash and read it back' do
-      call = make_test_call
-      md = { 'k1' => 'v1',  'k2' => 'v2' }
-      expect { call.metadata = md }.not_to raise_error
-      expect(call.metadata).to be(md)
+      make_test_call do |call|
+        md = { 'k1' => 'v1',  'k2' => 'v2' }
+        expect { call.metadata = md }.not_to raise_error
+        expect(call.metadata).to be(md)
+      end
     end
 
     it 'must be set with a hash' do
-      call = make_test_call
-      bad_md = Object.new
-      expect { call.metadata = bad_md }.to raise_error(TypeError)
+      make_test_call do |call|
+        bad_md = Object.new
+        expect { call.metadata = bad_md }.to raise_error(TypeError)
+      end
     end
 
     it 'can be set to nil' do
-      call = make_test_call
-      expect { call.metadata = nil }.not_to raise_error
+      make_test_call do |call|
+        expect { call.metadata = nil }.not_to raise_error
+      end
     end
   end
 
   describe '#set_credentials!' do
     it 'can set a valid CallCredentials object' do
-      call = make_test_call
-      auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
-      creds = GRPC::Core::CallCredentials.new auth_proc
-      expect { call.set_credentials! creds }.not_to raise_error
+      make_test_call do |call|
+        auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
+        creds = GRPC::Core::CallCredentials.new auth_proc
+        expect { call.set_credentials! creds }.not_to raise_error
+      end
     end
   end
 
   describe '#cancel' do
     it 'completes ok' do
-      call = make_test_call
-      expect { call.cancel }.not_to raise_error
+      make_test_call do |call|
+        expect { call.cancel }.not_to raise_error
+      end
     end
 
     it 'completes ok when the call is closed' do
-      call = make_test_call
-      call.close
-      expect { call.cancel }.not_to raise_error
+      make_test_call do |call|
+        call.close
+        expect { call.cancel }.not_to raise_error
+      end
     end
   end
 
   describe '#cancel_with_status' do
     it 'completes ok' do
-      call = make_test_call
-      expect do
-        call.cancel_with_status(0, 'test status')
-      end.not_to raise_error
-      expect do
-        call.cancel_with_status(0, nil)
-      end.to raise_error(TypeError)
+      make_test_call do |call|
+        expect do
+          call.cancel_with_status(0, 'test status')
+        end.not_to raise_error
+        expect do
+          call.cancel_with_status(0, nil)
+        end.to raise_error(TypeError)
+      end
     end
 
     it 'completes ok when the call is closed' do
-      call = make_test_call
-      call.close
-      expect do
-        call.cancel_with_status(0, 'test status')
-      end.not_to raise_error
+      make_test_call do |call|
+        call.close
+        expect do
+          call.cancel_with_status(0, 'test status')
+        end.not_to raise_error
+      end
     end
   end
 
   def make_test_call
-    @ch.create_call(nil, nil, 'phony_method', nil, deadline)
+    call = @ch.create_call(nil, nil, 'phony_method', nil, deadline)
+    yield call
+    call.close
   end
 
   def deadline

data/src/ruby/spec/channel_spec.rb

@@ -118,7 +118,8 @@ describe GRPC::Core::Channel do
       deadline = Time.now + 5
 
       blk = proc do
-        ch.create_call(nil, nil, 'phony_method', nil, deadline)
+        call = ch.create_call(nil, nil, 'phony_method', nil, deadline)
+        call.close
       end
       expect(&blk).to_not raise_error
     end
@@ -132,8 +133,9 @@ describe GRPC::Core::Channel do
 
       deadline = Time.now + 5
       blk = proc do
-        ch.create_call(nil, nil, 'phony_method', nil, deadline)
+        call = ch.create_call(nil, nil, 'phony_method', nil, deadline)
         STDERR.puts "#{Time.now}: created call"
+        call.close
       end
       expect(&blk).to raise_error(RuntimeError)
       STDERR.puts "#{Time.now}: finished: raises an error if called on a closed channel"