grpc 1.64.0-x64-mingw-ucrt → 1.65.0.pre1-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64e10686482a02a792fa476ab874b55278e270e0dca5cbba7a2e1a6a248b063c
-  data.tar.gz: f30280166a3e69bab8636782735ba8565b5f77ba567c8af9399953060b8643fe
+  metadata.gz: 585ddb9c384cc4dc37c54517d06eb45f08f63cd29d7d0ff3728c8be94e6eba5d
+  data.tar.gz: d40565406749781c5f862332f26ceed0375674796ecc5f9c2d332655a16d8526
 SHA512:
-  metadata.gz: c480415b7b232e3f5e1e7728ced25663c3bb9847310d23ae9af0260d7f6b9f599c9192d56d6e6e912a163dcddb42ca2c8607c5c13d994b1db478560714eac44c
-  data.tar.gz: 61cd5631a8e4beb2edde12a3a1b682aa46b370ed98508367db909fa115dcab7a552c26f60edb97fa97d8a815f7d33084e8656c6e74965f9a0b9d1da4757e7f0b
+  metadata.gz: ab3d25867689d2ddca0ae0b07a41b861cd880bbeb04196913c5e574c55522c09e82618d6758965d569df3fab19dfafab32d599aee013c78b606792787534b994
+  data.tar.gz: 3f849791255cc9734d2070fb593a6b452c462f05fe2a195c715639cacdfb87399f7786ccbd99bf196b701f122c116794d1e21eec5f86ed51db1af595a3abe1ec

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

@@ -808,6 +808,12 @@ struct call_run_batch_args {
   run_batch_stack* st;
 };
 
+static void cancel_call_unblock_func(void* arg) {
+  gpr_log(GPR_INFO, "GRPC_RUBY: cancel_call_unblock_func");
+  grpc_call* call = (grpc_call*)arg;
+  grpc_call_cancel(call, NULL);
+}
+
 static VALUE grpc_rb_call_run_batch_try(VALUE value_args) {
   grpc_rb_fork_unsafe_begin();
   struct call_run_batch_args* args = (struct call_run_batch_args*)value_args;
@@ -830,7 +836,8 @@ static VALUE grpc_rb_call_run_batch_try(VALUE value_args) {
              grpc_call_error_detail_of(err), err);
   }
   ev = rb_completion_queue_pluck(args->call->queue, tag,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+                                 gpr_inf_future(GPR_CLOCK_REALTIME),
+                                 cancel_call_unblock_func, args->call->wrapped);
   if (!ev.success) {
     rb_raise(grpc_rb_eCallError, "call#run_batch failed somehow");
   }

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

@@ -35,23 +35,15 @@ typedef struct next_call_stack {
   grpc_event event;
   gpr_timespec timeout;
   void* tag;
-  volatile int interrupted;
+  void (*unblock_func)(void*);
+  void* unblock_func_arg;
 } 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;
-  gpr_timespec increment = gpr_time_from_millis(20, GPR_TIMESPAN);
-  gpr_timespec deadline;
-  do {
-    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 ||
-        gpr_time_cmp(deadline, next_call->timeout) > 0) {
-      break;
-    }
-  } while (!next_call->interrupted);
+  next_call->event = grpc_completion_queue_pluck(next_call->cq, next_call->tag,
+                                                 next_call->timeout, NULL);
   return NULL;
 }
 
@@ -65,37 +57,28 @@ void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq) {
   grpc_completion_queue_destroy(cq);
 }
 
