grpc 1.73.0-x86_64-darwin → 1.74.0.pre2-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a8dcf7ab517cc78bd45105a29698e7c97439f6065d0d803bbca72446ff2c657
-  data.tar.gz: 602c7000df2a4ecc1e95f2dd6ee6b883eaa8643d95987416b0901aaa57507e6a
+  metadata.gz: 560e82a2f81e0906f78b10d286512307764b23bd350e45ba304fd0ff1f71a7de
+  data.tar.gz: c31d490c9a3ababb70ec232140c92eade4d7be3adb6a98af2da9c1483b94788d
 SHA512:
-  metadata.gz: f5256864f1bda19eaa3be25c81a5c1b1ef6941fb835eccb1f82f97a88379f57ef0b16be8faac90c7b1c1e9c71982fa606a8a46bba66acc5e99786d9ff9c89d97
-  data.tar.gz: 61763dd7482ac4d1e2e40bf225b4766d7dbfb3a024e54c5c04178a8fb4484c08706fec77a37ebba28d1fcbdbca7709fcbab5a3e943ad367f7f3822375a81bdff
+  metadata.gz: 537825f8099968d1e9e74066248c7b2a37236daef02897344f2d358b82cd11c0f71c2ef5b498dc00207af9ec44e6506a5db61042257a9480fda19a231d38b853
+  data.tar.gz: 95c90e115db1c785a5a0f3513d626b5bee90b59fb5485a6535b2bdd1a5f80f500fdf892aaa6a12bf744a847feb56b2524a6637a88698258f8e1e2383b7262173

data/src/ruby/ext/grpc/extconf.rb

@@ -114,6 +114,8 @@ env_append 'CPPFLAGS', '-DGRPC_XDS_USER_AGENT_NAME_SUFFIX="\"RUBY\""'
 require_relative '../../lib/grpc/version'
 env_append 'CPPFLAGS', '-DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"' + GRPC::VERSION + '\""'
 env_append 'CPPFLAGS', '-DGRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK=1'
+env_append 'CPPFLAGS', '-DGRPC_ENABLE_FORK_SUPPORT=1'
+env_append 'CPPFLAGS', '-DGRPC_ENABLE_FORK_SUPPORT_DEFAULT=false'
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])
 grpc_lib_dir = File.join(output_dir, 'libs', grpc_config)

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

@@ -808,12 +808,6 @@ struct call_run_batch_args {
   run_batch_stack* st;
 };
 
-static void cancel_call_unblock_func(void* arg) {
-  grpc_absl_log(GPR_DEBUG, "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;
@@ -836,8 +830,7 @@ 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),
-                                 cancel_call_unblock_func, args->call->wrapped);
+                                 gpr_inf_future(GPR_CLOCK_REALTIME), "call op");
   if (!ev.success) {
     rb_raise(grpc_rb_eCallError, "call#run_batch failed somehow");
   }

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

@@ -59,137 +59,30 @@ static VALUE grpc_rb_cChannel = Qnil;
 /* Used during the conversion of a hash to channel args during channel setup */
 static VALUE grpc_rb_cChannelArgs;
 
