grpc 1.63.0 → 1.66.0

data/src/core/{ext/xds → xds/xds_client}/xds_client.h

@@ -14,10 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_CLIENT_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_CLIENT_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_CLIENT_H
+#define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_CLIENT_H
 
 #include <map>
 #include <memory>
@@ -33,13 +31,8 @@
 #include "upb/reflection/def.hpp"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/ext/xds/xds_api.h"
-#include "src/core/ext/xds/xds_bootstrap.h"
-#include "src/core/ext/xds/xds_client_stats.h"
-#include "src/core/ext/xds/xds_metrics.h"
-#include "src/core/ext/xds/xds_resource_type.h"
-#include "src/core/ext/xds/xds_transport.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/orphanable.h"
@@ -49,6 +42,12 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/uri/uri_parser.h"
+#include "src/core/xds/xds_client/xds_api.h"
+#include "src/core/xds/xds_client/xds_bootstrap.h"
+#include "src/core/xds/xds_client/xds_client_stats.h"
+#include "src/core/xds/xds_client/xds_metrics.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
+#include "src/core/xds/xds_client/xds_transport.h"
 
 namespace grpc_core {
 
@@ -56,9 +55,6 @@ namespace testing {
 class XdsClientTestPeer;
 }
 
-extern TraceFlag grpc_xds_client_trace;
-extern TraceFlag grpc_xds_client_refcount_trace;
-
 class XdsClient : public DualRefCounted<XdsClient> {
  public:
   // The authority reported for old-style (non-xdstp) resource names.
@@ -388,4 +384,4 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_CLIENT_H
+#endif  // GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_CLIENT_H

data/src/core/{ext/xds → xds/xds_client}/xds_client_stats.cc

@@ -16,15 +16,15 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
+#include "src/core/xds/xds_client/xds_client_stats.h"
 
-#include "src/core/ext/xds/xds_client_stats.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/ext/xds/xds_client.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/xds/xds_client/xds_client.h"
 
 namespace grpc_core {
 
@@ -44,28 +44,25 @@ XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
                                          absl::string_view lrs_server,
                                          absl::string_view cluster_name,
                                          absl::string_view eds_service_name)
-    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(xds_client_refcount)
                      ? "XdsClusterDropStats"
                      : nullptr),
       xds_client_(std::move(xds_client)),
       lrs_server_(lrs_server),
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-    gpr_log(GPR_INFO, "[xds_client %p] created drop stats %p for {%s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
+    LOG(INFO) << "[xds_client " << xds_client_.get() << "] created drop stats "
+              << this << " for {" << lrs_server_ << ", " << cluster_name_
+              << ", " << eds_service_name_ << "}";
   }
 }
 
 XdsClusterDropStats::~XdsClusterDropStats() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-    gpr_log(GPR_INFO,
-            "[xds_client %p] destroying drop stats %p for {%s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
+    LOG(INFO) << "[xds_client " << xds_client_.get()
+              << "] destroying drop stats " << this << " for {" << lrs_server_
+              << ", " << cluster_name_ << ", " << eds_service_name_ << "}";
   }
   xds_client_->RemoveClusterDropStats(lrs_server_, cluster_name_,
                                       eds_service_name_, this);
@@ -97,7 +94,7 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
     RefCountedPtr<XdsClient> xds_client, absl::string_view lrs_server,
     absl::string_view cluster_name, absl::string_view eds_service_name,
     RefCountedPtr<XdsLocalityName> name)
-    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(xds_client_refcount)
                      ? "XdsClusterLocalityStats"
                      : nullptr),
       xds_client_(std::move(xds_client)),
@@ -105,24 +102,25 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name),
       name_(std::move(name)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-    gpr_log(GPR_INFO,
-            "[xds_client %p] created locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str(),
-            name_->human_readable_string().c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
+    LOG(INFO) << "[xds_client " << xds_client_.get()
+              << "] created locality stats " << this << " for {" << lrs_server_
+              << ", " << cluster_name_ << ", " << eds_service_name_ << ", "
+              << (name_ == nullptr ? "<none>"
+                                   : name_->human_readable_string().c_str())
+              << "}";
   }
 }
 
 XdsClusterLocalityStats::~XdsClusterLocalityStats() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-    gpr_log(GPR_INFO,
-            "[xds_client %p] destroying locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str(),
-            name_->human_readable_string().c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
+    LOG(INFO) << "[xds_client " << xds_client_.get()
+              << "] destroying locality stats " << this << " for {"
+              << lrs_server_ << ", " << cluster_name_ << ", "
+              << eds_service_name_ << ", "
+              << (name_ == nullptr ? "<none>"
+                                   : name_->human_readable_string().c_str())
+              << "}";
   }
   xds_client_->RemoveClusterLocalityStats(lrs_server_, cluster_name_,
                                           eds_service_name_, name_, this);

