grpc 1.72.0-x86-mingw32 → 1.74.0.pre2-x86-mingw32

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

@@ -26,9 +26,6 @@
 /* Initializes the Channel class. */
 void Init_grpc_channel();
 
-void grpc_rb_channel_polling_thread_start();
-void grpc_rb_channel_polling_thread_stop();
-
 /* Gets the wrapped channel from the ruby wrapper */
 grpc_channel* grpc_rb_get_wrapped_channel(VALUE v);
 

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

@@ -34,15 +34,22 @@ typedef struct next_call_stack {
   grpc_event event;
   gpr_timespec timeout;
   void* tag;
-  void (*unblock_func)(void*);
-  void* unblock_func_arg;
+  volatile int interrupted;
 } next_call_stack;
 
 /* Calls grpc_completion_queue_pluck without holding the ruby GIL */
 static void* grpc_rb_completion_queue_pluck_no_gil(void* param) {
   next_call_stack* const next_call = (next_call_stack*)param;
-  next_call->event = grpc_completion_queue_pluck(next_call->cq, next_call->tag,
-                                                 next_call->timeout, NULL);
+  gpr_timespec increment = gpr_time_from_millis(200, GPR_TIMESPAN);
+  gpr_timespec deadline;
+  for (;;) {
+    deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), increment);
+    next_call->event = grpc_completion_queue_pluck(
+        next_call->cq, next_call->tag, deadline, NULL);
+    if (next_call->event.type != GRPC_QUEUE_TIMEOUT) break;
+    if (gpr_time_cmp(deadline, next_call->timeout) > 0) break;
+    if (next_call->interrupted) break;
+  }
   return NULL;
 }
 
@@ -56,28 +63,33 @@ void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq) {
   grpc_completion_queue_destroy(cq);
 }
 
-static void outer_unblock_func(void* param) {
+static void unblock_func(void* param) {
   next_call_stack* const next_call = (next_call_stack*)param;
-  if (next_call->unblock_func == NULL) return;
-  next_call->unblock_func(next_call->unblock_func_arg);
+  next_call->interrupted = 1;
 }
 
 /* Does the same thing as grpc_completion_queue_pluck, while properly releasing
    the GVL and handling interrupts */
 grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
                                      gpr_timespec deadline,
-                                     void (*unblock_func)(void* param),
-                                     void* unblock_func_arg) {
+                                     const char* reason) {
   next_call_stack next_call;
   MEMZERO(&next_call, next_call_stack, 1);
   next_call.cq = queue;
   next_call.timeout = deadline;
   next_call.tag = tag;
   next_call.event.type = GRPC_QUEUE_TIMEOUT;
-  next_call.unblock_func = unblock_func;
-  next_call.unblock_func_arg = unblock_func_arg;
-  rb_thread_call_without_gvl(grpc_rb_completion_queue_pluck_no_gil,
-                             (void*)&next_call, outer_unblock_func,
-                             (void*)&next_call);
+  /* Loop until we finish a pluck without an interruption. See
+   * https://github.com/grpc/grpc/issues/38210 for an example of why
+   * this is necessary. */
+  grpc_absl_log_str(GPR_DEBUG, "CQ pluck loop begin: ", reason);
+  do {
+    next_call.interrupted = 0;
+    rb_thread_call_without_gvl(grpc_rb_completion_queue_pluck_no_gil,
+                               (void*)&next_call, unblock_func,
+                               (void*)&next_call);
+    if (next_call.event.type != GRPC_QUEUE_TIMEOUT) break;
+  } while (next_call.interrupted);
+  grpc_absl_log_str(GPR_DEBUG, "CQ pluck loop done: ", reason);
   return next_call.event;
 }

data/src/ruby/ext/grpc/rb_completion_queue.h

@@ -29,14 +29,8 @@ void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq);
  * Makes the implementation of CompletionQueue#pluck available in other files
  *
  * This avoids having code that holds the GIL repeated at multiple sites.
- *
- * unblock_func is invoked with the provided argument to unblock the CQ
- * operation in the event of process termination (e.g. a signal), but
- * unblock_func may be NULL in which case it's unused.
  */
 grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
-                                     gpr_timespec deadline,
-                                     void (*unblock_func)(void* param),
-                                     void* unblock_func_arg);
+                                     gpr_timespec deadline, const char* reason);
 
 #endif /* GRPC_RB_COMPLETION_QUEUE_H_ */

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