-typedef struct bg_watched_channel {
-  grpc_channel* channel;
-  // these fields must only be accessed under global_connection_polling_mu
-  struct bg_watched_channel* next;
-  int channel_destroyed;
-  int refcount;
-} bg_watched_channel;
-
 /* grpc_rb_channel wraps a grpc_channel. */
 typedef struct grpc_rb_channel {
-  VALUE credentials;
-  grpc_channel_args args;
-  /* The actual channel (protected in a wrapper to tell when it's safe to
-   * destroy) */
-  bg_watched_channel* bg_wrapped;
-} grpc_rb_channel;
-
-typedef enum { CONTINUOUS_WATCH, WATCH_STATE_API } watch_state_op_type;
-
-typedef struct watch_state_op {
-  watch_state_op_type op_type;
-  // from event.success
-  union {
-    struct {
-      int success;
-      // has been called back due to a cq next call
-      int called_back;
-    } api_callback_args;
-    struct {
-      bg_watched_channel* bg;
-    } continuous_watch_callback_args;
-  } op;
-} watch_state_op;
-
-static bg_watched_channel* bg_watched_channel_list_head = NULL;
-
-static void grpc_rb_channel_try_register_connection_polling(
-    bg_watched_channel* bg);
-static void* channel_init_try_register_connection_polling_without_gil(
-    void* arg);
-
-typedef struct channel_init_try_register_stack {
   grpc_channel* channel;
-  grpc_rb_channel* wrapper;
-} channel_init_try_register_stack;
-
-static grpc_completion_queue* g_channel_polling_cq;
-static gpr_mu global_connection_polling_mu;
-static gpr_cv global_connection_polling_cv;
-static int g_abort_channel_polling = 0;
-static gpr_once g_once_init = GPR_ONCE_INIT;
-static VALUE g_channel_polling_thread = Qnil;
-
-static int bg_watched_channel_list_lookup(bg_watched_channel* bg);
-static bg_watched_channel* bg_watched_channel_list_create_and_add(
-    grpc_channel* channel);
-static void bg_watched_channel_list_free_and_remove(bg_watched_channel* bg);
-static void run_poll_channels_loop_unblocking_func(void* arg);
-static void* run_poll_channels_loop_unblocking_func_wrapper(void* arg);
-
-// Needs to be called under global_connection_polling_mu
-static void grpc_rb_channel_watch_connection_state_op_complete(
-    watch_state_op* op, int success) {
-  GRPC_RUBY_ASSERT(!op->op.api_callback_args.called_back);
-  op->op.api_callback_args.called_back = 1;
-  op->op.api_callback_args.success = success;
-  // wake up the watch API call that's waiting on this op
-  gpr_cv_broadcast(&global_connection_polling_cv);
-}
-
-/* Avoids destroying a channel twice. */
-static void grpc_rb_channel_safe_destroy(bg_watched_channel* bg) {
-  gpr_mu_lock(&global_connection_polling_mu);
-  GRPC_RUBY_ASSERT(bg_watched_channel_list_lookup(bg));
-  if (!bg->channel_destroyed) {
-    grpc_channel_destroy(bg->channel);
-    bg->channel_destroyed = 1;
-  }
-  bg->refcount--;
-  if (bg->refcount == 0) {
-    bg_watched_channel_list_free_and_remove(bg);
-  }
-  gpr_mu_unlock(&global_connection_polling_mu);
-}
-
-static void* channel_safe_destroy_without_gil(void* arg) {
-  grpc_rb_channel_safe_destroy((bg_watched_channel*)arg);
-  return NULL;
-}
+} grpc_rb_channel;
 