-static void unblock_func(void* param) {
+static void outer_unblock_func(void* param) {
   next_call_stack* const next_call = (next_call_stack*)param;
-  next_call->interrupted = 1;
+  if (next_call->unblock_func == NULL) return;
+  next_call->unblock_func(next_call->unblock_func_arg);
 }
 
 /* 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* reserved) {
+                                     gpr_timespec deadline,
+                                     void (*unblock_func)(void* param),
+                                     void* unblock_func_arg) {
   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;
-  (void)reserved;
-  /* Loop until we finish a pluck without an interruption. The internal
-     pluck function runs either until it is interrupted or it gets an
-     event, or time runs out.
-
-     The basic reason we need this relatively complicated construction is that
-     we need to re-acquire the GVL when an interrupt comes in, so that the ruby
-     interpreter can do what it needs to do with the interrupt. But we also need
-     to get back to plucking when the interrupt has been handled. */
-  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 an interrupt prevented pluck from returning useful information, then
-       any plucks that did complete must have timed out */
-  } while (next_call.interrupted && 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);
   return next_call.event;
 }

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

@@ -29,8 +29,14 @@ 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* reserved);
+                                     gpr_timespec deadline,
+                                     void (*unblock_func)(void* param),
+                                     void* unblock_func_arg);
 
 #endif /* GRPC_RB_COMPLETION_QUEUE_H_ */

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

@@ -49,29 +49,28 @@ 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_maybe_shutdown_and_notify(grpc_rb_server* server,
-                                                     gpr_timespec deadline) {
+static void grpc_rb_server_shutdown_and_notify_internal(grpc_rb_server* server,
+                                                        gpr_timespec deadline) {
   grpc_event ev;
   void* tag = &ev;
-  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, deadline, NULL);
-      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), NULL);
-      }
-      if (ev.type != GRPC_OP_COMPLETE) {
-        gpr_log(GPR_INFO,
-                "GRPC_RUBY: bad grpc_server_shutdown_and_notify result:%d",
-                ev.type);
-      }
+  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);
+      ev = rb_completion_queue_pluck(
+          server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME), NULL, NULL);
+    }
+    if (ev.type != GRPC_OP_COMPLETE) {
+      gpr_log(GPR_INFO,
+              "GRPC_RUBY: bad grpc_server_shutdown_and_notify result:%d",
+              ev.type);
     }
   }
 }
@@ -100,7 +99,7 @@ static void grpc_rb_server_free_internal(void* p) {
   deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
                           gpr_time_from_seconds(2, GPR_TIMESPAN));
 
-  grpc_rb_server_maybe_shutdown_and_notify(svr, deadline);
+  grpc_rb_server_shutdown_and_notify_internal(svr, deadline);
   grpc_rb_server_maybe_destroy(svr);
 
   xfree(p);
@@ -132,7 +131,6 @@ 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);
 }
 
@@ -192,6 +190,24 @@ 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;
+  gpr_log(GPR_INFO, "GRPC_RUBY: shutdown_server_unblock_func");
+  GPR_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);
+  gpr_log(GPR_INFO,
+          "GRPC_RUBY: shutdown_server_unblock_func pluck event.type: %d "
+          "event.success: %d",
+          event.type, event.success);
+}
+
 static VALUE grpc_rb_server_request_call_try(VALUE value_args) {
   grpc_rb_fork_unsafe_begin();
   struct server_request_call_args* args =
@@ -215,7 +231,8 @@ static VALUE grpc_rb_server_request_call_try(VALUE value_args) {
   }
 
   grpc_event ev = rb_completion_queue_pluck(
-      args->server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      args->server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME),
+      shutdown_server_unblock_func, args->server);
   if (!ev.success) {
     rb_raise(grpc_rb_eCallError, "request_call completion failed");
   }
@@ -288,7 +305,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_maybe_shutdown_and_notify(s, deadline);
+  grpc_rb_server_shutdown_and_notify_internal(s, deadline);
 
   return Qnil;
 }

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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grpc
 version: !ruby/object:Gem::Version
-  version: 1.64.0
+  version: 1.65.0.pre1
 platform: x64-mingw-ucrt
 authors:
 - gRPC Authors
 autorequire: 
 bindir: src/ruby/bin
 cert_chain: []
-date: 2024-05-16 00:00:00.000000000 Z
+date: 2024-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -351,7 +351,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
+rubygems_version: 3.5.12
 signing_key: 
 specification_version: 4
 summary: GRPC system in Ruby