grpc 1.56.0-x64-mingw-ucrt → 1.57.0.pre1-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81c18bc3bcc2371e53c4807e7f9a1d1b3120549b92b64c845e93945f59074d33
-  data.tar.gz: 332167cae5b25a2b61ecd47d384cd87bd8dbed5f5461bd76a81b47de02a2e6d0
+  metadata.gz: 06d05082f7703eaf0c1224ddb25bd268487d21ab6fe351926588a309af16fd5e
+  data.tar.gz: bad9963c14d6392fae626d32c8e4e942559f5825dffca645c685ff2085c1cb05
 SHA512:
-  metadata.gz: 2926cdeb56ff1c02fb82ac7c353c49197ac9c4798d207868dc153d118b6255fdc9a51674be71170f980fe4306c0b8a3ff84c84d3e4e86476e892a91f6b28409c
-  data.tar.gz: 1fed343894921e21d934a1a866f316035713138ed5f4580a12d8a1c80122abaddb75a0f5f23c40bc4e03a48dfeff3a3c9559c8ccbbfb16c0cc9b554025defea7
+  metadata.gz: 615eec2241771c4933ad8f3acba23c1f541b014fae98438ab0154d1a5b4b828aaa7a080de71b89a00dc36e45c5da83eaad0847dd48adf2fd237d725e5ad97f22
+  data.tar.gz: 1f0c8681a8ac685283546f5cb1698bff3d0c00dc96b1312ac42aa106b8943d3d32ad9bdb8bb3500baa8345fb02925b95b6e0750db7f4a65831ced9ff91e092ae

data/src/ruby/bin/math_pb.rb

@@ -1,28 +1,34 @@
+# frozen_string_literal: true
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: math.proto
 
 require 'google/protobuf'
 
-Google::Protobuf::DescriptorPool.generated_pool.build do
-  add_file("math.proto", :syntax => :proto3) do
-    add_message "math.DivArgs" do
-      optional :dividend, :int64, 1
-      optional :divisor, :int64, 2
-    end
-    add_message "math.DivReply" do
-      optional :quotient, :int64, 1
-      optional :remainder, :int64, 2
-    end
-    add_message "math.FibArgs" do
-      optional :limit, :int64, 1
-    end
-    add_message "math.Num" do
-      optional :num, :int64, 1
-    end
-    add_message "math.FibReply" do
-      optional :count, :int64, 1
+
+descriptor_data = "\n\nmath.proto\x12\x04math\",\n\x07\x44ivArgs\x12\x10\n\x08\x64ividend\x18\x01 \x01(\x03\x12\x0f\n\x07\x64ivisor\x18\x02 \x01(\x03\"/\n\x08\x44ivReply\x12\x10\n\x08quotient\x18\x01 \x01(\x03\x12\x11\n\tremainder\x18\x02 \x01(\x03\"\x18\n\x07\x46ibArgs\x12\r\n\x05limit\x18\x01 \x01(\x03\"\x12\n\x03Num\x12\x0b\n\x03num\x18\x01 \x01(\x03\"\x19\n\x08\x46ibReply\x12\r\n\x05\x63ount\x18\x01 \x01(\x03\x32\xa4\x01\n\x04Math\x12&\n\x03\x44iv\x12\r.math.DivArgs\x1a\x0e.math.DivReply\"\x00\x12.\n\x07\x44ivMany\x12\r.math.DivArgs\x1a\x0e.math.DivReply\"\x00(\x01\x30\x01\x12#\n\x03\x46ib\x12\r.math.FibArgs\x1a\t.math.Num\"\x00\x30\x01\x12\x1f\n\x03Sum\x12\t.math.Num\x1a\t.math.Num\"\x00(\x01\x62\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+
+begin
+  pool.add_serialized_file(descriptor_data)
+rescue TypeError => e
+  # Compatibility code: will be removed in the next major version.
+  require 'google/protobuf/descriptor_pb'
+  parsed = Google::Protobuf::FileDescriptorProto.decode(descriptor_data)
+  parsed.clear_dependency
+  serialized = parsed.class.encode(parsed)
+  file = pool.add_serialized_file(serialized)
+  warn "Warning: Protobuf detected an import path issue while loading generated file #{__FILE__}"
+  imports = [
+  ]
+  imports.each do |type_name, expected_filename|
+    import_file = pool.lookup(type_name).file_descriptor
+    if import_file.name != expected_filename
+      warn "- #{file.name} imports #{expected_filename}, but that import was loaded as #{import_file.name}"
     end
   end
