grpc 1.56.2 → 1.58.0

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/active_call.rb

@@ -232,17 +232,16 @@ module GRPC
     def server_unary_response(req, trailing_metadata: {},
                               code: Core::StatusCodes::OK, details: 'OK')
       ops = {}
+      ops[SEND_MESSAGE] = @marshal.call(req)
+      ops[SEND_STATUS_FROM_SERVER] = Struct::Status.new(
+        code, details, trailing_metadata)
+      ops[RECV_CLOSE_ON_SERVER] = nil
+
       @send_initial_md_mutex.synchronize do
         ops[SEND_INITIAL_METADATA] = @metadata_to_send unless @metadata_sent
         @metadata_sent = true
       end
 
-      payload = @marshal.call(req)
-      ops[SEND_MESSAGE] = payload
-      ops[SEND_STATUS_FROM_SERVER] = Struct::Status.new(
-        code, details, trailing_metadata)
-      ops[RECV_CLOSE_ON_SERVER] = nil
-
       @call.run_batch(ops)
       set_output_stream_done
     end
@@ -262,6 +261,9 @@ module GRPC
         @metadata_received = true
       end
       get_message_from_batch_result(batch_result)
+    rescue GRPC::Core::CallError => e
+      GRPC.logger.info("remote_read: #{e}")
+      nil
     end
 
     def get_message_from_batch_result(recv_message_batch_result)
@@ -328,14 +330,7 @@ module GRPC
     def each_remote_read_then_finish
       return enum_for(:each_remote_read_then_finish) unless block_given?
       loop do
-        resp =
-          begin
-            remote_read
-          rescue GRPC::Core::CallError => e
-            GRPC.logger.warn("In each_remote_read_then_finish: #{e}")
-            nil
-          end
-
+        resp = remote_read
         break if resp.nil?  # the last response was received
         yield resp
       end

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.58.0'
 end

data/src/ruby/pb/grpc/health/v1/health_pb.rb

@@ -1,23 +1,34 @@
+# frozen_string_literal: true
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: grpc/health/v1/health.proto
 
 require 'google/protobuf'
 
-Google::Protobuf::DescriptorPool.generated_pool.build do
-  add_file("grpc/health/v1/health.proto", :syntax => :proto3) do
-    add_message "grpc.health.v1.HealthCheckRequest" do
-      optional :service, :string, 1
-    end
-    add_message "grpc.health.v1.HealthCheckResponse" do
-      optional :status, :enum, 1, "grpc.health.v1.HealthCheckResponse.ServingStatus"
-    end
-    add_enum "grpc.health.v1.HealthCheckResponse.ServingStatus" do
-      value :UNKNOWN, 0
-      value :SERVING, 1
-      value :NOT_SERVING, 2
-      value :SERVICE_UNKNOWN, 3
+
+descriptor_data = "\n\x1bgrpc/health/v1/health.proto\x12\x0egrpc.health.v1\"%\n\x12HealthCheckRequest\x12\x0f\n\x07service\x18\x01 \x01(\t\"\xa9\x01\n\x13HealthCheckResponse\x12\x41\n\x06status\x18\x01 \x01(\x0e\x32\x31.grpc.health.v1.HealthCheckResponse.ServingStatus\"O\n\rServingStatus\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07SERVING\x10\x01\x12\x0f\n\x0bNOT_SERVING\x10\x02\x12\x13\n\x0fSERVICE_UNKNOWN\x10\x03\x32\xae\x01\n\x06Health\x12P\n\x05\x43heck\x12\".grpc.health.v1.HealthCheckRequest\x1a#.grpc.health.v1.HealthCheckResponse\x12R\n\x05Watch\x12\".grpc.health.v1.HealthCheckRequest\x1a#.grpc.health.v1.HealthCheckResponse0\x01\x42\x61\n\x11io.grpc.health.v1B\x0bHealthProtoP\x01Z,google.golang.org/grpc/health/grpc_health_v1\xaa\x02\x0eGrpc.Health.V1b\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 Grpc

data/src/ruby/pb/src/proto/grpc/testing/empty_pb.rb

@@ -1,13 +1,34 @@
+# frozen_string_literal: true
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: src/proto/grpc/testing/empty.proto
 
 require 'google/protobuf'
 
-Google::Protobuf::DescriptorPool.generated_pool.build do
-  add_file("src/proto/grpc/testing/empty.proto", :syntax => :proto3) do
-    add_message "grpc.testing.Empty" do
+
+descriptor_data = "\n\"src/proto/grpc/testing/empty.proto\x12\x0cgrpc.testing\"\x07\n\x05\x45mptyb\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 Grpc