data/src/core/{ext/xds → xds/xds_client}/xds_client_stats.h

@@ -16,10 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_CLIENT_STATS_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_CLIENT_STATS_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_CLIENT_STATS_H
+#define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_CLIENT_STATS_H
 
 #include <atomic>
 #include <cstdint>
@@ -31,14 +29,16 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
-#include "src/core/ext/xds/xds_bootstrap.h"
-#include "src/core/lib/channel/call_tracer.h"
-#include "src/core/lib/gpr/useful.h"
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/per_cpu.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/resolver/endpoint_addresses.h"
+#include "src/core/telemetry/call_tracer.h"
+#include "src/core/util/useful.h"
+#include "src/core/xds/xds_client/xds_bootstrap.h"
 
 namespace grpc_core {
 
@@ -255,4 +255,4 @@ class XdsClusterLocalityStats final
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_CLIENT_STATS_H
+#endif  // GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_CLIENT_STATS_H

data/src/core/{ext/xds → xds/xds_client}/xds_metrics.h

@@ -14,13 +14,13 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_METRICS_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_METRICS_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_METRICS_H
+#define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_METRICS_H
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 // An interface for XdsClient to report metrics.
@@ -32,8 +32,10 @@ class XdsMetricsReporter {
                                      absl::string_view resource_type,
                                      uint64_t num_valid,
                                      uint64_t num_invalid) = 0;
+
+  virtual void ReportServerFailure(absl::string_view xds_server) = 0;
 };
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_METRICS_H
+#endif  // GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_METRICS_H

data/src/core/{ext/xds → xds/xds_client}/xds_resource_type.h

@@ -14,10 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H
-#include <grpc/support/port_platform.h>
-
+#ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_H
+#define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_H
 #include <memory>
 #include <string>
 
@@ -27,8 +25,10 @@
 #include "upb/mem/arena.h"
 #include "upb/reflection/def.h"
 