@@ -333,7 +333,6 @@ static void grpc_ruby_init_threads() {
   rb_mutex_lock(g_bg_thread_init_rb_mu);
   if (!g_bg_thread_init_done) {
     grpc_rb_event_queue_thread_start();
-    grpc_rb_channel_polling_thread_start();
     g_bg_thread_init_done = true;
   }
   rb_mutex_unlock(g_bg_thread_init_rb_mu);
@@ -381,7 +380,7 @@ static VALUE grpc_rb_prefork(VALUE self) {
     rb_raise(rb_eRuntimeError,
              "GRPC.prefork and fork need to be called from the same thread "
              "that GRPC was initialized on (GRPC lazy-initializes when when "
-             "the first GRPC object is created");
+             "the first GRPC object is created)");
   }
   if (g_grpc_rb_num_fork_unsafe_threads > 0) {
     rb_raise(
@@ -395,7 +394,6 @@ static VALUE grpc_rb_prefork(VALUE self) {
   g_grpc_rb_prefork_pending = true;
   rb_mutex_lock(g_bg_thread_init_rb_mu);
   if (g_bg_thread_init_done) {
-    grpc_rb_channel_polling_thread_stop();
     grpc_rb_event_queue_thread_stop();
     // all ruby-level background threads joined at this point
     g_bg_thread_init_done = false;
@@ -449,9 +447,15 @@ void grpc_rb_fork_unsafe_begin() { g_grpc_rb_num_fork_unsafe_threads++; }
 void grpc_rb_fork_unsafe_end() { g_grpc_rb_num_fork_unsafe_threads--; }
 
 // APIs to mark fork-unsafe sections from ruby code
-static VALUE grpc_rb_fork_unsafe_begin_api() { grpc_rb_fork_unsafe_begin(); }
+static VALUE grpc_rb_fork_unsafe_begin_api() {
+  grpc_rb_fork_unsafe_begin();
+  return Qnil;
+}
 
-static VALUE grpc_rb_fork_unsafe_end_api() { grpc_rb_fork_unsafe_end(); }
+static VALUE grpc_rb_fork_unsafe_end_api() {
+  grpc_rb_fork_unsafe_end();
+  return Qnil;
+}
 
 // One-time initialization
 void Init_grpc_c() {

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

@@ -132,7 +132,7 @@ extern grpc_metadata_credentials_create_from_plugin_type grpc_metadata_credentia
 typedef void(*grpc_call_credentials_release_type)(grpc_call_credentials* creds);
 extern grpc_call_credentials_release_type grpc_call_credentials_release_import;
 #define grpc_call_credentials_release grpc_call_credentials_release_import
-typedef grpc_channel_credentials*(*grpc_google_default_credentials_create_type)(grpc_call_credentials* call_credentials);
+typedef grpc_channel_credentials*(*grpc_google_default_credentials_create_type)(grpc_call_credentials* call_creds_for_tls, grpc_call_credentials* call_creds_for_alts);
 extern grpc_google_default_credentials_create_type grpc_google_default_credentials_create_import;
 #define grpc_google_default_credentials_create grpc_google_default_credentials_create_import
 typedef grpc_ssl_server_certificate_config*(*grpc_ssl_server_certificate_config_create_type)(const char* pem_root_certs, const grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, size_t num_key_cert_pairs);

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

@@ -23,11 +23,7 @@
 
 int grpc_rb_load_core() {
 #if GPR_ARCH_64
-#if GRPC_RUBY_WINDOWS_UCRT
   TCHAR fname[] = _T("grpc_c.64-ucrt.ruby");
-#else
-  TCHAR fname[] = _T("grpc_c.64-msvcrt.ruby");
-#endif
 #else
   TCHAR fname[] = _T("grpc_c.32-msvcrt.ruby");
 #endif

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

@@ -49,28 +49,32 @@ typedef struct grpc_rb_server {
   /* The actual server */
   grpc_server* wrapped;
   grpc_completion_queue* queue;
+  int shutdown_and_notify_done;
   int destroy_done;
 } grpc_rb_server;
 
-static void grpc_rb_server_shutdown_and_notify_internal(grpc_rb_server* server,
-                                                        gpr_timespec deadline) {
+static void grpc_rb_server_maybe_shutdown_and_notify(grpc_rb_server* server,
+                                                     gpr_timespec deadline) {
   grpc_event ev;
   void* tag = &ev;
-  if (server->wrapped != NULL) {
-    grpc_server_shutdown_and_notify(server->wrapped, server->queue, tag);
-    // Following pluck calls will release the GIL and block but cannot
-    // be interrupted. They should terminate quickly enough though b/c
-    // we will cancel all server calls after the deadline.
-    ev = rb_completion_queue_pluck(server->queue, tag, deadline, NULL, NULL);
-    if (ev.type == GRPC_QUEUE_TIMEOUT) {
-      grpc_server_cancel_all_calls(server->wrapped);
+  if (!server->shutdown_and_notify_done) {
+    server->shutdown_and_notify_done = 1;
+    if (server->wrapped != NULL) {
+      grpc_server_shutdown_and_notify(server->wrapped, server->queue, tag);
       ev = rb_completion_queue_pluck(
-          server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME), NULL, NULL);
-    }
-    if (ev.type != GRPC_OP_COMPLETE) {
-      grpc_absl_log_int(
-          GPR_DEBUG,
-          "GRPC_RUBY: bad grpc_server_shutdown_and_notify result:", ev.type);
+          server->queue, tag, deadline,
+          "grpc_server_shutdown_and_notify first try");
+      if (ev.type == GRPC_QUEUE_TIMEOUT) {
+        grpc_server_cancel_all_calls(server->wrapped);
+        ev = rb_completion_queue_pluck(
+            server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME),
+            "grpc_server_shutdown_and_notify second try");
+      }
+      if (ev.type != GRPC_OP_COMPLETE) {
+        grpc_absl_log_int(
+            GPR_DEBUG,
+            "GRPC_RUBY: bad grpc_server_shutdown_and_notify result: ", ev.type);
+      }
     }
   }
 }
@@ -89,19 +93,15 @@ static void grpc_rb_server_maybe_destroy(grpc_rb_server* server) {
 }
 
 static void grpc_rb_server_free_internal(void* p) {
-  grpc_rb_server* svr = NULL;
-  gpr_timespec deadline;
   if (p == NULL) {
     return;
   };
-  svr = (grpc_rb_server*)p;
-
-  deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
-                          gpr_time_from_seconds(2, GPR_TIMESPAN));
-
-  grpc_rb_server_shutdown_and_notify_internal(svr, deadline);
-  grpc_rb_server_maybe_destroy(svr);
-
+  grpc_rb_server* server = (grpc_rb_server*)p;
+  // Shutdown the server first if we haven't already
+  gpr_timespec deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                                       gpr_time_from_seconds(2, GPR_TIMESPAN));
+  grpc_rb_server_maybe_shutdown_and_notify(server, deadline);
+  grpc_rb_server_maybe_destroy(server);
   xfree(p);
 }
 
@@ -131,6 +131,7 @@ static VALUE grpc_rb_server_alloc(VALUE cls) {
   grpc_rb_server* wrapper = ALLOC(grpc_rb_server);
   wrapper->wrapped = NULL;
   wrapper->destroy_done = 0;
+  wrapper->shutdown_and_notify_done = 0;
   return TypedData_Wrap_Struct(cls, &grpc_rb_server_data_type, wrapper);
 }
 
@@ -190,26 +191,6 @@ struct server_request_call_args {
   request_call_stack st;
 };
 
-static void shutdown_server_unblock_func(void* arg) {
-  grpc_rb_server* server = (grpc_rb_server*)arg;
-  grpc_absl_log(GPR_DEBUG, "GRPC_RUBY: shutdown_server_unblock_func");
-  GRPC_RUBY_ASSERT(server->wrapped != NULL);
-  grpc_event event;
-  void* tag = &event;
-  grpc_server_shutdown_and_notify(server->wrapped, server->queue, tag);
-  grpc_server_cancel_all_calls(server->wrapped);
-  // Following call is blocking, but should finish quickly since we've
-  // cancelled all calls.
-  event = grpc_completion_queue_pluck(server->queue, tag,
-                                      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
-  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) {
   grpc_rb_fork_unsafe_begin();
   struct server_request_call_args* args =
@@ -232,9 +213,9 @@ static VALUE grpc_rb_server_request_call_try(VALUE value_args) {
              grpc_call_error_detail_of(err), err);
   }
 
-  grpc_event ev = rb_completion_queue_pluck(
-      args->server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME),
-      shutdown_server_unblock_func, args->server);
+  grpc_event ev = rb_completion_queue_pluck(args->server->queue, tag,
+                                            gpr_inf_future(GPR_CLOCK_REALTIME),
+                                            "server request call");
   if (!ev.success) {
     rb_raise(grpc_rb_eCallError, "request_call completion failed");
   }
@@ -307,7 +288,7 @@ static VALUE grpc_rb_server_shutdown_and_notify(VALUE self, VALUE timeout) {
     deadline = grpc_rb_time_timeval(timeout, /* absolute time*/ 0);
   }
 
-  grpc_rb_server_shutdown_and_notify_internal(s, deadline);
+  grpc_rb_server_maybe_shutdown_and_notify(s, deadline);
 
   return Qnil;
 }

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

@@ -60,7 +60,7 @@ module GRPC
     # Minimally, a stub is created with the just the host of the gRPC service
     # it wishes to access, e.g.,
     #
-    #   my_stub = ClientStub.new(example.host.com:50505,
+    #   my_stub = ClientStub.new("example.host.com:50505",
     #                            :this_channel_is_insecure)
     #
     # If a channel_override argument is passed, it will be used as the
@@ -72,7 +72,7 @@ module GRPC
     #
     # - :channel_override
     # when present, this must be a pre-created GRPC::Core::Channel.  If it's
-    # present the host and arbitrary keyword arg areignored, and the RPC
+    # present the host and arbitrary keyword args are ignored, and the RPC
     # connection uses this channel.
     #
     # - :timeout
@@ -118,11 +118,11 @@ module GRPC
     #
     # * it does not return until a response is received.
     #
-    # * the requests is sent only when GRPC core's flow control allows it to
+    # * the request is sent only when GRPC core's flow control allows it to
     #   be sent.
     #
     # == Errors ==
-    # An RuntimeError is raised if
+    # A RuntimeError is raised if
     #
     # * the server responds with a non-OK status
     #

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

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.72.0'
+  VERSION = '1.74.0.pre2'
 end

data/src/ruby/spec/core_spec.rb

@@ -0,0 +1,22 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+describe GRPC::Core do
+  it 'returns valid VALUEs from C functions' do
+    expect(GRPC::Core.fork_unsafe_begin).to be_nil
+    expect(GRPC::Core.fork_unsafe_end).to be_nil
+  end
+end

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

@@ -60,8 +60,8 @@ describe GRPC::ActiveCall do
 
   after(:each) do
     @server.shutdown_and_notify(deadline)
-    @server.close
     @server_thread.join
+    @server.close
     # Don't rely on GC to unref the call, since that can prevent
     # the channel connectivity state polling thread from shutting down.
     @call.close

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

@@ -64,12 +64,8 @@ end
 def sanity_check_values_of_accessors(op_view,
                                      expected_metadata,
                                      expected_trailing_metadata)
-  expected_status = Struct::Status.new
-  expected_status.code = 0
-  expected_status.details = 'OK'
-  expected_status.metadata = expected_trailing_metadata
-
-  expect(op_view.status).to eq(expected_status)
+  expect(op_view.status.code).to eq(0)
+  expect(op_view.status.metadata).to eq(expected_trailing_metadata)
   expect(op_view.metadata).to eq(expected_metadata)
   expect(op_view.trailing_metadata).to eq(expected_trailing_metadata)
 

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

@@ -46,7 +46,7 @@ class FailingService
 
   def initialize(_default_var = 'ignored')
     @details = 'app error'
-    @code = 101
+    @code = 3
     @md = { 'failed_method' => 'an_rpc' }
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grpc
 version: !ruby/object:Gem::Version
-  version: 1.72.0
+  version: 1.74.0.pre2
 platform: x86-mingw32
 authors:
 - gRPC Authors
@@ -205,7 +205,6 @@ extra_rdoc_files: []
 files:
 - etc/roots.pem
 - grpc_c.32-msvcrt.ruby
-- grpc_c.64-msvcrt.ruby
 - grpc_c.64-ucrt.ruby
 - src/ruby/bin/math_client.rb
 - src/ruby/bin/math_pb.rb
@@ -254,7 +253,6 @@ files:
 - src/ruby/ext/grpc/rb_xds_server_credentials.c
 - src/ruby/ext/grpc/rb_xds_server_credentials.h
 - src/ruby/lib/grpc.rb
-- src/ruby/lib/grpc/3.0/grpc_c.so
 - src/ruby/lib/grpc/3.1/grpc_c.so
 - src/ruby/lib/grpc/3.2/grpc_c.so
 - src/ruby/lib/grpc/3.3/grpc_c.so
@@ -299,6 +297,7 @@ files:
 - src/ruby/spec/client_auth_spec.rb
 - src/ruby/spec/client_server_spec.rb
 - src/ruby/spec/compression_options_spec.rb
+- src/ruby/spec/core_spec.rb
 - src/ruby/spec/debug_message_spec.rb
 - src/ruby/spec/error_sanity_spec.rb
 - src/ruby/spec/errors_spec.rb
@@ -348,7 +347,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
   - - "<"
     - !ruby/object:Gem::Version
       version: 3.5.dev
@@ -358,7 +357,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.7.0
 specification_version: 4
 summary: GRPC system in Ruby
 test_files:
@@ -373,6 +372,7 @@ test_files:
 - src/ruby/spec/client_auth_spec.rb
 - src/ruby/spec/client_server_spec.rb
 - src/ruby/spec/compression_options_spec.rb
+- src/ruby/spec/core_spec.rb
 - src/ruby/spec/debug_message_spec.rb
 - src/ruby/spec/error_sanity_spec.rb
 - src/ruby/spec/errors_spec.rb