+  warn "Each proto file must use a consistent fully-qualified name."
+  warn "This will become an error in the next major version."
 end
 
 module Math

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

@@ -88,11 +88,15 @@ 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'
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])
 grpc_lib_dir = File.join(output_dir, 'libs', grpc_config)
 ENV['BUILDDIR'] = output_dir
 
+strip_tool = RbConfig::CONFIG['STRIP']
+strip_tool += ' -x' if apple_toolchain
+
 unless windows
   puts 'Building internal gRPC into ' + grpc_lib_dir
   nproc = 4
@@ -107,6 +111,17 @@ unless windows
   puts "Building grpc native library: #{cmd}"
   system(cmd)
   exit 1 unless $? == 0
+
+  if grpc_config == 'opt'
+    rm_obj_cmd = "rm -rf #{File.join(output_dir, 'objs')}"
+    puts "Removing grpc object files: #{rm_obj_cmd}"
+    system(rm_obj_cmd)
+    exit 1 unless $? == 0
+    strip_cmd = "#{strip_tool} #{grpc_lib_dir}/*.a"
+    puts "Stripping grpc native library: #{strip_cmd}"
+    system(strip_cmd)
+    exit 1 unless $? == 0
+  end
 end
 
 $CFLAGS << ' -DGRPC_RUBY_WINDOWS_UCRT' if windows_ucrt
@@ -141,7 +156,10 @@ end
 
 ext_export_file = File.join(grpc_root, 'src', 'ruby', 'ext', 'grpc', ext_export_filename())
 $LDFLAGS << ' -Wl,--version-script="' + ext_export_file + '.gcc"' if linux
-$LDFLAGS << ' -Wl,-exported_symbols_list,"' + ext_export_file + '.clang"' if apple_toolchain
+if apple_toolchain
+  $LDFLAGS << ' -weak_framework CoreFoundation' if RUBY_PLATFORM =~ /arm64/
+  $LDFLAGS << ' -Wl,-exported_symbols_list,"' + ext_export_file + '.clang"'
+end
 
 $LDFLAGS << ' ' + File.join(grpc_lib_dir, 'libgrpc.a') unless windows
 if grpc_config == 'gcov'
@@ -169,23 +187,6 @@ output = File.join('grpc', 'grpc_c')
 puts 'Generating Makefile for ' + output
 create_makefile(output)
 
-strip_tool = RbConfig::CONFIG['STRIP']
-strip_tool += ' -x' if apple_toolchain
-
-if grpc_config == 'opt'
-  File.open('Makefile.new', 'w') do |o|
-    o.puts 'hijack: all strip'
-    o.puts
-    File.foreach('Makefile') do |i|
-      o.puts i
-    end
-    o.puts
-    o.puts 'strip: $(DLLIB)'
-    o.puts "\t$(ECHO) Stripping $(DLLIB)"
-    o.puts "\t$(Q) #{strip_tool} $(DLLIB)"
-  end
-  File.rename('Makefile.new', 'Makefile')
-end
 if ENV['GRPC_RUBY_TEST_ONLY_WORKAROUND_MAKE_INSTALL_BUG']
   # Note: this env var setting is intended to work around a problem observed
   # with the ginstall command on grpc's macos automated test infrastructure,

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