-#include "src/core/ext/xds/xds_bootstrap.h"
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/debug/trace.h"
+#include "src/core/xds/xds_client/xds_bootstrap.h"
 
 namespace grpc_core {
 
@@ -95,4 +95,4 @@ class XdsResourceType {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H
+#endif  // GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_H

data/src/core/{ext/xds → xds/xds_client}/xds_resource_type_impl.h

@@ -14,18 +14,18 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_IMPL_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_IMPL_H
-#include <grpc/support/port_platform.h>
-
+#ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_IMPL_H
+#define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_IMPL_H
 #include <memory>
 #include <utility>
 
 #include "absl/strings/string_view.h"
 
-#include "src/core/ext/xds/xds_client.h"
-#include "src/core/ext/xds/xds_resource_type.h"
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/xds/xds_client/xds_client.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
 
 namespace grpc_core {
 
@@ -85,4 +85,4 @@ class XdsResourceTypeImpl : public XdsResourceType {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_IMPL_H
+#endif  // GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_RESOURCE_TYPE_IMPL_H

data/src/core/{ext/xds → xds/xds_client}/xds_transport.h

@@ -14,10 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_TRANSPORT_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_TRANSPORT_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_TRANSPORT_H
+#define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_TRANSPORT_H
 
 #include <functional>
 #include <memory>
@@ -26,8 +24,10 @@
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
-#include "src/core/ext/xds/xds_bootstrap.h"
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/xds/xds_client/xds_bootstrap.h"
 
 namespace grpc_core {
 
@@ -86,4 +86,4 @@ class XdsTransportFactory : public InternallyRefCounted<XdsTransportFactory> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_TRANSPORT_H
+#endif  // GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_TRANSPORT_H

data/src/ruby/bin/math_pb.rb

@@ -8,28 +8,7 @@ require 'google/protobuf'
 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
-  # 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
+pool.add_serialized_file(descriptor_data)
 
 module Math
   DivArgs = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("math.DivArgs").msgclass

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

@@ -437,7 +437,7 @@ static int grpc_rb_md_ary_fill_hash_cb(VALUE key, VALUE val, VALUE md_ary_obj) {
                  tmp_str);
         return ST_STOP;
       }
-      GPR_ASSERT(md_ary->count < md_ary->capacity);
+      GRPC_RUBY_ASSERT(md_ary->count < md_ary->capacity);
       md_ary->metadata[md_ary->count].key = key_slice;
       md_ary->metadata[md_ary->count].value = value_slice;
       md_ary->count += 1;
@@ -453,7 +453,7 @@ static int grpc_rb_md_ary_fill_hash_cb(VALUE key, VALUE val, VALUE md_ary_obj) {
                tmp_str);
       return ST_STOP;
     }
-    GPR_ASSERT(md_ary->count < md_ary->capacity);
+    GRPC_RUBY_ASSERT(md_ary->count < md_ary->capacity);
     md_ary->metadata[md_ary->count].key = key_slice;
     md_ary->metadata[md_ary->count].value = value_slice;
     md_ary->count += 1;
@@ -808,6 +808,12 @@ struct call_run_batch_args {
   run_batch_stack* st;
 };
 
+static void cancel_call_unblock_func(void* arg) {
+  gpr_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;
@@ -830,7 +836,8 @@ static VALUE grpc_rb_call_run_batch_try(VALUE value_args) {
              grpc_call_error_detail_of(err), err);
   }
   ev = rb_completion_queue_pluck(args->call->queue, tag,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+                                 gpr_inf_future(GPR_CLOCK_REALTIME),
+                                 cancel_call_unblock_func, args->call->wrapped);
   if (!ev.success) {
     rb_raise(grpc_rb_eCallError, "call#run_batch failed somehow");
   }

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

@@ -27,6 +27,7 @@
 #include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
@@ -111,7 +112,7 @@ static VALUE grpc_rb_call_credentials_callback_rescue(VALUE args,
   VALUE rb_exception_info =
       rb_funcall(exception_object, rb_intern("inspect"), 0);
   (void)args;
-  gpr_log(GPR_INFO,
+  gpr_log(GPR_DEBUG,
           "GRPC_RUBY call credentials callback failed, exception inspect:|%s| "
           "backtrace:|%s|",
           StringValueCStr(rb_exception_info), StringValueCStr(backtrace_str));

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

@@ -21,6 +21,7 @@
 
 #include <ruby/ruby.h>
 
+#include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
 
 /* Initializes the ruby CallCredentials class. */

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

@@ -32,6 +32,7 @@
 #include "rb_server.h"
 #include "rb_xds_channel_credentials.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
@@ -122,7 +123,7 @@ 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) {
-  GPR_ASSERT(!op->op.api_callback_args.called_back);
+  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
@@ -132,7 +133,7 @@ static void grpc_rb_channel_watch_connection_state_op_complete(
 /* Avoids destroying a channel twice. */
 static void grpc_rb_channel_safe_destroy(bg_watched_channel* bg) {
   gpr_mu_lock(&global_connection_polling_mu);
-  GPR_ASSERT(bg_watched_channel_list_lookup(bg));
+  GRPC_RUBY_ASSERT(bg_watched_channel_list_lookup(bg));
   if (!bg->channel_destroyed) {
     grpc_channel_destroy(bg->channel);
     bg->channel_destroyed = 1;
@@ -252,7 +253,7 @@ static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
     ch = grpc_channel_create(target_chars, creds, &wrapper->args);
   }
 
-  GPR_ASSERT(ch);
+  GRPC_RUBY_ASSERT(ch);
   stack.channel = ch;
   stack.wrapper = wrapper;
   rb_thread_call_without_gvl(
@@ -415,7 +416,7 @@ static void grpc_rb_channel_maybe_recreate_channel_after_fork(
   if (bg->channel_destroyed) {
     // There must be one ref at this point, held by the ruby-level channel
     // object, drop this one here.
-    GPR_ASSERT(bg->refcount == 1);
+    GRPC_RUBY_ASSERT(bg->refcount == 1);
     rb_thread_call_without_gvl(channel_safe_destroy_without_gil, bg, NULL,
                                NULL);
     // re-create C-core channel
@@ -580,8 +581,8 @@ static void bg_watched_channel_list_free_and_remove(
     bg_watched_channel* target) {
   bg_watched_channel* bg = NULL;
 
-  GPR_ASSERT(bg_watched_channel_list_lookup(target));
-  GPR_ASSERT(target->channel_destroyed && target->refcount == 0);
+  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);
@@ -596,7 +597,7 @@ static void bg_watched_channel_list_free_and_remove(
     }
     bg = bg->next;
   }
-  GPR_ASSERT(0);
+  GRPC_RUBY_ASSERT(0);
 }
 
 /* Initialize a grpc_rb_channel's "protected grpc_channel" and try to push
@@ -620,11 +621,11 @@ static void grpc_rb_channel_try_register_connection_polling(
   grpc_connectivity_state conn_state;
   watch_state_op* op = NULL;
   if (bg->refcount == 0) {
-    GPR_ASSERT(bg->channel_destroyed);
+    GRPC_RUBY_ASSERT(bg->channel_destroyed);
     bg_watched_channel_list_free_and_remove(bg);
     return;
   }
-  GPR_ASSERT(bg->refcount == 1);
+  GRPC_RUBY_ASSERT(bg->refcount == 1);
   if (bg->channel_destroyed || g_abort_channel_polling) {
     return;
   }
@@ -632,7 +633,7 @@ static void grpc_rb_channel_try_register_connection_polling(
   if (conn_state == GRPC_CHANNEL_SHUTDOWN) {
     return;
   }
-  GPR_ASSERT(bg_watched_channel_list_lookup(bg));
+  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));
@@ -678,7 +679,7 @@ static void* run_poll_channels_loop_no_gil(void* arg) {
         grpc_rb_channel_watch_connection_state_op_complete(
             (watch_state_op*)event.tag, event.success);
       } else {
-        GPR_ASSERT(0);
+        GRPC_RUBY_ASSERT(0);
       }
     }
     gpr_mu_unlock(&global_connection_polling_mu);
@@ -768,9 +769,9 @@ static void do_basic_init() {
  */
 void grpc_rb_channel_polling_thread_start() {
   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_cq == NULL);
+  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);

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

@@ -160,7 +160,7 @@ void grpc_rb_hash_convert_to_channel_args(VALUE src_hash,
 }
 
 void grpc_rb_channel_args_destroy(grpc_channel_args* args) {
-  GPR_ASSERT(args != NULL);
+  GRPC_RUBY_ASSERT(args != NULL);
   if (args->args == NULL) return;
   for (int i = 0; i < args->num_args; i++) {
     // the key was created with gpr_strdup

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

@@ -26,6 +26,7 @@
 #include "rb_grpc.h"
 #include "rb_grpc_imports.generated.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>

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

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

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

@@ -29,8 +29,14 @@ void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq);
  * Makes the implementation of CompletionQueue#pluck available in other files
  *
  * This avoids having code that holds the GIL repeated at multiple sites.
+ *
+ * unblock_func is invoked with the provided argument to unblock the CQ
+ * operation in the event of process termination (e.g. a signal), but
+ * unblock_func may be NULL in which case it's unused.
  */
 grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
-                                     gpr_timespec deadline, void* reserved);
+                                     gpr_timespec deadline,
+                                     void (*unblock_func)(void* param),
+                                     void* unblock_func_arg);
 
 #endif /* GRPC_RB_COMPLETION_QUEUE_H_ */

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

@@ -181,9 +181,9 @@ void grpc_rb_compression_options_algorithm_name_to_value_internal(
     char* name_slice_str = grpc_slice_to_c_string(name_slice);
     char* error_message_str = NULL;
     VALUE error_message_ruby_str = Qnil;
-    GPR_ASSERT(gpr_asprintf(&error_message_str,
-                            "Invalid compression algorithm name: %s",
-                            name_slice_str) != -1);
+    GRPC_RUBY_ASSERT(gpr_asprintf(&error_message_str,
+                                  "Invalid compression algorithm name: %s",
+                                  name_slice_str) != -1);
     gpr_free(name_slice_str);
     error_message_ruby_str =
         rb_str_new(error_message_str, strlen(error_message_str));