grpc 1.66.0-x86_64-linux → 1.67.0-x86_64-linux

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 601a5941893f612d69a7019095a5e57735372882e4a2e15714bf770298ed184d
4
- data.tar.gz: c52237b084f30405c7af81a024b6e6b751a3bce2587ff9d9ac22adabcb1e0f9e
3
+ metadata.gz: 05204241c254ae9fa2b0b3b5719a31cfdb592125bc4265d1b9581434d82a5b44
4
+ data.tar.gz: a72b43c13b5552135b5ac9875b69aaed3add17a8d9babd14ccddd710bcb92f7a
5
5
  SHA512:
6
- metadata.gz: e0a25eb3e011fc819a0d06c07144e8556890dfaa7779b4e07d930981557b0ab4c08ee79a744ec9cd91197a59bbb1d3bcc800466ccd4a589da59ae5f13292bceb
7
- data.tar.gz: 7e04b89090a55eb1324a25ad1cfc882dd87c5f40dde705566a5ff1289a24257983c976b9d6e1c2212d703ebe5f140a6427cff93e8dca1c962b5558ccd6b125f1
6
+ metadata.gz: 2b44dc56632062acf2060b74e83ae2ac64611c66de335e4cb4935b805433c710692c3ff5a6ad0a451d6926866d660bff63bc2793714ec2dcc3556696193d73a9
7
+ data.tar.gz: 280249b31a3c6328975b48c3ecefca625dec872efba9c8a53f6fda6d5259efb2b0bc41abc476983f6a3f46aa02ef5b6427795983b2219d91c082cdf6ef7a0ddd
@@ -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
Binary file
Binary file
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'
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"