grpc 1.56.2-x64-mingw32 → 1.57.0.pre1-x64-mingw32

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

@@ -27,6 +27,7 @@
 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_channel_args.c

@@ -24,6 +24,7 @@
 #include "rb_grpc_imports.generated.h"
 
 #include <grpc/grpc.h>
+#include <grpc/support/log.h>
 
 static rb_data_type_t grpc_rb_channel_args_data_type = {
     "grpc_channel_args",
@@ -73,13 +74,14 @@ static int grpc_rb_channel_create_in_process_add_args_hash_cb(VALUE key,
     case T_SYMBOL:
       args->args[args->num_args - 1].type = GRPC_ARG_STRING;
       args->args[args->num_args - 1].value.string =
-          (char*)rb_id2name(SYM2ID(val));
+          strdup(rb_id2name(SYM2ID(val)));
       --args->num_args;
       return ST_CONTINUE;
 
     case T_STRING:
       args->args[args->num_args - 1].type = GRPC_ARG_STRING;
-      args->args[args->num_args - 1].value.string = StringValueCStr(val);
+      args->args[args->num_args - 1].value.string =
+          strdup(StringValueCStr(val));
       --args->num_args;
       return ST_CONTINUE;
 
@@ -154,3 +156,15 @@ void grpc_rb_hash_convert_to_channel_args(VALUE src_hash,
     rb_jump_tag(status);
   }
 }
+
+void grpc_rb_channel_args_destroy(grpc_channel_args* args) {
+  GPR_ASSERT(args != NULL);
+  if (args->args == NULL) return;
+  for (int i = 0; i < args->num_args; i++) {
+    if (args->args[i].type == GRPC_ARG_STRING) {
+      // we own string pointers, which were created with strdup
+      free(args->args[i].value.string);
+    }
+  }
+  xfree(args->args);
+}

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

@@ -35,4 +35,8 @@
 void grpc_rb_hash_convert_to_channel_args(VALUE src_hash,
                                           grpc_channel_args* dst);
 
+/* Destroys inner fields of args (does not deallocate the args pointer itself)
+ */
+void grpc_rb_channel_args_destroy(grpc_channel_args* args);
+
 #endif /* GRPC_RB_CHANNEL_ARGS_H_ */

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

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

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

@@ -70,7 +70,6 @@ static void grpc_rb_compression_options_free_internal(void* p) {
  * wrapped grpc compression options. */
 static void grpc_rb_compression_options_free(void* p) {
   grpc_rb_compression_options_free_internal(p);
-  grpc_ruby_shutdown();
 }
 
 /* Ruby recognized data type for the CompressionOptions class. */

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

@@ -51,6 +51,8 @@ typedef struct grpc_rb_event_queue {
 } grpc_rb_event_queue;
 
 static grpc_rb_event_queue event_queue;
+static VALUE g_event_thread = Qnil;
+static bool g_one_time_init_done = false;
 
 void grpc_rb_event_queue_enqueue(void (*callback)(void*), void* argument) {
   grpc_rb_event* event = gpr_malloc(sizeof(grpc_rb_event));
@@ -117,7 +119,6 @@ static void grpc_rb_event_unblocking_func(void* arg) {
 static VALUE grpc_rb_event_thread(VALUE arg) {
   grpc_rb_event* event;
   (void)arg;
-  grpc_ruby_init();
   while (true) {
     event = (grpc_rb_event*)rb_thread_call_without_gvl(
         grpc_rb_wait_for_event_no_gil, NULL, grpc_rb_event_unblocking_func,
@@ -131,15 +132,30 @@ static VALUE grpc_rb_event_thread(VALUE arg) {
     }
   }
   grpc_rb_event_queue_destroy();
-  grpc_ruby_shutdown();
   return Qnil;
 }
 
 void grpc_rb_event_queue_thread_start() {
-  event_queue.head = event_queue.tail = NULL;
+  if (!g_one_time_init_done) {
+    g_one_time_init_done = true;
+    gpr_mu_init(&event_queue.mu);
+    gpr_cv_init(&event_queue.cv);
+    rb_global_variable(&g_event_thread);
+    event_queue.head = event_queue.tail = NULL;
+  }
   event_queue.abort = false;
-  gpr_mu_init(&event_queue.mu);
-  gpr_cv_init(&event_queue.cv);
+  GPR_ASSERT(!RTEST(g_event_thread));
+  g_event_thread = rb_thread_create(grpc_rb_event_thread, NULL);
+}
 
-  rb_thread_create(grpc_rb_event_thread, NULL);
+void grpc_rb_event_queue_thread_stop() {
+  GPR_ASSERT(g_one_time_init_done);
+  if (!RTEST(g_event_thread)) {
+    gpr_log(GPR_ERROR,
+            "GRPC_RUBY: call credentials thread stop: thread not running");
+    return;
+  }
+  rb_thread_call_without_gvl(grpc_rb_event_unblocking_func, NULL, NULL, NULL);
+  rb_funcall(g_event_thread, rb_intern("join"), 0);
+  g_event_thread = Qnil;
 }

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

@@ -17,5 +17,6 @@
  */
 
 void grpc_rb_event_queue_thread_start();
+void grpc_rb_event_queue_thread_stop();
 
 void grpc_rb_event_queue_enqueue(void (*callback)(void*), void* argument);

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

@@ -44,6 +44,11 @@
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
+#ifdef GPR_LINUX
+#include <sys/syscall.h>
+#include <unistd.h>
+#endif
+
 static VALUE grpc_rb_cTimeVal = Qnil;
 
 static rb_data_type_t grpc_rb_timespec_data_type = {
@@ -224,20 +229,51 @@ static void Init_grpc_time_consts() {
   id_tv_nsec = rb_intern("tv_nsec");
 }
 
+static bool g_enable_fork_support;
+
+#ifdef GPR_LINUX
+static long sys_gettid() { return syscall(__NR_gettid); }
+static bool can_enable_fork_support() { return true; }
+#else
+static long sys_gettid() { return 0; }
+static bool can_enable_fork_support() { return false; }
+#endif
+
 #if GPR_WINDOWS
-static void grpc_ruby_set_init_pid(void) {}
-static bool grpc_ruby_forked_after_init(void) { return false; }
+static void grpc_ruby_basic_init(void) {}
+static bool grpc_ruby_initial_pid(void) { return true; }
+static bool grpc_ruby_initial_thread(void) { return true; }
+static void grpc_ruby_reset_init_state(void) {}
 #else
-static pid_t grpc_init_pid;
+static pid_t g_init_pid;
+static long g_init_tid;
 
-static void grpc_ruby_set_init_pid(void) {
-  GPR_ASSERT(grpc_init_pid == 0);
-  grpc_init_pid = getpid();
+static bool grpc_ruby_initial_pid(void) {
+  GPR_ASSERT(g_init_pid != 0);
+  return g_init_pid == getpid();
 }
 
-static bool grpc_ruby_forked_after_init(void) {
-  GPR_ASSERT(grpc_init_pid != 0);
-  return grpc_init_pid != getpid();
+static bool grpc_ruby_initial_thread(void) {
+  GPR_ASSERT(g_init_tid != 0);
+  return sys_gettid() == g_init_tid;
+}
+
+static void grpc_ruby_reset_init_state(void) {
+  g_init_pid = getpid();
+  g_init_tid = sys_gettid();
+}
+
+static void grpc_ruby_basic_init(void) {
+  GPR_ASSERT(g_init_pid == 0);
+  GPR_ASSERT(g_init_tid == 0);
+  grpc_ruby_reset_init_state();
+  // TODO(apolcyn): ideally, we should share logic with C-core
+  // for determining whether or not fork support is enabled, rather
+  // than parsing the environment variable ourselves.
+  const char* res = getenv("GRPC_ENABLE_FORK_SUPPORT");
+  if (res != NULL && strcmp(res, "1") == 0) {
+    g_enable_fork_support = can_enable_fork_support();
+  }
 }
 #endif
 
@@ -258,59 +294,175 @@ VALUE sym_details = Qundef;
 VALUE sym_metadata = Qundef;
 
 static gpr_once g_once_init = GPR_ONCE_INIT;
+static int64_t g_grpc_rb_prefork_pending;          // synchronized by the GIL
+static int64_t g_grpc_rb_num_fork_unsafe_threads;  // synchronized by the GIL
 
 void grpc_ruby_fork_guard() {
-  if (grpc_ruby_forked_after_init()) {
-    rb_raise(rb_eRuntimeError, "grpc cannot be used before and after forking");
+  // Check if we're using gRPC between prefork and postfork
+  gpr_once_init(&g_once_init, grpc_ruby_basic_init);
+  if (g_grpc_rb_prefork_pending) {
+    rb_raise(rb_eRuntimeError,
+             "grpc cannot be used between calls to GRPC.prefork and "
+             "GRPC.postfork_child or GRPC.postfork_parent");
+  }
+  if (!grpc_ruby_initial_pid()) {
+    if (g_enable_fork_support) {
+      // Only way we can get here is by enabling for support and forking but not
+      // calling prefork
+      rb_raise(rb_eRuntimeError,
+               "grpc is in a broken state: GRPC.prefork must be called before "
+               "calling fork from a process using grpc");
+    } else {
+      rb_raise(rb_eRuntimeError,
+               "grpc cannot be used before and after forking unless the "
+               "GRPC_ENABLE_FORK_SUPPORT env var is set to \"1\" and the "
+               "platform supports it (linux only)");
+    }
   }
 }
 
-static VALUE bg_thread_init_rb_mu = Qundef;
-static int bg_thread_init_done = 0;
+static VALUE g_bg_thread_init_rb_mu = Qundef;
+static bool g_bg_thread_init_done;
 
 static void grpc_ruby_init_threads() {
   // Avoid calling into ruby library (when creating threads here)
   // in gpr_once_init. In general, it appears to be unsafe to call
   // into the ruby library while holding a non-ruby mutex, because a gil yield
   // could end up trying to lock onto that same mutex and deadlocking.
-  rb_mutex_lock(bg_thread_init_rb_mu);
-  if (!bg_thread_init_done) {
+  gpr_log(GPR_INFO,
+          "GRPC_RUBY: grpc_ruby_init_threads g_bg_thread_init_done=%d",
+          g_bg_thread_init_done);
+  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();
-    bg_thread_init_done = 1;
+    g_bg_thread_init_done = true;
   }
-  rb_mutex_unlock(bg_thread_init_rb_mu);
+  rb_mutex_unlock(g_bg_thread_init_rb_mu);
 }
 
 static int64_t g_grpc_ruby_init_count;
 
 void grpc_ruby_init() {
-  gpr_once_init(&g_once_init, grpc_ruby_set_init_pid);
+  gpr_once_init(&g_once_init, grpc_ruby_basic_init);
+  grpc_ruby_fork_guard();
   grpc_init();
   grpc_ruby_init_threads();
   // (only gpr_log after logging has been initialized)
   gpr_log(GPR_DEBUG,
-          "GRPC_RUBY: grpc_ruby_init - prev g_grpc_ruby_init_count:%" PRId64,
-          g_grpc_ruby_init_count++);
+          "GRPC_RUBY: grpc_ruby_init - g_enable_fork_support=%d prev "
+          "g_grpc_ruby_init_count:%" PRId64,
+          g_enable_fork_support, g_grpc_ruby_init_count++);
+}
+
+// fork APIs, useable on linux with env var: GRPC_ENABLE_FORK_SUPPORT=1
+//
+// Must be called once and only once before forking. Must be called on the
+// same threads that gRPC was (lazy-)initialized on. One must not call
+// into the gRPC library during or after prefork has been called, until
+// the corresponding postfork_{parent,child} APIs have been called.
+static VALUE grpc_rb_prefork(VALUE self) {
+  // This might be the first time we've called into the grpc library, so make
+  // sure basic one-time initialization is taken care of. Note that if this is
+  // the case, then grpc_init() will start up c-core threads; that's OK since
+  // they will be shut down in C-core's pthread_atfork handler.
+  gpr_once_init(&g_once_init, grpc_ruby_basic_init);
+  grpc_init();
+  if (!g_enable_fork_support) {
+    rb_raise(rb_eRuntimeError,
+             "forking with gRPC/Ruby is only supported on linux with env var: "
+             "GRPC_ENABLE_FORK_SUPPORT=1");
+  }
+  if (g_grpc_rb_prefork_pending) {
+    rb_raise(rb_eRuntimeError,
+             "GRPC.prefork already called without a matching "
+             "GRPC.postfork_{parent,child}");
+  }
+  if (!grpc_ruby_initial_thread()) {
+    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");
+  }
+  if (g_grpc_rb_num_fork_unsafe_threads > 0) {
+    rb_raise(
+        rb_eRuntimeError,
+        "Detected at least %ld threads actively using grpc, so it is not safe "
+        "call GRPC.prefork or fork. Note that grpc-ruby servers and "
+        "bidirectional "
+        "streams manage background threads and are not fork safe.",
+        g_grpc_rb_num_fork_unsafe_threads);
+  }
+  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;
+  }
+  rb_mutex_unlock(g_bg_thread_init_rb_mu);
+  return Qnil;
 }
 
-void grpc_ruby_shutdown() {
-  GPR_ASSERT(g_grpc_ruby_init_count > 0);
-  if (!grpc_ruby_forked_after_init()) grpc_shutdown();
-  gpr_log(
-      GPR_DEBUG,
-      "GRPC_RUBY: grpc_ruby_shutdown - prev g_grpc_ruby_init_count:%" PRId64,
-      g_grpc_ruby_init_count--);
+static VALUE grpc_rb_postfork_child(VALUE self) {
+  if (!g_grpc_rb_prefork_pending) {
+    rb_raise(rb_eRuntimeError,
+             "GRPC::postfork_child can only be called once following a "
+             "GRPC::prefork");
+  }
+  if (grpc_ruby_initial_pid()) {
+    rb_raise(rb_eRuntimeError,
+             "GRPC.postfork_child must be called only from the child process "
+             "after a fork");
+  }
+  grpc_ruby_reset_init_state();
+  grpc_ruby_init_threads();
+  g_grpc_rb_prefork_pending = false;
+  return Qnil;
 }
 
+static VALUE grpc_rb_postfork_parent(VALUE self) {
+  // TODO(apolcyn): check calling thread vs. thread that gRPC was initialized on
+  if (!g_grpc_rb_prefork_pending) {
+    rb_raise(rb_eRuntimeError,
+             "GRPC::postfork_parent can only be called once following a "
+             "GRPC::prefork");
+  }
+  if (!grpc_ruby_initial_pid()) {
+    rb_raise(rb_eRuntimeError,
+             "GRPC.postfork_parent must be called only from the parent process "
+             "after a fork");
+  }
+  if (!grpc_ruby_initial_thread()) {
+    rb_raise(rb_eRuntimeError,
+             "GRPC.postfork_parent needs to be called from the same thread "
+             "that GRPC.prefork (and fork) was called from");
+  }
+  grpc_ruby_init_threads();
+  g_grpc_rb_prefork_pending = false;
+  return Qnil;
+}
+
+// APIs to mark fork-unsafe sections from C-extension code
+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_end_api() { grpc_rb_fork_unsafe_end(); }
+
+// One-time initialization
 void Init_grpc_c() {
   if (!grpc_rb_load_core()) {
     rb_raise(rb_eLoadError, "Couldn't find or load gRPC's dynamic C core");
     return;
   }
 
-  rb_global_variable(&bg_thread_init_rb_mu);
-  bg_thread_init_rb_mu = rb_mutex_new();
+  rb_global_variable(&g_bg_thread_init_rb_mu);
+  g_bg_thread_init_rb_mu = rb_mutex_new();
 
   grpc_rb_mGRPC = rb_define_module("GRPC");
   grpc_rb_mGrpcCore = rb_define_module_under(grpc_rb_mGRPC, "Core");
@@ -320,7 +472,7 @@ void Init_grpc_c() {
   sym_code = ID2SYM(rb_intern("code"));
   sym_details = ID2SYM(rb_intern("details"));
   sym_metadata = ID2SYM(rb_intern("metadata"));
-
+  // init C-defined classes
   Init_grpc_channel();
   Init_grpc_call();
   Init_grpc_call_credentials();
@@ -331,4 +483,14 @@ void Init_grpc_c() {
   Init_grpc_xds_server_credentials();
   Init_grpc_time_consts();
   Init_grpc_compression_options();
+  // define fork APIs
+  rb_define_module_function(grpc_rb_mGRPC, "prefork", grpc_rb_prefork, 0);
+  rb_define_module_function(grpc_rb_mGRPC, "postfork_child",
+                            grpc_rb_postfork_child, 0);
+  rb_define_module_function(grpc_rb_mGRPC, "postfork_parent",
+                            grpc_rb_postfork_parent, 0);
+  rb_define_module_function(grpc_rb_mGrpcCore, "fork_unsafe_begin",
+                            grpc_rb_fork_unsafe_begin_api, 0);
+  rb_define_module_function(grpc_rb_mGrpcCore, "fork_unsafe_end",
+                            grpc_rb_fork_unsafe_end_api, 0);
 }

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

@@ -70,8 +70,14 @@ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval);
 
 void grpc_ruby_fork_guard();
 
-void grpc_ruby_init();
+/* To be called once and only once before entering code section that is
+ * definitely not fork-safe. Used in conjunction with GRPC.prefork
+ * to catch for-unsafe processes and raise errors. */
+void grpc_rb_fork_unsafe_begin();
+
+/* To be called once and only once after each grpc_rb_fork_unsafe_begin*/
+void grpc_rb_fork_unsafe_end();
 
-void grpc_ruby_shutdown();
+void grpc_ruby_init();
 
 #endif /* GRPC_RB_H_ */

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

@@ -106,10 +106,7 @@ static void grpc_rb_server_free_internal(void* p) {
 }
 
 /* Destroys server instances. */
-static void grpc_rb_server_free(void* p) {
-  grpc_rb_server_free_internal(p);
-  grpc_ruby_shutdown();
-}
+static void grpc_rb_server_free(void* p) { grpc_rb_server_free_internal(p); }
 
 static const rb_data_type_t grpc_rb_server_data_type = {
     "grpc_server",
@@ -155,10 +152,7 @@ static VALUE grpc_rb_server_init(VALUE self, VALUE channel_args) {
                        wrapper);
   grpc_rb_hash_convert_to_channel_args(channel_args, &args);
   srv = grpc_server_create(&args, NULL);
-
-  if (args.args != NULL) {
-    xfree(args.args); /* Allocated by grpc_rb_hash_convert_to_channel_args */
-  }
+  grpc_rb_channel_args_destroy(&args);
   if (srv == NULL) {
     rb_raise(rb_eRuntimeError, "could not create a gRPC server, not sure why");
   }
@@ -191,65 +185,88 @@ static void grpc_request_call_stack_cleanup(request_call_stack* st) {
   grpc_call_details_destroy(&st->details);
 }
 
-/* call-seq:
-   server.request_call
+struct server_request_call_args {
+  grpc_rb_server* server;
+  grpc_completion_queue* call_queue;
+  request_call_stack st;
+};
+
+static VALUE grpc_rb_server_request_call_try(VALUE value_args) {
+  grpc_rb_fork_unsafe_begin();
+  struct server_request_call_args* args =
+      (struct server_request_call_args*)value_args;
 
-   Requests notification of a new call on a server. */
-static VALUE grpc_rb_server_request_call(VALUE self) {
-  grpc_rb_server* s = NULL;
   grpc_call* call = NULL;
-  grpc_event ev;
-  grpc_call_error err;
-  request_call_stack st;
-  VALUE result;
-  void* tag = (void*)&st;
-  grpc_completion_queue* call_queue =
-      grpc_completion_queue_create_for_pluck(NULL);
-  gpr_timespec deadline;
+  void* tag = (void*)&args->st;
+
+  args->call_queue = grpc_completion_queue_create_for_pluck(NULL);
+  grpc_request_call_stack_init(&args->st);
 
-  TypedData_Get_Struct(self, grpc_rb_server, &grpc_rb_server_data_type, s);
-  if (s->wrapped == NULL) {
-    rb_raise(rb_eRuntimeError, "destroyed!");
-    return Qnil;
-  }
-  grpc_request_call_stack_init(&st);
   /* call grpc_server_request_call, then wait for it to complete using
    * pluck_event */
-  err = grpc_server_request_call(s->wrapped, &call, &st.details, &st.md_ary,
-                                 call_queue, s->queue, tag);
+  grpc_call_error err = grpc_server_request_call(
+      args->server->wrapped, &call, &args->st.details, &args->st.md_ary,
+      args->call_queue, args->server->queue, tag);
   if (err != GRPC_CALL_OK) {
-    grpc_request_call_stack_cleanup(&st);
     rb_raise(grpc_rb_eCallError,
              "grpc_server_request_call failed: %s (code=%d)",
              grpc_call_error_detail_of(err), err);
-    return Qnil;
   }
 
-  ev = rb_completion_queue_pluck(s->queue, tag,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  grpc_event ev = rb_completion_queue_pluck(
+      args->server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
   if (!ev.success) {
-    grpc_request_call_stack_cleanup(&st);
     rb_raise(grpc_rb_eCallError, "request_call completion failed");
-    return Qnil;
   }
 
   /* build the NewServerRpc struct result */
-  deadline = gpr_convert_clock_type(st.details.deadline, GPR_CLOCK_REALTIME);
-  result = rb_struct_new(
-      grpc_rb_sNewServerRpc, grpc_rb_slice_to_ruby_string(st.details.method),
-      grpc_rb_slice_to_ruby_string(st.details.host),
-      rb_funcall(rb_cTime, id_at, 2, INT2NUM(deadline.tv_sec),
-                 INT2NUM(deadline.tv_nsec / 1000)),
-      grpc_rb_md_ary_to_h(&st.md_ary), grpc_rb_wrap_call(call, call_queue),
-      NULL);
-  grpc_request_call_stack_cleanup(&st);
+  gpr_timespec deadline =
+      gpr_convert_clock_type(args->st.details.deadline, GPR_CLOCK_REALTIME);
+  VALUE result =
+      rb_struct_new(grpc_rb_sNewServerRpc,
+                    grpc_rb_slice_to_ruby_string(args->st.details.method),
+                    grpc_rb_slice_to_ruby_string(args->st.details.host),
+                    rb_funcall(rb_cTime, id_at, 2, INT2NUM(deadline.tv_sec),
+                               INT2NUM(deadline.tv_nsec / 1000)),
+                    grpc_rb_md_ary_to_h(&args->st.md_ary),
+                    grpc_rb_wrap_call(call, args->call_queue), NULL);
+  args->call_queue = NULL;
   return result;
 }
 
+static VALUE grpc_rb_server_request_call_ensure(VALUE value_args) {
+  grpc_rb_fork_unsafe_end();
+  struct server_request_call_args* args =
+      (struct server_request_call_args*)value_args;
+
+  if (args->call_queue) {
+    grpc_rb_completion_queue_destroy(args->call_queue);
+  }
+
+  grpc_request_call_stack_cleanup(&args->st);
+
+  return Qnil;
+}
+
+/* call-seq:
+   server.request_call
+
+   Requests notification of a new call on a server. */
+static VALUE grpc_rb_server_request_call(VALUE self) {
+  grpc_rb_server* s;
+  TypedData_Get_Struct(self, grpc_rb_server, &grpc_rb_server_data_type, s);
+  grpc_ruby_fork_guard();
+  if (s->wrapped == NULL) {
+    rb_raise(rb_eRuntimeError, "destroyed!");
+  }
+  struct server_request_call_args args = {.server = s, .call_queue = NULL};
+  return rb_ensure(grpc_rb_server_request_call_try, (VALUE)&args,
+                   grpc_rb_server_request_call_ensure, (VALUE)&args);
+}
+
 static VALUE grpc_rb_server_start(VALUE self) {
   grpc_rb_server* s = NULL;
   TypedData_Get_Struct(self, grpc_rb_server, &grpc_rb_server_data_type, s);
-
   grpc_ruby_fork_guard();
   if (s->wrapped == NULL) {
     rb_raise(rb_eRuntimeError, "destroyed!");

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

@@ -62,7 +62,6 @@ static void grpc_rb_server_credentials_free_internal(void* p) {
 /* Destroys the server credentials instances. */
 static void grpc_rb_server_credentials_free(void* p) {
   grpc_rb_server_credentials_free_internal(p);
-  grpc_ruby_shutdown();
 }
 
 /* Protects the mark object from GC */

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

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

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

@@ -63,7 +63,6 @@ static void grpc_rb_xds_server_credentials_free_internal(void* p) {
 /* Destroys the server credentials instances. */
 static void grpc_rb_xds_server_credentials_free(void* p) {
   grpc_rb_xds_server_credentials_free_internal(p);
-  grpc_ruby_shutdown();
 }
 
 /* Protects the mark object from GC */

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

@@ -141,6 +141,7 @@ module GRPC
     # set_output_stream_done is relevant on client-side
     # rubocop:disable Metrics/PerceivedComplexity
     def write_loop(requests, is_client: true, set_output_stream_done: nil)
+      GRPC::Core.fork_unsafe_begin
       GRPC.logger.debug('bidi-write-loop: starting')
       count = 0
       requests.each do |req|
@@ -181,6 +182,7 @@ module GRPC
         raise e
       end
     ensure
+      GRPC::Core.fork_unsafe_end
       set_output_stream_done.call if is_client
     end
     # rubocop:enable Metrics/PerceivedComplexity

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

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