@@ -801,6 +801,56 @@ static VALUE grpc_run_batch_stack_build_result(run_batch_stack* st) {
   return result;
 }
 
+struct call_run_batch_args {
+  grpc_rb_call* call;
+  unsigned write_flag;
+  VALUE ops_hash;
+  run_batch_stack* st;
+};
+
+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;
+  void* tag = (void*)&args->st;
+
+  grpc_event ev;
+  grpc_call_error err;
+
+  args->st = gpr_malloc(sizeof(run_batch_stack));
+  grpc_run_batch_stack_init(args->st, args->write_flag);
+  grpc_run_batch_stack_fill_ops(args->st, args->ops_hash);
+
+  /* call grpc_call_start_batch, then wait for it to complete using
+   * pluck_event */
+  err = grpc_call_start_batch(args->call->wrapped, args->st->ops,
+                              args->st->op_num, tag, NULL);
+  if (err != GRPC_CALL_OK) {
+    rb_raise(grpc_rb_eCallError,
+             "grpc_call_start_batch failed with %s (code=%d)",
+             grpc_call_error_detail_of(err), err);
+  }
+  ev = rb_completion_queue_pluck(args->call->queue, tag,
+                                 gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  if (!ev.success) {
+    rb_raise(grpc_rb_eCallError, "call#run_batch failed somehow");
+  }
+  /* Build and return the BatchResult struct result,
+     if there is an error, it's reflected in the status */
+  return grpc_run_batch_stack_build_result(args->st);
+}
+
+static VALUE grpc_rb_call_run_batch_ensure(VALUE value_args) {
+  grpc_rb_fork_unsafe_end();
+  struct call_run_batch_args* args = (struct call_run_batch_args*)value_args;
+
+  if (args->st) {
+    grpc_run_batch_stack_cleanup(args->st);
+    gpr_free(args->st);
+  }
+
+  return Qnil;
+}
+
 /* call-seq:
    ops = {
      GRPC::Core::CallOps::SEND_INITIAL_METADATA => <op_value>,
@@ -819,56 +869,29 @@ static VALUE grpc_run_batch_stack_build_result(run_batch_stack* st) {
    Only one operation of each type can be active at once in any given
    batch */
 static VALUE grpc_rb_call_run_batch(VALUE self, VALUE ops_hash) {
-  run_batch_stack* st = NULL;
-  grpc_rb_call* call = NULL;
-  grpc_event ev;
-  grpc_call_error err;
-  VALUE result = Qnil;
-  VALUE rb_write_flag = rb_ivar_get(self, id_write_flag);
-  unsigned write_flag = 0;
-  void* tag = (void*)&st;
-
   grpc_ruby_fork_guard();
   if (RTYPEDDATA_DATA(self) == NULL) {
     rb_raise(grpc_rb_eCallError, "Cannot run batch on closed call");
-    return Qnil;
   }
+
+  grpc_rb_call* call = NULL;
   TypedData_Get_Struct(self, grpc_rb_call, &grpc_call_data_type, call);
 
   /* Validate the ops args, adding them to a ruby array */
   if (TYPE(ops_hash) != T_HASH) {
     rb_raise(rb_eTypeError, "call#run_batch: ops hash should be a hash");
-    return Qnil;
   }
-  if (rb_write_flag != Qnil) {
-    write_flag = NUM2UINT(rb_write_flag);
-  }
-  st = gpr_malloc(sizeof(run_batch_stack));
-  grpc_run_batch_stack_init(st, write_flag);
-  grpc_run_batch_stack_fill_ops(st, ops_hash);
 
-  /* call grpc_call_start_batch, then wait for it to complete using
-   * pluck_event */
-  err = grpc_call_start_batch(call->wrapped, st->ops, st->op_num, tag, NULL);
-  if (err != GRPC_CALL_OK) {
-    grpc_run_batch_stack_cleanup(st);
-    gpr_free(st);
-    rb_raise(grpc_rb_eCallError,
-             "grpc_call_start_batch failed with %s (code=%d)",
-             grpc_call_error_detail_of(err), err);
-    return Qnil;
-  }
-  ev = rb_completion_queue_pluck(call->queue, tag,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
-  if (!ev.success) {
-    rb_raise(grpc_rb_eCallError, "call#run_batch failed somehow");
-  }
-  /* Build and return the BatchResult struct result,
-     if there is an error, it's reflected in the status */
-  result = grpc_run_batch_stack_build_result(st);
-  grpc_run_batch_stack_cleanup(st);
-  gpr_free(st);
-  return result;
+  VALUE rb_write_flag = rb_ivar_get(self, id_write_flag);
+
+  struct call_run_batch_args args = {
+      .call = call,
+      .write_flag = rb_write_flag == Qnil ? 0 : NUM2UINT(rb_write_flag),
+      .ops_hash = ops_hash,
+      .st = NULL};
+
+  return rb_ensure(grpc_rb_call_run_batch_try, (VALUE)&args,
+                   grpc_rb_call_run_batch_ensure, (VALUE)&args);
 }
 
 static void Init_grpc_write_flags() {

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

@@ -193,7 +193,6 @@ static void grpc_rb_call_credentials_free_internal(void* p) {
 /* Destroys the credentials instances. */
 static void grpc_rb_call_credentials_free(void* p) {
   grpc_rb_call_credentials_free_internal(p);
-  grpc_ruby_shutdown();
 }
 
 /* Protects the mark object from GC */

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

@@ -47,6 +47,9 @@ static ID id_channel;
  * GCed before the channel */
 static ID id_target;
 
+/* hidden ivar that synchronizes post-fork channel re-creation */
+static ID id_channel_recreation_mu;
+
 /* id_insecure_channel is used to indicate that a channel is insecure */
 static VALUE id_insecure_channel;
 
@@ -67,7 +70,7 @@ typedef struct 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;
@@ -104,11 +107,13 @@ typedef struct channel_init_try_register_stack {
   grpc_rb_channel* wrapper;
 } channel_init_try_register_stack;
 
-static grpc_completion_queue* channel_polling_cq;
+static grpc_completion_queue* g_channel_polling_cq;
 static gpr_mu global_connection_polling_mu;
 static gpr_cv global_connection_polling_cv;
-static int abort_channel_polling = 0;
-static int channel_polling_thread_started = 0;
+static int g_abort_channel_polling = 0;
+static int g_channel_polling_thread_started = 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(
@@ -158,16 +163,13 @@ static void grpc_rb_channel_free_internal(void* p) {
      * and we can count on this thread to not be interrupted or
      * yield the gil. */
     grpc_rb_channel_safe_destroy(ch->bg_wrapped);
-    ch->bg_wrapped = NULL;
+    grpc_rb_channel_args_destroy(&ch->args);
   }
   xfree(p);
 }
 
 /* Destroys Channel instances. */
-static void grpc_rb_channel_free(void* p) {
-  grpc_rb_channel_free_internal(p);
-  grpc_ruby_shutdown();
-}
+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) {
@@ -199,6 +201,7 @@ static VALUE grpc_rb_channel_alloc(VALUE cls) {
   grpc_rb_channel* wrapper = ALLOC(grpc_rb_channel);
   wrapper->bg_wrapped = NULL;
   wrapper->credentials = Qnil;
+  MEMZERO(&wrapper->args, grpc_channel_args, 1);
   return TypedData_Wrap_Struct(cls, &grpc_channel_data_type, wrapper);
 }
 
@@ -218,24 +221,21 @@ static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
   grpc_channel* ch = NULL;
   grpc_channel_credentials* creds = NULL;
   char* target_chars = NULL;
-  grpc_channel_args args;
   channel_init_try_register_stack stack;
-  int stop_waiting_for_thread_start = 0;
-  MEMZERO(&args, grpc_channel_args, 1);
 
   grpc_ruby_fork_guard();
+  int stop_waiting_for_thread_start = 0;
   rb_thread_call_without_gvl(
       wait_until_channel_polling_thread_started_no_gil,
       &stop_waiting_for_thread_start,
       wait_until_channel_polling_thread_started_unblocking_func,
       &stop_waiting_for_thread_start);
-
   /* "3" == 3 mandatory args */
   rb_scan_args(argc, argv, "3", &target, &channel_args, &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, &args);
+  grpc_rb_hash_convert_to_channel_args(channel_args, &wrapper->args);
   if (TYPE(credentials) == T_SYMBOL) {
     if (id_insecure_channel != SYM2ID(credentials)) {
       rb_raise(rb_eTypeError,
@@ -244,7 +244,7 @@ static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
     }
     grpc_channel_credentials* insecure_creds =
         grpc_insecure_credentials_create();
-    ch = grpc_channel_create(target_chars, insecure_creds, &args);
+    ch = grpc_channel_create(target_chars, insecure_creds, &wrapper->args);
     grpc_channel_credentials_release(insecure_creds);
   } else {
     wrapper->credentials = credentials;
@@ -257,7 +257,7 @@ static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
                "bad creds, want ChannelCredentials or XdsChannelCredentials");
       return Qnil;
     }
-    ch = grpc_channel_create(target_chars, creds, &args);
+    ch = grpc_channel_create(target_chars, creds, &wrapper->args);
   }
 
   GPR_ASSERT(ch);
@@ -266,16 +266,13 @@ static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
   rb_thread_call_without_gvl(
       channel_init_try_register_connection_polling_without_gil, &stack, NULL,
       NULL);
-
-  if (args.args != NULL) {
-    xfree(args.args); /* Allocated by grpc_rb_hash_convert_to_channel_args */
-  }
   if (ch == NULL) {
     rb_raise(rb_eRuntimeError, "could not create an rpc channel to target:%s",
              target_chars);
     return Qnil;
   }
   rb_ivar_set(self, id_target, target);
+  rb_ivar_set(self, id_channel_recreation_mu, rb_mutex_new());
   return self;
 }
 
@@ -289,7 +286,7 @@ static void* get_state_without_gil(void* arg) {
   get_state_stack* stack = (get_state_stack*)arg;
 
   gpr_mu_lock(&global_connection_polling_mu);
-  GPR_ASSERT(abort_channel_polling || channel_polling_thread_started);
+  GPR_ASSERT(g_abort_channel_polling || g_channel_polling_thread_started);
   if (stack->bg->channel_destroyed) {
     stack->out = GRPC_CHANNEL_SHUTDOWN;
   } else {
@@ -346,7 +343,7 @@ static void* wait_for_watch_state_op_complete_without_gvl(void* arg) {
   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 (abort_channel_polling || stack->bg_wrapped->channel_destroyed) {
+  if (g_abort_channel_polling || stack->bg_wrapped->channel_destroyed) {
     gpr_mu_unlock(&global_connection_polling_mu);
     return (void*)0;
   }
@@ -354,7 +351,7 @@ static void* wait_for_watch_state_op_complete_without_gvl(void* arg) {
   op->op_type = WATCH_STATE_API;
   grpc_channel_watch_connectivity_state(stack->bg_wrapped->channel,
                                         stack->last_state, stack->deadline,
-                                        channel_polling_cq, op);
+                                        g_channel_polling_cq, op);
 
   while (!op->op.api_callback_args.called_back) {
     gpr_cv_wait(&global_connection_polling_cv, &global_connection_polling_mu,
@@ -418,6 +415,58 @@ static VALUE grpc_rb_channel_watch_connectivity_state(VALUE self,
   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.
+    GPR_ASSERT(bg->refcount == 1);
+    // Wait for channel polling thread to re-initialize
+    int stop_waiting_for_thread_start = 0;
+    rb_thread_call_without_gvl(
+        wait_until_channel_polling_thread_started_no_gil,
+        &stop_waiting_for_thread_start,
+        wait_until_channel_polling_thread_started_unblocking_func,
+        &stop_waiting_for_thread_start);
+    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);
+  }
+}
+
 /* Create a call given a grpc_channel, in order to call method. The request
    is not sent until grpc_call_invoke is called. */
 static VALUE grpc_rb_channel_create_call(VALUE self, VALUE parent, VALUE mask,
@@ -452,6 +501,11 @@ static VALUE grpc_rb_channel_create_call(VALUE self, VALUE parent, VALUE mask,
     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 =
@@ -582,7 +636,7 @@ static void grpc_rb_channel_try_register_connection_polling(
   grpc_connectivity_state conn_state;
   watch_state_op* op = NULL;
 
-  GPR_ASSERT(channel_polling_thread_started || abort_channel_polling);
+  GPR_ASSERT(g_channel_polling_thread_started || g_abort_channel_polling);
 
   if (bg->refcount == 0) {
     GPR_ASSERT(bg->channel_destroyed);
@@ -590,7 +644,7 @@ static void grpc_rb_channel_try_register_connection_polling(
     return;
   }
   GPR_ASSERT(bg->refcount == 1);
-  if (bg->channel_destroyed || abort_channel_polling) {
+  if (bg->channel_destroyed || g_abort_channel_polling) {
     return;
   }
 
@@ -607,7 +661,7 @@ static void grpc_rb_channel_try_register_connection_polling(
   op->op.continuous_watch_callback_args.bg = bg;
   grpc_channel_watch_connectivity_state(bg->channel, conn_state,
                                         gpr_inf_future(GPR_CLOCK_REALTIME),
-                                        channel_polling_cq, op);
+                                        g_channel_polling_cq, op);
 }
 
 // Note this loop breaks out with a single call of
@@ -624,14 +678,15 @@ static void* run_poll_channels_loop_no_gil(void* arg) {
   gpr_log(GPR_DEBUG, "GRPC_RUBY: run_poll_channels_loop_no_gil - begin");
 
   gpr_mu_lock(&global_connection_polling_mu);
-  GPR_ASSERT(!channel_polling_thread_started);
-  channel_polling_thread_started = 1;
+  GPR_ASSERT(!g_abort_channel_polling);
+  GPR_ASSERT(!g_channel_polling_thread_started);
+  g_channel_polling_thread_started = 1;
   gpr_cv_broadcast(&global_connection_polling_cv);
   gpr_mu_unlock(&global_connection_polling_mu);
 
   for (;;) {
     event = grpc_completion_queue_next(
-        channel_polling_cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+        g_channel_polling_cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
     if (event.type == GRPC_QUEUE_SHUTDOWN) {
       break;
     }
@@ -652,7 +707,7 @@ static void* run_poll_channels_loop_no_gil(void* arg) {
     }
     gpr_mu_unlock(&global_connection_polling_mu);
   }
-  grpc_completion_queue_destroy(channel_polling_cq);
+  grpc_completion_queue_destroy(g_channel_polling_cq);
   gpr_log(GPR_DEBUG,
           "GRPC_RUBY: run_poll_channels_loop_no_gil - exit connection polling "
           "loop");
@@ -669,11 +724,11 @@ static void run_poll_channels_loop_unblocking_func(void* arg) {
           "GRPC_RUBY: run_poll_channels_loop_unblocking_func - begin aborting "
           "connection polling");
   // early out after first time through
-  if (abort_channel_polling) {
+  if (g_abort_channel_polling) {
     gpr_mu_unlock(&global_connection_polling_mu);
     return;
   }
-  abort_channel_polling = 1;
+  g_abort_channel_polling = 1;
 
   // force pending watches to end by switching to shutdown state
   bg = bg_watched_channel_list_head;
@@ -685,7 +740,9 @@ static void run_poll_channels_loop_unblocking_func(void* arg) {
     bg = bg->next;
   }
 
-  grpc_completion_queue_shutdown(channel_polling_cq);
+  gpr_log(GPR_DEBUG, "GRPC_RUBY: cq shutdown on global polling cq. pid: %d",
+          getpid());
+  grpc_completion_queue_shutdown(g_channel_polling_cq);
   gpr_cv_broadcast(&global_connection_polling_cv);
   gpr_mu_unlock(&global_connection_polling_mu);
   gpr_log(GPR_DEBUG,
@@ -699,10 +756,8 @@ static VALUE run_poll_channels_loop(VALUE arg) {
   gpr_log(
       GPR_DEBUG,
       "GRPC_RUBY: run_poll_channels_loop - create connection polling thread");
-  grpc_ruby_init();
   rb_thread_call_without_gvl(run_poll_channels_loop_no_gil, NULL,
                              run_poll_channels_loop_unblocking_func, NULL);
-  grpc_ruby_shutdown();
   return Qnil;
 }
 
@@ -710,7 +765,7 @@ static void* wait_until_channel_polling_thread_started_no_gil(void* arg) {
   int* stop_waiting = (int*)arg;
   gpr_log(GPR_DEBUG, "GRPC_RUBY: wait for channel polling thread to start");
   gpr_mu_lock(&global_connection_polling_mu);
-  while (!channel_polling_thread_started && !abort_channel_polling &&
+  while (!g_channel_polling_thread_started && !g_abort_channel_polling &&
          !*stop_waiting) {
     gpr_cv_wait(&global_connection_polling_cv, &global_connection_polling_mu,
                 gpr_inf_future(GPR_CLOCK_REALTIME));
@@ -734,12 +789,17 @@ static void wait_until_channel_polling_thread_started_unblocking_func(
 static void* set_abort_channel_polling_without_gil(void* arg) {
   (void)arg;
   gpr_mu_lock(&global_connection_polling_mu);
-  abort_channel_polling = 1;
+  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,
@@ -751,23 +811,38 @@ static void* set_abort_channel_polling_without_gil(void* arg) {
  * TODO(apolcyn) remove this when core handles new RPCs on dead connections.
  */
 void grpc_rb_channel_polling_thread_start() {
-  VALUE background_thread = Qnil;
+  gpr_once_init(&g_once_init, do_basic_init);
+  GPR_ASSERT(!RTEST(g_channel_polling_thread));
+  GPR_ASSERT(!g_abort_channel_polling);
+  GPR_ASSERT(!g_channel_polling_thread_started);
+  GPR_ASSERT(g_channel_polling_cq == NULL);
 
-  GPR_ASSERT(!abort_channel_polling);
-  GPR_ASSERT(!channel_polling_thread_started);
-  GPR_ASSERT(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);
 
-  gpr_mu_init(&global_connection_polling_mu);
-  gpr_cv_init(&global_connection_polling_cv);
-
-  channel_polling_cq = grpc_completion_queue_create_for_next(NULL);
-  background_thread = rb_thread_create(run_poll_channels_loop, NULL);
-
-  if (!RTEST(background_thread)) {
-    gpr_log(GPR_DEBUG, "GRPC_RUBY: failed to spawn channel polling thread");
+  if (!RTEST(g_channel_polling_thread)) {
+    gpr_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)) {
+    gpr_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, 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_thread_started = false;
+  g_channel_polling_cq = NULL;
 }
 
 static void Init_grpc_propagate_masks() {
@@ -803,6 +878,7 @@ 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 =
@@ -829,6 +905,7 @@ void Init_grpc_channel() {
 
   id_channel = rb_intern("__channel");
   id_target = rb_intern("__target");
+  id_channel_recreation_mu = rb_intern("__channel_recreation_mu");
   rb_define_const(grpc_rb_cChannel, "SSL_TARGET",
                   ID2SYM(rb_intern(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)));
   rb_define_const(grpc_rb_cChannel, "ENABLE_CENSUS",