grpc 1.66.0-x64-mingw32 → 1.67.0.pre1-x64-mingw32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: e2bf00a6d533b92df178983c878e4a4de2e25f7939e38ac4cb7440f0f89c8e5f
4
- data.tar.gz: d8ae2327168e209723bda5dd03eada756e755d91f46f2f39ba52867ee3a564c8
3
+ metadata.gz: ba7e0ece8ee58815ac433e6591d5a3a7a7efc2959d5b49c0c0c6549adbe62520
4
+ data.tar.gz: 6887f9bd8d334e4449a9223075a39e5c7b9a21cea2c2ecf2fb55aba85c1684eb
5
5
  SHA512:
6
- metadata.gz: 3d006d9d8c74fe0a42f5e0ed61c2dfcb8ada845645a78c3f91a1ae736d01853857b0ee46779676ad16d9f6593b00d0c2d7e39e132b45065ded49cdcd18075780
7
- data.tar.gz: 68517b2b5c5ff9f3634661f11f0505e58a9caff5f7097e2b6396aa09b3c4e2e56c9b81751900d53ae804726af03d729639733c41fbca72acca3bc7fe85437abc
6
+ metadata.gz: cb155049a78fdf5a53cf4455948ebc72a5a5e6ff03f556b86b1e80f44ab8e2a10a0750f40e96bfb014ed3fe422f95df123daa5f384d790eeb4e62df380dd1b71
7
+ data.tar.gz: ed9ea9a78ef5772c592464d9490c33d39acf413fb659367575940ce54dd691c94bc0d00ed7a6a2e567a9db59a828bfec54d5a8a34826740b9e0a63750e13f34c
Binary file
@@ -809,7 +809,7 @@ struct call_run_batch_args {
809
809
  };
810
810
 
811
811
  static void cancel_call_unblock_func(void* arg) {
812
- gpr_log(GPR_DEBUG, "GRPC_RUBY: cancel_call_unblock_func");
812
+ grpc_absl_log(GPR_DEBUG, "GRPC_RUBY: cancel_call_unblock_func");
813
813
  grpc_call* call = (grpc_call*)arg;
814
814
  grpc_call_cancel(call, NULL);
815
815
  }