-static void grpc_rb_channel_free_internal(void* p) {
-  grpc_rb_channel* ch = NULL;
+static void grpc_rb_channel_free(void* p) {
   if (p == NULL) {
     return;
   };
-  ch = (grpc_rb_channel*)p;
-  if (ch->bg_wrapped != NULL) {
-    /* assumption made here: it's ok to directly gpr_mu_lock the global
-     * connection polling mutex because we're in a finalizer,
-     * and we can count on this thread to not be interrupted or
-     * yield the gil. */
-    grpc_rb_channel_safe_destroy(ch->bg_wrapped);
-    grpc_rb_channel_args_destroy(&ch->args);
+  grpc_rb_channel* wrapper = (grpc_rb_channel*)p;
+  if (wrapper->channel != NULL) {
+    grpc_channel_destroy(wrapper->channel);
+    wrapper->channel = NULL;
   }
   xfree(p);
 }
 
-/* Destroys Channel instances. */
-static void grpc_rb_channel_free(void* p) { grpc_rb_channel_free_internal(p); }
-
-/* Protects the mark object from GC */
-static void grpc_rb_channel_mark(void* p) {
-  grpc_rb_channel* channel = NULL;
-  if (p == NULL) {
-    return;
-  }
-  channel = (grpc_rb_channel*)p;
-  if (channel->credentials != Qnil) {
-    rb_gc_mark(channel->credentials);
-  }
-}
-
-static rb_data_type_t grpc_channel_data_type = {"grpc_channel",
-                                                {grpc_rb_channel_mark,
-                                                 grpc_rb_channel_free,
-                                                 GRPC_RB_MEMSIZE_UNAVAILABLE,
-                                                 {NULL, NULL}},
-                                                NULL,
-                                                NULL,
+static rb_data_type_t grpc_channel_data_type = {
+    "grpc_channel",
+    {NULL, grpc_rb_channel_free, GRPC_RB_MEMSIZE_UNAVAILABLE, {NULL, NULL}},
+    NULL,
+    NULL,
 #ifdef RUBY_TYPED_FREE_IMMEDIATELY
-                                                RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY
 #endif
 };
 
@@ -197,9 +90,7 @@ static rb_data_type_t grpc_channel_data_type = {"grpc_channel",
 static VALUE grpc_rb_channel_alloc(VALUE cls) {
   grpc_ruby_init();
   grpc_rb_channel* wrapper = ALLOC(grpc_rb_channel);
-  wrapper->bg_wrapped = NULL;
-  wrapper->credentials = Qnil;
-  MEMZERO(&wrapper->args, grpc_channel_args, 1);
+  wrapper->channel = NULL;
   return TypedData_Wrap_Struct(cls, &grpc_channel_data_type, wrapper);
 }
 
@@ -212,53 +103,45 @@ static VALUE grpc_rb_channel_alloc(VALUE cls) {
 
   Creates channel instances. */
 static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
-  VALUE channel_args = Qnil;
-  VALUE credentials = Qnil;
+  VALUE rb_channel_args = Qnil;
+  VALUE rb_credentials = Qnil;
   VALUE target = Qnil;
   grpc_rb_channel* wrapper = NULL;
-  grpc_channel* ch = NULL;
-  grpc_channel_credentials* creds = NULL;
   char* target_chars = NULL;
-  channel_init_try_register_stack stack;
-
   grpc_ruby_fork_guard();
   /* "3" == 3 mandatory args */
-  rb_scan_args(argc, argv, "3", &target, &channel_args, &credentials);
-
+  rb_scan_args(argc, argv, "3", &target, &rb_channel_args, &rb_credentials);
   TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
   target_chars = StringValueCStr(target);
-  grpc_rb_hash_convert_to_channel_args(channel_args, &wrapper->args);
-  if (TYPE(credentials) == T_SYMBOL) {
-    if (id_insecure_channel != SYM2ID(credentials)) {
+  grpc_channel_args channel_args;
+  memset(&channel_args, 0, sizeof(channel_args));
+  grpc_rb_hash_convert_to_channel_args(rb_channel_args, &channel_args);
+  if (TYPE(rb_credentials) == T_SYMBOL) {
+    if (id_insecure_channel != SYM2ID(rb_credentials)) {
       rb_raise(rb_eTypeError,
                "bad creds symbol, want :this_channel_is_insecure");
       return Qnil;
     }
     grpc_channel_credentials* insecure_creds =
         grpc_insecure_credentials_create();
-    ch = grpc_channel_create(target_chars, insecure_creds, &wrapper->args);
+    wrapper->channel =
+        grpc_channel_create(target_chars, insecure_creds, &channel_args);
     grpc_channel_credentials_release(insecure_creds);
   } else {
-    wrapper->credentials = credentials;
-    if (grpc_rb_is_channel_credentials(credentials)) {
-      creds = grpc_rb_get_wrapped_channel_credentials(credentials);
-    } else if (grpc_rb_is_xds_channel_credentials(credentials)) {
-      creds = grpc_rb_get_wrapped_xds_channel_credentials(credentials);
+    grpc_channel_credentials* creds;
+    if (grpc_rb_is_channel_credentials(rb_credentials)) {
+      creds = grpc_rb_get_wrapped_channel_credentials(rb_credentials);
+    } else if (grpc_rb_is_xds_channel_credentials(rb_credentials)) {
+      creds = grpc_rb_get_wrapped_xds_channel_credentials(rb_credentials);
     } else {
       rb_raise(rb_eTypeError,
                "bad creds, want ChannelCredentials or XdsChannelCredentials");
       return Qnil;
     }
-    ch = grpc_channel_create(target_chars, creds, &wrapper->args);
+    wrapper->channel = grpc_channel_create(target_chars, creds, &channel_args);
   }
-
-  GRPC_RUBY_ASSERT(ch);
-  stack.channel = ch;
-  stack.wrapper = wrapper;
-  rb_thread_call_without_gvl(
-      channel_init_try_register_connection_polling_without_gil, &stack, NULL,
-      NULL);
-  if (ch == NULL) {
+  grpc_rb_channel_args_destroy(&channel_args);
+  if (wrapper->channel == NULL) {
     rb_raise(rb_eRuntimeError, "could not create an rpc channel to target:%s",
              target_chars);
     return Qnil;
@@ -268,27 +151,6 @@ static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
   return self;
 }
 
-typedef struct get_state_stack {
-  bg_watched_channel* bg;
-  int try_to_connect;
-  int out;
-} get_state_stack;
-
-static void* get_state_without_gil(void* arg) {
-  get_state_stack* stack = (get_state_stack*)arg;
-
-  gpr_mu_lock(&global_connection_polling_mu);
-  if (stack->bg->channel_destroyed) {
-    stack->out = GRPC_CHANNEL_SHUTDOWN;
-  } else {
-    stack->out = grpc_channel_check_connectivity_state(stack->bg->channel,
-                                                       stack->try_to_connect);
-  }
-  gpr_mu_unlock(&global_connection_polling_mu);
-
-  return NULL;
-}
-
 /*
   call-seq:
     ch.connectivity_state       -> state
@@ -302,68 +164,17 @@ static VALUE grpc_rb_channel_get_connectivity_state(int argc, VALUE* argv,
                                                     VALUE self) {
   VALUE try_to_connect_param = Qfalse;
   grpc_rb_channel* wrapper = NULL;
-  get_state_stack stack;
-
   /* "01" == 0 mandatory args, 1 (try_to_connect) is optional */
   rb_scan_args(argc, argv, "01", &try_to_connect_param);
-
   TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
-  if (wrapper->bg_wrapped == NULL) {
+  if (wrapper->channel == NULL) {
     rb_raise(rb_eRuntimeError, "closed!");
     return Qnil;
   }
-
-  stack.bg = wrapper->bg_wrapped;
-  stack.try_to_connect = RTEST(try_to_connect_param) ? 1 : 0;
-  rb_thread_call_without_gvl(get_state_without_gil, &stack, NULL, NULL);
-
-  return LONG2NUM(stack.out);
-}
-
-typedef struct watch_state_stack {
-  bg_watched_channel* bg_wrapped;
-  gpr_timespec deadline;
-  int last_state;
-} watch_state_stack;
-
-static void* wait_for_watch_state_op_complete_without_gvl(void* arg) {
-  watch_state_stack* stack = (watch_state_stack*)arg;
-  watch_state_op* op = NULL;
-  void* success = (void*)0;
-
-  gpr_mu_lock(&global_connection_polling_mu);
-  // it's unsafe to do a "watch" after "channel polling abort" because the cq
-  // has been shut down.
-  if (g_abort_channel_polling || stack->bg_wrapped->channel_destroyed) {
-    gpr_mu_unlock(&global_connection_polling_mu);
-    return (void*)0;
-  }
-  op = gpr_zalloc(sizeof(watch_state_op));
-  op->op_type = WATCH_STATE_API;
-  grpc_channel_watch_connectivity_state(stack->bg_wrapped->channel,
-                                        stack->last_state, stack->deadline,
-                                        g_channel_polling_cq, op);
-
-  while (!op->op.api_callback_args.called_back) {
-    gpr_cv_wait(&global_connection_polling_cv, &global_connection_polling_mu,
-                gpr_inf_future(GPR_CLOCK_REALTIME));
-  }
-  if (op->op.api_callback_args.success) {
-    success = (void*)1;
-  }
-  gpr_free(op);
-  gpr_mu_unlock(&global_connection_polling_mu);
-
-  return success;
-}
-static void wait_for_watch_state_op_complete_unblocking_func(void* arg) {
-  bg_watched_channel* bg = (bg_watched_channel*)arg;
-  gpr_mu_lock(&global_connection_polling_mu);
-  if (!bg->channel_destroyed) {
-    grpc_channel_destroy(bg->channel);
-    bg->channel_destroyed = 1;
-  }
-  gpr_mu_unlock(&global_connection_polling_mu);
+  bool try_to_connect = RTEST(try_to_connect_param) ? true : false;
+  int state =
+      grpc_channel_check_connectivity_state(wrapper->channel, try_to_connect);
+  return LONG2NUM(state);
 }
 
 /* Wait until the channel's connectivity state becomes different from
@@ -375,79 +186,46 @@ static void wait_for_watch_state_op_complete_unblocking_func(void* arg) {
  * */
 static VALUE grpc_rb_channel_watch_connectivity_state(VALUE self,
                                                       VALUE last_state,
-                                                      VALUE deadline) {
+                                                      VALUE rb_deadline) {
   grpc_rb_channel* wrapper = NULL;
-  watch_state_stack stack;
-  void* op_success = 0;
-
   grpc_ruby_fork_guard();
   TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
-
-  if (wrapper->bg_wrapped == NULL) {
+  if (wrapper->channel == NULL) {
     rb_raise(rb_eRuntimeError, "closed!");
     return Qnil;
   }
-
   if (!FIXNUM_P(last_state)) {
     rb_raise(
         rb_eTypeError,
         "bad type for last_state. want a GRPC::Core::ChannelState constant");
     return Qnil;
   }
-
-  stack.bg_wrapped = wrapper->bg_wrapped;
-  stack.deadline = grpc_rb_time_timeval(deadline, 0),
-  stack.last_state = NUM2LONG(last_state);
-
-  op_success = rb_thread_call_without_gvl(
-      wait_for_watch_state_op_complete_without_gvl, &stack,
-      wait_for_watch_state_op_complete_unblocking_func, wrapper->bg_wrapped);
-
-  return op_success ? Qtrue : Qfalse;
-}
-
-static void grpc_rb_channel_maybe_recreate_channel_after_fork(
-    grpc_rb_channel* wrapper, VALUE target) {
-  // TODO(apolcyn): maybe check if fork support is enabled here.
-  // The only way we can get bg->channel_destroyed without bg itself being
-  // NULL is if we destroyed the channel during GRPC::prefork.
-  bg_watched_channel* bg = wrapper->bg_wrapped;
-  if (bg->channel_destroyed) {
-    // There must be one ref at this point, held by the ruby-level channel
-    // object, drop this one here.
-    GRPC_RUBY_ASSERT(bg->refcount == 1);
-    rb_thread_call_without_gvl(channel_safe_destroy_without_gil, bg, NULL,
-                               NULL);
-    // re-create C-core channel
-    const char* target_str = StringValueCStr(target);
-    grpc_channel* channel;
-    if (wrapper->credentials == Qnil) {
-      grpc_channel_credentials* insecure_creds =
-          grpc_insecure_credentials_create();
-      channel = grpc_channel_create(target_str, insecure_creds, &wrapper->args);
-      grpc_channel_credentials_release(insecure_creds);
-    } else {
-      grpc_channel_credentials* creds;
-      if (grpc_rb_is_channel_credentials(wrapper->credentials)) {
-        creds = grpc_rb_get_wrapped_channel_credentials(wrapper->credentials);
-      } else if (grpc_rb_is_xds_channel_credentials(wrapper->credentials)) {
-        creds =
-            grpc_rb_get_wrapped_xds_channel_credentials(wrapper->credentials);
-      } else {
-        rb_raise(rb_eTypeError,
-                 "failed to re-create channel after fork: bad creds, want "
-                 "ChannelCredentials or XdsChannelCredentials");
-        return;
-      }
-      channel = grpc_channel_create(target_str, creds, &wrapper->args);
-    }
-    // re-register with channel polling thread
-    channel_init_try_register_stack stack;
-    stack.channel = channel;
-    stack.wrapper = wrapper;
-    rb_thread_call_without_gvl(
-        channel_init_try_register_connection_polling_without_gil, &stack, NULL,
-        NULL);
+  const void* tag = &wrapper;
+  gpr_timespec deadline = grpc_rb_time_timeval(rb_deadline, 0);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_pluck(NULL);
+  grpc_channel_watch_connectivity_state(wrapper->channel, NUM2LONG(last_state),
+                                        deadline, cq, tag);
+  grpc_event event =
+      rb_completion_queue_pluck(cq, tag, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                "grpc_channel_watch_connectivity_state");
+  // TODO(apolcyn): this CQ would leak if the thread were killed
+  // while polling queue_pluck, e.g. with Thread#kill. One fix may be
+  // to make this CQ owned by the channel object. Another fix could be to
+  // busy-poll watch_connectivity_state with a short deadline, without
+  // the GIL, rather than just polling CQ pluck, and destroy the CQ
+  // before exitting the no-GIL block.
+  grpc_completion_queue_shutdown(cq);
+  grpc_rb_completion_queue_destroy(cq);
+  if (event.type == GRPC_OP_COMPLETE) {
+    return Qtrue;
+  } else if (event.type == GRPC_QUEUE_TIMEOUT) {
+    return Qfalse;
+  } else {
+    grpc_absl_log_int(
+        GPR_ERROR,
+        "GRPC_RUBY: unexpected grpc_channel_watch_connectivity_state result:",
+        event.type);
+    return Qfalse;
   }
 }
 
@@ -466,7 +244,6 @@ static VALUE grpc_rb_channel_create_call(VALUE self, VALUE parent, VALUE mask,
   grpc_slice host_slice;
   grpc_slice* host_slice_ptr = NULL;
   char* tmp_str = NULL;
-
   grpc_ruby_fork_guard();
   if (host != Qnil) {
     host_slice =
@@ -479,40 +256,29 @@ static VALUE grpc_rb_channel_create_call(VALUE self, VALUE parent, VALUE mask,
   if (parent != Qnil) {
     parent_call = grpc_rb_get_wrapped_call(parent);
   }
-
   TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
-  if (wrapper->bg_wrapped == NULL) {
+  if (wrapper->channel == NULL) {
     rb_raise(rb_eRuntimeError, "closed!");
     return Qnil;
   }
-  // TODO(apolcyn): only do this check if fork support is enabled
-  rb_mutex_lock(rb_ivar_get(self, id_channel_recreation_mu));
-  grpc_rb_channel_maybe_recreate_channel_after_fork(
-      wrapper, rb_ivar_get(self, id_target));
-  rb_mutex_unlock(rb_ivar_get(self, id_channel_recreation_mu));
-
   cq = grpc_completion_queue_create_for_pluck(NULL);
   method_slice =
       grpc_slice_from_copied_buffer(RSTRING_PTR(method), RSTRING_LEN(method));
-  call = grpc_channel_create_call(wrapper->bg_wrapped->channel, parent_call,
-                                  flags, cq, method_slice, host_slice_ptr,
+  call = grpc_channel_create_call(wrapper->channel, parent_call, flags, cq,
+                                  method_slice, host_slice_ptr,
                                   grpc_rb_time_timeval(deadline,
                                                        /* absolute time */ 0),
                                   NULL);
-
   if (call == NULL) {
     tmp_str = grpc_slice_to_c_string(method_slice);
     rb_raise(rb_eRuntimeError, "cannot create call with method %s", tmp_str);
     return Qnil;
   }
-
   grpc_slice_unref(method_slice);
   if (host_slice_ptr != NULL) {
     grpc_slice_unref(host_slice);
   }
-
   res = grpc_rb_wrap_call(call, cq);
-
   /* Make this channel an instance attribute of the call so that it is not GCed
    * before the call. */
   rb_ivar_set(res, id_channel, self);
@@ -524,14 +290,11 @@ static VALUE grpc_rb_channel_create_call(VALUE self, VALUE parent, VALUE mask,
  * this */
 static VALUE grpc_rb_channel_destroy(VALUE self) {
   grpc_rb_channel* wrapper = NULL;
-
   TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
-  if (wrapper->bg_wrapped != NULL) {
-    rb_thread_call_without_gvl(channel_safe_destroy_without_gil,
-                               wrapper->bg_wrapped, NULL, NULL);
-    wrapper->bg_wrapped = NULL;
+  if (wrapper->channel != NULL) {
+    grpc_channel_destroy(wrapper->channel);
+    wrapper->channel = NULL;
   }
-
   return Qnil;
 }
 
@@ -540,271 +303,13 @@ static VALUE grpc_rb_channel_get_target(VALUE self) {
   grpc_rb_channel* wrapper = NULL;
   VALUE res = Qnil;
   char* target = NULL;
-
   TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
-  target = grpc_channel_get_target(wrapper->bg_wrapped->channel);
+  target = grpc_channel_get_target(wrapper->channel);
   res = rb_str_new2(target);
   gpr_free(target);
-
   return res;
 }
 
-/* Needs to be called under global_connection_polling_mu */
-static int bg_watched_channel_list_lookup(bg_watched_channel* target) {
-  bg_watched_channel* cur = bg_watched_channel_list_head;
-
-  while (cur != NULL) {
-    if (cur == target) {
-      return 1;
-    }
-    cur = cur->next;
-  }
-
-  return 0;
-}
-
-/* Needs to be called under global_connection_polling_mu */
-static bg_watched_channel* bg_watched_channel_list_create_and_add(
-    grpc_channel* channel) {
-  bg_watched_channel* watched = gpr_zalloc(sizeof(bg_watched_channel));
-
-  watched->channel = channel;
-  watched->next = bg_watched_channel_list_head;
-  watched->refcount = 1;
-  bg_watched_channel_list_head = watched;
-  return watched;
-}
-
-/* Needs to be called under global_connection_polling_mu */
-static void bg_watched_channel_list_free_and_remove(
-    bg_watched_channel* target) {
-  bg_watched_channel* bg = NULL;
-
-  GRPC_RUBY_ASSERT(bg_watched_channel_list_lookup(target));
-  GRPC_RUBY_ASSERT(target->channel_destroyed && target->refcount == 0);
-  if (bg_watched_channel_list_head == target) {
-    bg_watched_channel_list_head = target->next;
-    gpr_free(target);
-    return;
-  }
-  bg = bg_watched_channel_list_head;
-  while (bg != NULL && bg->next != NULL) {
-    if (bg->next == target) {
-      bg->next = bg->next->next;
-      gpr_free(target);
-      return;
-    }
-    bg = bg->next;
-  }
-  GRPC_RUBY_ASSERT(0);
-}
-
-/* Initialize a grpc_rb_channel's "protected grpc_channel" and try to push
- * it onto the background thread for constant watches. */
-static void* channel_init_try_register_connection_polling_without_gil(
-    void* arg) {
-  channel_init_try_register_stack* stack =
-      (channel_init_try_register_stack*)arg;
-
-  gpr_mu_lock(&global_connection_polling_mu);
-  stack->wrapper->bg_wrapped =
-      bg_watched_channel_list_create_and_add(stack->channel);
-  grpc_rb_channel_try_register_connection_polling(stack->wrapper->bg_wrapped);
-  gpr_mu_unlock(&global_connection_polling_mu);
-  return NULL;
-}
-
-// Needs to be called under global_connection_poolling_mu
-static void grpc_rb_channel_try_register_connection_polling(
-    bg_watched_channel* bg) {
-  grpc_connectivity_state conn_state;
-  watch_state_op* op = NULL;
-  if (bg->refcount == 0) {
-    GRPC_RUBY_ASSERT(bg->channel_destroyed);
-    bg_watched_channel_list_free_and_remove(bg);
-    return;
-  }
-  GRPC_RUBY_ASSERT(bg->refcount == 1);
-  if (bg->channel_destroyed || g_abort_channel_polling) {
-    return;
-  }
-  conn_state = grpc_channel_check_connectivity_state(bg->channel, 0);
-  if (conn_state == GRPC_CHANNEL_SHUTDOWN) {
-    return;
-  }
-  GRPC_RUBY_ASSERT(bg_watched_channel_list_lookup(bg));
-  // prevent bg from being free'd by GC while background thread is watching it
-  bg->refcount++;
-  op = gpr_zalloc(sizeof(watch_state_op));
-  op->op_type = CONTINUOUS_WATCH;
-  op->op.continuous_watch_callback_args.bg = bg;
-  grpc_channel_watch_connectivity_state(bg->channel, conn_state,
-                                        gpr_inf_future(GPR_CLOCK_REALTIME),
-                                        g_channel_polling_cq, op);
-}
-
-// Note this loop breaks out with a single call of
-// "run_poll_channels_loop_no_gil".
-// This assumes that a ruby call the unblocking func
-// indicates process shutdown.
-// In the worst case, this stops polling channel connectivity
-// early and falls back to current behavior.
-static void* run_poll_channels_loop_no_gil(void* arg) {
-  grpc_event event;
-  watch_state_op* op = NULL;
-  bg_watched_channel* bg = NULL;
-  (void)arg;
-  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);
-  gpr_mu_unlock(&global_connection_polling_mu);
-
-  for (;;) {
-    event = grpc_completion_queue_next(
-        g_channel_polling_cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
-    if (event.type == GRPC_QUEUE_SHUTDOWN) {
-      break;
-    }
-    gpr_mu_lock(&global_connection_polling_mu);
-    if (event.type == GRPC_OP_COMPLETE) {
-      op = (watch_state_op*)event.tag;
-      if (op->op_type == CONTINUOUS_WATCH) {
-        bg = (bg_watched_channel*)op->op.continuous_watch_callback_args.bg;
-        bg->refcount--;
-        grpc_rb_channel_try_register_connection_polling(bg);
-        gpr_free(op);
-      } else if (op->op_type == WATCH_STATE_API) {
-        grpc_rb_channel_watch_connection_state_op_complete(
-            (watch_state_op*)event.tag, event.success);
-      } else {
-        GRPC_RUBY_ASSERT(0);
-      }
-    }
-    gpr_mu_unlock(&global_connection_polling_mu);
-  }
-  grpc_completion_queue_destroy(g_channel_polling_cq);
-  grpc_absl_log(
-      GPR_DEBUG,
-      "GRPC_RUBY: run_poll_channels_loop_no_gil - exit connection polling "
-      "loop");
-  return NULL;
-}
-
-static void run_poll_channels_loop_unblocking_func(void* arg) {
-  run_poll_channels_loop_unblocking_func_wrapper(arg);
-}
-
-// Notify the channel polling loop to cleanup and shutdown.
-static void* run_poll_channels_loop_unblocking_func_wrapper(void* arg) {
-  bg_watched_channel* bg = NULL;
-  (void)arg;
-
-  gpr_mu_lock(&global_connection_polling_mu);
-  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);
-    return NULL;
-  }
-  g_abort_channel_polling = 1;
-
-  // force pending watches to end by switching to shutdown state
-  bg = bg_watched_channel_list_head;
-  while (bg != NULL) {
-    if (!bg->channel_destroyed) {
-      grpc_channel_destroy(bg->channel);
-      bg->channel_destroyed = 1;
-    }
-    bg = bg->next;
-  }
-
-  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);
-  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;
-  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,
-                             run_poll_channels_loop_unblocking_func, NULL);
-  return Qnil;
-}
-
-static void* set_abort_channel_polling_without_gil(void* arg) {
-  (void)arg;
-  gpr_mu_lock(&global_connection_polling_mu);
-  g_abort_channel_polling = 1;
-  gpr_cv_broadcast(&global_connection_polling_cv);
-  gpr_mu_unlock(&global_connection_polling_mu);
-  return NULL;
-}
-
-static void do_basic_init() {
-  gpr_mu_init(&global_connection_polling_mu);
-  gpr_cv_init(&global_connection_polling_cv);
-}
-
-/* Temporary fix for
- * https://github.com/GoogleCloudPlatform/google-cloud-ruby/issues/899.
- * Transports in idle channels can get destroyed. Normally c-core re-connects,
- * but in grpc-ruby core never gets a thread until an RPC is made, because ruby
- * only calls c-core's "completion_queu_pluck" API.
- * This uses a global background thread that calls
- * "completion_queue_next" on registered "watch_channel_connectivity_state"
- * calls - so that c-core can reconnect if needed, when there aren't any RPC's.
- * TODO(apolcyn) remove this when core handles new RPCs on dead connections.
- */
-void grpc_rb_channel_polling_thread_start() {
-  gpr_once_init(&g_once_init, do_basic_init);
-  GRPC_RUBY_ASSERT(!RTEST(g_channel_polling_thread));
-  GRPC_RUBY_ASSERT(!g_abort_channel_polling);
-  GRPC_RUBY_ASSERT(g_channel_polling_cq == NULL);
-
-  g_channel_polling_cq = grpc_completion_queue_create_for_next(NULL);
-  g_channel_polling_thread = rb_thread_create(run_poll_channels_loop, NULL);
-
-  if (!RTEST(g_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;
-  }
-}
-
-void grpc_rb_channel_polling_thread_stop() {
-  if (!RTEST(g_channel_polling_thread)) {
-    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,
-                             NULL, NULL, NULL);
-  rb_funcall(g_channel_polling_thread, rb_intern("join"), 0);
-  // state associated with the channel polling thread is destroyed, reset so
-  // we can start again later
-  g_channel_polling_thread = Qnil;
-  g_abort_channel_polling = false;
-  g_channel_polling_cq = NULL;
-}
-
 static void Init_grpc_propagate_masks() {
   /* Constants representing call propagation masks in grpc.h */
   VALUE grpc_rb_mPropagateMasks =
@@ -838,7 +343,6 @@ static void Init_grpc_connectivity_states() {
 }
 
 void Init_grpc_channel() {
-  rb_global_variable(&g_channel_polling_thread);
   grpc_rb_cChannelArgs = rb_define_class("TmpChannelArgs", rb_cObject);
   rb_undef_alloc_func(grpc_rb_cChannelArgs);
   grpc_rb_cChannel =
@@ -883,5 +387,5 @@ void Init_grpc_channel() {
 grpc_channel* grpc_rb_get_wrapped_channel(VALUE v) {
   grpc_rb_channel* wrapper = NULL;
   TypedData_Get_Struct(v, grpc_rb_channel, &grpc_channel_data_type, wrapper);
-  return wrapper->bg_wrapped->channel;
+  return wrapper->channel;
 }

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.73.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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grpc
 version: !ruby/object:Gem::Version
-  version: 1.73.0
+  version: 1.74.0.pre2
 platform: x86_64-darwin
 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.bundle
 - src/ruby/lib/grpc/3.1/grpc_c.bundle
 - src/ruby/lib/grpc/3.2/grpc_c.bundle
 - src/ruby/lib/grpc/3.3/grpc_c.bundle
@@ -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.9
+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