@@ -60,30 +60,32 @@ static VALUE grpc_rb_call_credentials_callback(VALUE args) {
60
60
  VALUE callback_func = rb_ary_entry(args, 0);
61
61
  VALUE callback_args = rb_ary_entry(args, 1);
62
62
  VALUE md_ary_obj = rb_ary_entry(args, 2);
63
- if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
64
- VALUE callback_func_str = rb_funcall(callback_func, rb_intern("to_s"), 0);
65
- VALUE callback_args_str = rb_funcall(callback_args, rb_intern("to_s"), 0);
66
- VALUE callback_source_info =
67
- rb_funcall(callback_func, rb_intern("source_location"), 0);
68
- if (callback_source_info != Qnil) {
69
- VALUE source_filename = rb_ary_entry(callback_source_info, 0);
70
- VALUE source_line_number = rb_funcall(
71
- rb_ary_entry(callback_source_info, 1), rb_intern("to_s"), 0);
72
- gpr_log(GPR_DEBUG,
73
- "GRPC_RUBY: grpc_rb_call_credentials invoking user callback:|%s| "
74
- "source_filename:%s line_number:%s with arguments:|%s|",
75
- StringValueCStr(callback_func_str),
76
- StringValueCStr(source_filename),
77
- StringValueCStr(source_line_number),
78
- StringValueCStr(callback_args_str));
79
- } else {
80
- gpr_log(GPR_DEBUG,
81
- "GRPC_RUBY: grpc_rb_call_credentials invoking user callback:|%s| "
82
- "(failed to get source filename and line) with arguments:|%s|",
83
- StringValueCStr(callback_func_str),
84
- StringValueCStr(callback_args_str));
85
- }
63
+
64
+ VALUE callback_func_str = rb_funcall(callback_func, rb_intern("to_s"), 0);
65
+ VALUE callback_args_str = rb_funcall(callback_args, rb_intern("to_s"), 0);
66
+ VALUE callback_source_info =
67
+ rb_funcall(callback_func, rb_intern("source_location"), 0);
68
+
69
+ grpc_absl_log_str(
70
+ GPR_DEBUG, "GRPC_RUBY: grpc_rb_call_credentials invoking user callback:",
71
+ StringValueCStr(callback_func_str));
72
+
73
+ if (callback_source_info != Qnil) {
74
+ VALUE source_filename = rb_ary_entry(callback_source_info, 0);
75
+ VALUE source_line_number =
76
+ rb_funcall(rb_ary_entry(callback_source_info, 1), rb_intern("to_s"), 0);
77
+ grpc_absl_log_str(GPR_DEBUG, "GRPC_RUBY: source_filename: ",
78
+ StringValueCStr(source_filename));
79
+ grpc_absl_log_str(GPR_DEBUG, "GRPC_RUBY: source_line_number: ",
80
+ StringValueCStr(source_line_number));
81
+ grpc_absl_log_str(GPR_DEBUG, "GRPC_RUBY: Arguments: ",
82
+ StringValueCStr(callback_args_str));
83
+ } else {
84
+ grpc_absl_log_str(
85
+ GPR_DEBUG, "(failed to get source filename and line) with arguments: ",
86
+ StringValueCStr(callback_args_str));
86
87
  }
88
+
87
89
  VALUE metadata =
88
90
  rb_funcall(callback_func, rb_intern("call"), 1, callback_args);
89
91
  grpc_metadata_array* md_ary = NULL;
@@ -112,10 +114,15 @@ static VALUE grpc_rb_call_credentials_callback_rescue(VALUE args,
112
114
  VALUE rb_exception_info =
113
115
  rb_funcall(exception_object, rb_intern("inspect"), 0);
114
116
  (void)args;
115
- gpr_log(GPR_DEBUG,
116
- "GRPC_RUBY call credentials callback failed, exception inspect:|%s| "
117
- "backtrace:|%s|",
118
- StringValueCStr(rb_exception_info), StringValueCStr(backtrace_str));
117
+
118
+ grpc_absl_log_str(
119
+ GPR_DEBUG,
120
+ "GRPC_RUBY call credentials callback failed, exception inspect: ",
121
+ StringValueCStr(rb_exception_info));
122
+ grpc_absl_log_str(GPR_DEBUG,
123
+ "GRPC_RUBY call credentials callback failed, backtrace: ",
124
+ StringValueCStr(backtrace_str));
125
+
119
126
  rb_hash_aset(result, rb_str_new2("metadata"), Qnil);
120
127
  rb_hash_aset(result, rb_str_new2("status"),
121
128
  INT2NUM(GRPC_STATUS_UNAUTHENTICATED));
@@ -655,7 +655,7 @@ static void* run_poll_channels_loop_no_gil(void* arg) {
655
655
  watch_state_op* op = NULL;
656
656
  bg_watched_channel* bg = NULL;
657
657
  (void)arg;
658
- gpr_log(GPR_DEBUG, "GRPC_RUBY: run_poll_channels_loop_no_gil - begin");
658
+ grpc_absl_log(GPR_DEBUG, "GRPC_RUBY: run_poll_channels_loop_no_gil - begin");
659
659
 
660
660
  gpr_mu_lock(&global_connection_polling_mu);
661
661
  gpr_cv_broadcast(&global_connection_polling_cv);
@@ -685,9 +685,10 @@ static void* run_poll_channels_loop_no_gil(void* arg) {
685
685
  gpr_mu_unlock(&global_connection_polling_mu);
686
686
  }
687
687
  grpc_completion_queue_destroy(g_channel_polling_cq);
688
- gpr_log(GPR_DEBUG,
689
- "GRPC_RUBY: run_poll_channels_loop_no_gil - exit connection polling "
690
- "loop");
688
+ grpc_absl_log(
689
+ GPR_DEBUG,
690
+ "GRPC_RUBY: run_poll_channels_loop_no_gil - exit connection polling "
691
+ "loop");
691
692
  return NULL;
692
693
  }
693
694
 
@@ -701,9 +702,10 @@ static void* run_poll_channels_loop_unblocking_func_wrapper(void* arg) {
701
702
  (void)arg;
702
703
 
703
704
  gpr_mu_lock(&global_connection_polling_mu);
704
- gpr_log(GPR_DEBUG,
705
- "GRPC_RUBY: run_poll_channels_loop_unblocking_func - begin aborting "
706
- "connection polling");
705
+ grpc_absl_log(
706
+ GPR_DEBUG,
707
+ "GRPC_RUBY: run_poll_channels_loop_unblocking_func - begin aborting "
708
+ "connection polling");
707
709
  // early out after first time through
708
710
  if (g_abort_channel_polling) {
709
711
  gpr_mu_unlock(&global_connection_polling_mu);
@@ -721,21 +723,23 @@ static void* run_poll_channels_loop_unblocking_func_wrapper(void* arg) {
721
723
  bg = bg->next;
722
724
  }
723
725
 
724
- gpr_log(GPR_DEBUG, "GRPC_RUBY: cq shutdown on global polling cq. pid: %d",
725
- getpid());
726
+ grpc_absl_log_int(
727
+ GPR_DEBUG,
728
+ "GRPC_RUBY: cq shutdown on global polling cq. pid: ", getpid());
726
729
  grpc_completion_queue_shutdown(g_channel_polling_cq);
727
730
  gpr_cv_broadcast(&global_connection_polling_cv);
728
731
  gpr_mu_unlock(&global_connection_polling_mu);
729
- gpr_log(GPR_DEBUG,
730
- "GRPC_RUBY: run_poll_channels_loop_unblocking_func - end aborting "
731
- "connection polling");
732
+ grpc_absl_log(
733
+ GPR_DEBUG,
734
+ "GRPC_RUBY: run_poll_channels_loop_unblocking_func - end aborting "
735
+ "connection polling");
732
736
  return NULL;
733
737
  }
734
738
 
735
739
  // Poll channel connectivity states in background thread without the GIL.
736
740
  static VALUE run_poll_channels_loop(void* arg) {
737
741
  (void)arg;
738
- gpr_log(
742
+ grpc_absl_log(
739
743
  GPR_DEBUG,
740
744
  "GRPC_RUBY: run_poll_channels_loop - create connection polling thread");
741
745
  rb_thread_call_without_gvl(run_poll_channels_loop_no_gil, NULL,
@@ -777,7 +781,8 @@ void grpc_rb_channel_polling_thread_start() {
777
781
  g_channel_polling_thread = rb_thread_create(run_poll_channels_loop, NULL);
778
782
 
779
783
  if (!RTEST(g_channel_polling_thread)) {
780
- gpr_log(GPR_ERROR, "GRPC_RUBY: failed to spawn channel polling thread");
784
+ grpc_absl_log(GPR_ERROR,
785
+ "GRPC_RUBY: failed to spawn channel polling thread");
781
786
  rb_thread_call_without_gvl(set_abort_channel_polling_without_gil, NULL,
782
787
  NULL, NULL);
783
788
  return;
@@ -786,8 +791,9 @@ void grpc_rb_channel_polling_thread_start() {
786
791
 
787
792
  void grpc_rb_channel_polling_thread_stop() {
788
793
  if (!RTEST(g_channel_polling_thread)) {
789
- gpr_log(GPR_ERROR,
790
- "GRPC_RUBY: channel polling thread stop: thread was not started");
794
+ grpc_absl_log(
795
+ GPR_ERROR,
796
+ "GRPC_RUBY: channel polling thread stop: thread was not started");
791
797
  return;
792
798
  }
793
799
  rb_thread_call_without_gvl(run_poll_channels_loop_unblocking_func_wrapper,
@@ -156,8 +156,9 @@ void grpc_rb_event_queue_thread_start() {
156
156
  void grpc_rb_event_queue_thread_stop() {
157
157
  GRPC_RUBY_ASSERT(g_one_time_init_done);
158
158
  if (!RTEST(g_event_thread)) {
159
- gpr_log(GPR_ERROR,
160
- "GRPC_RUBY: call credentials thread stop: thread not running");
159
+ grpc_absl_log(
160
+ GPR_ERROR,
161
+ "GRPC_RUBY: call credentials thread stop: thread not running");
161
162
  return;
162
163
  }
163
164
  rb_thread_call_without_gvl(grpc_rb_event_unblocking_func_wrapper, NULL, NULL,
@@ -328,9 +328,9 @@ static void grpc_ruby_init_threads() {
328
328
  // in gpr_once_init. In general, it appears to be unsafe to call
329
329
  // into the ruby library while holding a non-ruby mutex, because a gil yield
330
330
  // could end up trying to lock onto that same mutex and deadlocking.
331
- gpr_log(GPR_DEBUG,
332
- "GRPC_RUBY: grpc_ruby_init_threads g_bg_thread_init_done=%d",
333
- g_bg_thread_init_done);
331
+ grpc_absl_log_int(GPR_DEBUG,
332
+ "GRPC_RUBY: grpc_ruby_init_threads g_bg_thread_init_done=",
333
+ g_bg_thread_init_done);
334
334
  rb_mutex_lock(g_bg_thread_init_rb_mu);
335
335
  if (!g_bg_thread_init_done) {
336
336
  grpc_rb_event_queue_thread_start();
@@ -347,11 +347,12 @@ void grpc_ruby_init() {
347
347
  grpc_ruby_fork_guard();
348
348
  grpc_init();
349
349
  grpc_ruby_init_threads();
350
- // (only gpr_log after logging has been initialized)
351
- gpr_log(GPR_DEBUG,
352
- "GRPC_RUBY: grpc_ruby_init - g_enable_fork_support=%d prev "
353
- "g_grpc_ruby_init_count:%" PRId64,
354
- g_enable_fork_support, g_grpc_ruby_init_count++);
350
+ // (only log after logging has been initialized)
351
+ grpc_absl_log_int(GPR_DEBUG,
352
+ "GRPC_RUBY: grpc_ruby_init - g_enable_fork_support=",
353
+ g_enable_fork_support);
354
+ grpc_absl_log_int(GPR_DEBUG,
355
+ "prev g_grpc_ruby_init_count:", g_grpc_ruby_init_count++);
355
356
  }
356
357
 
357
358
  // fork APIs, useable on linux with env var: GRPC_ENABLE_FORK_SUPPORT=1
@@ -253,12 +253,10 @@ gpr_malloc_aligned_type gpr_malloc_aligned_import;
253
253
  gpr_free_aligned_type gpr_free_aligned_import;
254
254
  gpr_cpu_num_cores_type gpr_cpu_num_cores_import;
255
255
  gpr_cpu_current_cpu_type gpr_cpu_current_cpu_import;
256
- gpr_log_type gpr_log_import;
257
- gpr_should_log_type gpr_should_log_import;
258
- gpr_log_message_type gpr_log_message_import;
259
- gpr_set_log_verbosity_type gpr_set_log_verbosity_import;
256
+ grpc_absl_log_type grpc_absl_log_import;
257
+ grpc_absl_log_int_type grpc_absl_log_int_import;
258
+ grpc_absl_log_str_type grpc_absl_log_str_import;
260
259
  gpr_log_verbosity_init_type gpr_log_verbosity_init_import;
261
- gpr_set_log_function_type gpr_set_log_function_import;
262
260
  gpr_format_message_type gpr_format_message_import;
263
261
  gpr_strdup_type gpr_strdup_import;
264
262
  gpr_asprintf_type gpr_asprintf_import;
@@ -541,12 +539,10 @@ void grpc_rb_load_imports(HMODULE library) {
541
539
  gpr_free_aligned_import = (gpr_free_aligned_type) GetProcAddress(library, "gpr_free_aligned");
542
540
  gpr_cpu_num_cores_import = (gpr_cpu_num_cores_type) GetProcAddress(library, "gpr_cpu_num_cores");
543
541
  gpr_cpu_current_cpu_import = (gpr_cpu_current_cpu_type) GetProcAddress(library, "gpr_cpu_current_cpu");
544
- gpr_log_import = (gpr_log_type) GetProcAddress(library, "gpr_log");
545
- gpr_should_log_import = (gpr_should_log_type) GetProcAddress(library, "gpr_should_log");
546
- gpr_log_message_import = (gpr_log_message_type) GetProcAddress(library, "gpr_log_message");
547
- gpr_set_log_verbosity_import = (gpr_set_log_verbosity_type) GetProcAddress(library, "gpr_set_log_verbosity");
542
+ grpc_absl_log_import = (grpc_absl_log_type) GetProcAddress(library, "grpc_absl_log");
543
+ grpc_absl_log_int_import = (grpc_absl_log_int_type) GetProcAddress(library, "grpc_absl_log_int");
544
+ grpc_absl_log_str_import = (grpc_absl_log_str_type) GetProcAddress(library, "grpc_absl_log_str");
548
545
  gpr_log_verbosity_init_import = (gpr_log_verbosity_init_type) GetProcAddress(library, "gpr_log_verbosity_init");
549
- gpr_set_log_function_import = (gpr_set_log_function_type) GetProcAddress(library, "gpr_set_log_function");
550
546
  gpr_format_message_import = (gpr_format_message_type) GetProcAddress(library, "gpr_format_message");
551
547
  gpr_strdup_import = (gpr_strdup_type) GetProcAddress(library, "gpr_strdup");
552
548
  gpr_asprintf_import = (gpr_asprintf_type) GetProcAddress(library, "gpr_asprintf");
@@ -735,24 +735,18 @@ extern gpr_cpu_num_cores_type gpr_cpu_num_cores_import;
735
735
  typedef unsigned(*gpr_cpu_current_cpu_type)(void);
736
736
  extern gpr_cpu_current_cpu_type gpr_cpu_current_cpu_import;
737
737
  #define gpr_cpu_current_cpu gpr_cpu_current_cpu_import
738
- typedef void(*gpr_log_type)(const char* file, int line, gpr_log_severity severity, const char* format, ...) GPR_PRINT_FORMAT_CHECK(4, 5);
739
- extern gpr_log_type gpr_log_import;
740
- #define gpr_log gpr_log_import
741
- typedef int(*gpr_should_log_type)(gpr_log_severity severity);
742
- extern gpr_should_log_type gpr_should_log_import;
743
- #define gpr_should_log gpr_should_log_import
744
- typedef void(*gpr_log_message_type)(const char* file, int line, gpr_log_severity severity, const char* message);
745
- extern gpr_log_message_type gpr_log_message_import;
746
- #define gpr_log_message gpr_log_message_import
747
- typedef void(*gpr_set_log_verbosity_type)(gpr_log_severity deprecated_setting);
748
- extern gpr_set_log_verbosity_type gpr_set_log_verbosity_import;
749
- #define gpr_set_log_verbosity gpr_set_log_verbosity_import
738
+ typedef void(*grpc_absl_log_type)(const char* file, int line, gpr_log_severity severity, const char* message_str);
739
+ extern grpc_absl_log_type grpc_absl_log_import;
740
+ #define grpc_absl_log grpc_absl_log_import
741
+ typedef void(*grpc_absl_log_int_type)(const char* file, int line, gpr_log_severity severity, const char* message_str, intptr_t num);
742
+ extern grpc_absl_log_int_type grpc_absl_log_int_import;
743
+ #define grpc_absl_log_int grpc_absl_log_int_import
744
+ typedef void(*grpc_absl_log_str_type)(const char* file, int line, gpr_log_severity severity, const char* message_str1, const char* message_str2);
745
+ extern grpc_absl_log_str_type grpc_absl_log_str_import;
746
+ #define grpc_absl_log_str grpc_absl_log_str_import
750
747
  typedef void(*gpr_log_verbosity_init_type)(void);
751
748
  extern gpr_log_verbosity_init_type gpr_log_verbosity_init_import;
752
749
  #define gpr_log_verbosity_init gpr_log_verbosity_init_import
753
- typedef void(*gpr_set_log_function_type)(gpr_log_func deprecated_setting);
754
- extern gpr_set_log_function_type gpr_set_log_function_import;
755
- #define gpr_set_log_function gpr_set_log_function_import
756
750
  typedef char*(*gpr_format_message_type)(int messageid);
757
751
  extern gpr_format_message_type gpr_format_message_import;
758
752
  #define gpr_format_message gpr_format_message_import
@@ -68,9 +68,9 @@ static void grpc_rb_server_shutdown_and_notify_internal(grpc_rb_server* server,
68
68
  server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME), NULL, NULL);
69
69
  }
70
70
  if (ev.type != GRPC_OP_COMPLETE) {
71
- gpr_log(GPR_DEBUG,
72
- "GRPC_RUBY: bad grpc_server_shutdown_and_notify result:%d",
73
- ev.type);
71
+ grpc_absl_log_int(
72
+ GPR_DEBUG,
73
+ "GRPC_RUBY: bad grpc_server_shutdown_and_notify result:", ev.type);
74
74
  }
75
75
  }
76
76
  }
@@ -192,7 +192,7 @@ struct server_request_call_args {
192
192
 
193
193
  static void shutdown_server_unblock_func(void* arg) {
194
194
  grpc_rb_server* server = (grpc_rb_server*)arg;
195
- gpr_log(GPR_DEBUG, "GRPC_RUBY: shutdown_server_unblock_func");
195
+ grpc_absl_log(GPR_DEBUG, "GRPC_RUBY: shutdown_server_unblock_func");
196
196
  GRPC_RUBY_ASSERT(server->wrapped != NULL);
197
197
  grpc_event event;
198
198
  void* tag = &event;
@@ -202,10 +202,12 @@ static void shutdown_server_unblock_func(void* arg) {
202
202
  // cancelled all calls.
203
203
  event = grpc_completion_queue_pluck(server->queue, tag,
204
204
  gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
205
- gpr_log(GPR_DEBUG,
206
- "GRPC_RUBY: shutdown_server_unblock_func pluck event.type: %d "
207
- "event.success: %d",
208
- event.type, event.success);
205
+ grpc_absl_log_int(
206
+ GPR_DEBUG,
207
+ "GRPC_RUBY: shutdown_server_unblock_func pluck event.type: ", event.type);
208
+ grpc_absl_log_int(
209
+ GPR_DEBUG,
210
+ "GRPC_RUBY: shutdown_server_unblock_func event.success: ", event.success);
209
211
  }
210
212
 
211
213
  static VALUE grpc_rb_server_request_call_try(VALUE value_args) {
Binary file
@@ -44,8 +44,8 @@ module GRPC
44
44
  include Core::CallOps
45
45
  extend Forwardable
46
46
  attr_reader :deadline, :metadata_sent, :metadata_to_send, :peer, :peer_cert
47
- def_delegators :@call, :cancel, :metadata, :write_flag, :write_flag=,
48
- :trailing_metadata, :status
47
+ def_delegators :@call, :cancel, :cancel_with_status, :metadata,
48
+ :write_flag, :write_flag=, :trailing_metadata, :status
49
49
 
50
50
  # client_invoke begins a client invocation.
51
51
  #
@@ -620,6 +620,8 @@ module GRPC
620
620
  # @param metadata [Hash] metadata to be sent to the server. If a value is
621
621
  # a list, multiple metadata for its key are sent
622
622
  def start_call(metadata = {})
623
+ # TODO(apolcyn): we should cancel and clean up the call in case this
624
+ # send initial MD op fails.
623
625
  merge_metadata_to_send(metadata) && send_initial_metadata
624
626
  end
625
627
 
@@ -665,9 +667,10 @@ module GRPC
665
667
 
666
668
  # Operation limits access to an ActiveCall's methods for use as
667
669
  # a Operation on the client.
668
- Operation = view_class(:cancel, :cancelled?, :deadline, :execute,
669
- :metadata, :status, :start_call, :wait, :write_flag,
670
- :write_flag=, :trailing_metadata)
670
+ # TODO(apolcyn): expose peer getter
671
+ Operation = view_class(:cancel, :cancel_with_status, :cancelled?, :deadline,
672
+ :execute, :metadata, :status, :start_call, :wait,
673
+ :write_flag, :write_flag=, :trailing_metadata)
671
674
 
672
675
  # InterceptableView further limits access to an ActiveCall's methods
673
676
  # for use in interceptors on the client, exposing only the deadline
@@ -14,5 +14,5 @@
14
14
 
15
15
  # GRPC contains the General RPC module.
16
16
  module GRPC
17
- VERSION = '1.66.0'
17
+ VERSION = '1.67.0.pre1'
18
18
  end
@@ -90,88 +90,101 @@ describe GRPC::Core::Call do
90
90
 
91
91
  describe '#status' do
92
92
  it 'can save the status and read it back' do
93
- call = make_test_call
94
- sts = Struct::Status.new(OK, 'OK')
95
- expect { call.status = sts }.not_to raise_error
96
- expect(call.status).to eq(sts)
93
+ make_test_call do |call|
94
+ sts = Struct::Status.new(OK, 'OK')
95
+ expect { call.status = sts }.not_to raise_error
96
+ expect(call.status).to eq(sts)
97
+ end
97
98
  end
98
99
 
99
100
  it 'must be set to a status' do
100
- call = make_test_call
101
- bad_sts = Object.new
102
- expect { call.status = bad_sts }.to raise_error(TypeError)
101
+ make_test_call do |call|
102
+ bad_sts = Object.new
103
+ expect { call.status = bad_sts }.to raise_error(TypeError)
104
+ end
103
105
  end
104
106
 
105
107
  it 'can be set to nil' do
106
- call = make_test_call
107
- expect { call.status = nil }.not_to raise_error
108
+ make_test_call do |call|
109
+ expect { call.status = nil }.not_to raise_error
110
+ end
108
111
  end
109
112
  end
110
113
 
111
114
  describe '#metadata' do
112
115
  it 'can save the metadata hash and read it back' do
113
- call = make_test_call
114
- md = { 'k1' => 'v1', 'k2' => 'v2' }
115
- expect { call.metadata = md }.not_to raise_error
116
- expect(call.metadata).to be(md)
116
+ make_test_call do |call|
117
+ md = { 'k1' => 'v1', 'k2' => 'v2' }
118
+ expect { call.metadata = md }.not_to raise_error
119
+ expect(call.metadata).to be(md)
120
+ end
117
121
  end
118
122
 
119
123
  it 'must be set with a hash' do
120
- call = make_test_call
121
- bad_md = Object.new
122
- expect { call.metadata = bad_md }.to raise_error(TypeError)
124
+ make_test_call do |call|
125
+ bad_md = Object.new
126
+ expect { call.metadata = bad_md }.to raise_error(TypeError)
127
+ end
123
128
  end
124
129
 
125
130
  it 'can be set to nil' do
126
- call = make_test_call
127
- expect { call.metadata = nil }.not_to raise_error
131
+ make_test_call do |call|
132
+ expect { call.metadata = nil }.not_to raise_error
133
+ end
128
134
  end
129
135
  end
130
136
 
131
137
  describe '#set_credentials!' do
132
138
  it 'can set a valid CallCredentials object' do
133
- call = make_test_call
134
- auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
135
- creds = GRPC::Core::CallCredentials.new auth_proc
136
- expect { call.set_credentials! creds }.not_to raise_error
139
+ make_test_call do |call|
140
+ auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
141
+ creds = GRPC::Core::CallCredentials.new auth_proc
142
+ expect { call.set_credentials! creds }.not_to raise_error
143
+ end
137
144
  end
138
145
  end
139
146
 
140
147
  describe '#cancel' do
141
148
  it 'completes ok' do
142
- call = make_test_call
143
- expect { call.cancel }.not_to raise_error
149
+ make_test_call do |call|
150
+ expect { call.cancel }.not_to raise_error
151
+ end
144
152
  end
145
153
 
146
154
  it 'completes ok when the call is closed' do
147
- call = make_test_call
148
- call.close
149
- expect { call.cancel }.not_to raise_error
155
+ make_test_call do |call|
156
+ call.close
157
+ expect { call.cancel }.not_to raise_error
158
+ end
150
159
  end
151
160
  end
152
161
 
153
162
  describe '#cancel_with_status' do
154
163
  it 'completes ok' do
155
- call = make_test_call
156
- expect do
157
- call.cancel_with_status(0, 'test status')
158
- end.not_to raise_error
159
- expect do
160
- call.cancel_with_status(0, nil)
161
- end.to raise_error(TypeError)
164
+ make_test_call do |call|
165
+ expect do
166
+ call.cancel_with_status(0, 'test status')
167
+ end.not_to raise_error
168
+ expect do
169
+ call.cancel_with_status(0, nil)
170
+ end.to raise_error(TypeError)
171
+ end
162
172
  end
163
173
 
164
174
  it 'completes ok when the call is closed' do
165
- call = make_test_call
166
- call.close
167
- expect do
168
- call.cancel_with_status(0, 'test status')
169
- end.not_to raise_error
175
+ make_test_call do |call|
176
+ call.close
177
+ expect do
178
+ call.cancel_with_status(0, 'test status')
179
+ end.not_to raise_error
180
+ end
170
181
  end
171
182
  end
172
183
 
173
184
  def make_test_call
174
- @ch.create_call(nil, nil, 'phony_method', nil, deadline)
185
+ call = @ch.create_call(nil, nil, 'phony_method', nil, deadline)
186
+ yield call
187
+ call.close
175
188
  end
176
189
 
177
190
  def deadline
@@ -118,7 +118,8 @@ describe GRPC::Core::Channel do
118
118
  deadline = Time.now + 5
119
119
 
120
120
  blk = proc do
121
- ch.create_call(nil, nil, 'phony_method', nil, deadline)
121
+ call = ch.create_call(nil, nil, 'phony_method', nil, deadline)
122
+ call.close
122
123
  end
123
124
  expect(&blk).to_not raise_error
124
125
  end
@@ -132,8 +133,9 @@ describe GRPC::Core::Channel do
132
133
 
133
134
  deadline = Time.now + 5
134
135
  blk = proc do
135
- ch.create_call(nil, nil, 'phony_method', nil, deadline)
136
+ call = ch.create_call(nil, nil, 'phony_method', nil, deadline)
136
137
  STDERR.puts "#{Time.now}: created call"
138
+ call.close
137
139
  end
138
140
  expect(&blk).to raise_error(RuntimeError)
139
141
  STDERR.puts "#{Time.now}: finished: raises an error if called on a closed channel"