grpc 1.60.0.pre1-aarch64-linux

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

@@ -0,0 +1,35 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_RB_CHANNEL_H_
+#define GRPC_RB_CHANNEL_H_
+
+#include <ruby/ruby.h>
+
+#include <grpc/grpc.h>
+
+/* Initializes the Channel class. */
+void Init_grpc_channel();
+
+void grpc_rb_channel_polling_thread_start();
+void grpc_rb_channel_polling_thread_stop();
+
+/* Gets the wrapped channel from the ruby wrapper */
+grpc_channel* grpc_rb_get_wrapped_channel(VALUE v);
+
+#endif /* GRPC_RB_CHANNEL_H_ */

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

@@ -0,0 +1,172 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <ruby/ruby.h>
+
+#include "rb_channel_args.h"
+
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+
+static rb_data_type_t grpc_rb_channel_args_data_type = {
+    "grpc_channel_args",
+    {GRPC_RB_GC_NOT_MARKED,
+     GRPC_RB_GC_DONT_FREE,
+     GRPC_RB_MEMSIZE_UNAVAILABLE,
+     {NULL, NULL}},
+    NULL,
+    NULL,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+/* A callback the processes the hash key values in channel_args hash */
+static int grpc_rb_channel_create_in_process_add_args_hash_cb(VALUE key,
+                                                              VALUE val,
+                                                              VALUE args_obj) {
+  const char* the_key;
+  grpc_channel_args* args;
+
+  switch (TYPE(key)) {
+    case T_STRING:
+      the_key = StringValuePtr(key);
+      break;
+
+    case T_SYMBOL:
+      the_key = rb_id2name(SYM2ID(key));
+      break;
+
+    default:
+      rb_raise(rb_eTypeError, "bad chan arg: got <%s>, want <String|Symbol>",
+               rb_obj_classname(key));
+      return ST_STOP;
+  }
+
+  TypedData_Get_Struct(args_obj, grpc_channel_args,
+                       &grpc_rb_channel_args_data_type, args);
+  if (args->num_args <= 0) {
+    rb_raise(rb_eRuntimeError, "hash_cb bug: num_args is %lu for key:%s",
+             args->num_args, StringValueCStr(key));
+    return ST_STOP;
+  }
+
+  args->args[args->num_args - 1].key = (char*)the_key;
+  switch (TYPE(val)) {
+    case T_SYMBOL:
+      args->args[args->num_args - 1].type = GRPC_ARG_STRING;
+      args->args[args->num_args - 1].value.string =
+          gpr_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 =
+          gpr_strdup(StringValueCStr(val));
+      --args->num_args;
+      return ST_CONTINUE;
+
+    case T_FIXNUM:
+      args->args[args->num_args - 1].type = GRPC_ARG_INTEGER;
+      args->args[args->num_args - 1].value.integer = NUM2INT(val);
+      --args->num_args;
+      return ST_CONTINUE;
+
+    default:
+      rb_raise(rb_eTypeError, "%s: bad value: got <%s>, want <String|Fixnum>",
+               StringValueCStr(key), rb_obj_classname(val));
+      return ST_STOP;
+  }
+  rb_raise(rb_eRuntimeError, "impl bug: hash_cb reached to far while on key:%s",
+           StringValueCStr(key));
+  return ST_STOP;
+}
+
+/* channel_convert_params allows the call to
+   grpc_rb_hash_convert_to_channel_args to be made within an rb_protect
+   exception-handler.  This allows any allocated memory to be freed before
+   propagating any exception that occurs */
+typedef struct channel_convert_params {
+  VALUE src_hash;
+  grpc_channel_args* dst;
+} channel_convert_params;
+
+static VALUE grpc_rb_hash_convert_to_channel_args0(VALUE as_value) {
+  ID id_size = rb_intern("size");
+  VALUE grpc_rb_cChannelArgs = rb_define_class("TmpChannelArgs", rb_cObject);
+  rb_undef_alloc_func(grpc_rb_cChannelArgs);
+  channel_convert_params* params = (channel_convert_params*)as_value;
+  size_t num_args = 0;
+
+  if (!NIL_P(params->src_hash) && TYPE(params->src_hash) != T_HASH) {
+    rb_raise(rb_eTypeError, "bad channel args: got:<%s> want: a hash or nil",
+             rb_obj_classname(params->src_hash));
+    return Qnil;
+  }
+
+  if (TYPE(params->src_hash) == T_HASH) {
+    num_args = NUM2INT(rb_funcall(params->src_hash, id_size, 0));
+    params->dst->num_args = num_args;
+    params->dst->args = ALLOC_N(grpc_arg, num_args);
+    MEMZERO(params->dst->args, grpc_arg, num_args);
+    rb_hash_foreach(
+        params->src_hash, grpc_rb_channel_create_in_process_add_args_hash_cb,
+        TypedData_Wrap_Struct(grpc_rb_cChannelArgs,
+                              &grpc_rb_channel_args_data_type, params->dst));
+    /* reset num_args as grpc_rb_channel_create_in_process_add_args_hash_cb
+     * decrements it during has processing */
+    params->dst->num_args = num_args;
+  }
+  return Qnil;
+}
+
+void grpc_rb_hash_convert_to_channel_args(VALUE src_hash,
+                                          grpc_channel_args* dst) {
+  channel_convert_params params;
+  int status = 0;
+
+  /* Make a protected call to grpc_rb_hash_convert_channel_args */
+  params.src_hash = src_hash;
+  params.dst = dst;
+  rb_protect(grpc_rb_hash_convert_to_channel_args0, (VALUE)&params, &status);
+  if (status != 0) {
+    if (dst->args != NULL) {
+      /* Free any allocated memory before propagating the error */
+      xfree(dst->args);
+    }
+    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 gpr_strdup
+      gpr_free(args->args[i].value.string);
+    }
+  }
+  xfree(args->args);
+}

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

@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_RB_CHANNEL_ARGS_H_
+#define GRPC_RB_CHANNEL_ARGS_H_
+
+#include <ruby/ruby.h>
+
+#include <grpc/grpc.h>
+
+/* Converts a hash object containing channel args to a channel args instance.
+ *
+ * This func ALLOCs args->args.  The caller is responsible for freeing it.  If
+ * a ruby error is raised during processing of the hash values, the func takes
+ * care to deallocate any memory allocated so far, and propagate the error.
+ *
+ * @param src_hash A ruby hash
+ * @param dst the grpc_channel_args that the hash entries will be added to.
+ */
+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

@@ -0,0 +1,285 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <ruby/ruby.h>
+
+#include "rb_channel_credentials.h"
+
+#include <string.h>
+
+#include "rb_call_credentials.h"
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+/* grpc_rb_cChannelCredentials is the ruby class that proxies
+   grpc_channel_credentials. */
+static VALUE grpc_rb_cChannelCredentials = Qnil;
+
+static char* pem_root_certs = NULL;
+
+/* grpc_rb_channel_credentials wraps a grpc_channel_credentials.  It provides a
+ * mark object that is used to hold references to any objects used to create
+ * the credentials. */
+typedef struct grpc_rb_channel_credentials {
+  /* Holder of ruby objects involved in constructing the credentials */
+  VALUE mark;
+
+  /* The actual credentials */
+  grpc_channel_credentials* wrapped;
+} grpc_rb_channel_credentials;
+
+static void grpc_rb_channel_credentials_free_internal(void* p) {
+  grpc_rb_channel_credentials* wrapper = NULL;
+  if (p == NULL) {
+    return;
+  };
+  wrapper = (grpc_rb_channel_credentials*)p;
+  grpc_channel_credentials_release(wrapper->wrapped);
+  wrapper->wrapped = NULL;
+
+  xfree(p);
+}
+
+/* Destroys the credentials instances. */
+static void grpc_rb_channel_credentials_free(void* p) {
+  grpc_rb_channel_credentials_free_internal(p);
+}
+
+/* Protects the mark object from GC */
+static void grpc_rb_channel_credentials_mark(void* p) {
+  grpc_rb_channel_credentials* wrapper = NULL;
+  if (p == NULL) {
+    return;
+  }
+  wrapper = (grpc_rb_channel_credentials*)p;
+
+  if (wrapper->mark != Qnil) {
+    rb_gc_mark(wrapper->mark);
+  }
+}
+
+static rb_data_type_t grpc_rb_channel_credentials_data_type = {
+    "grpc_channel_credentials",
+    {grpc_rb_channel_credentials_mark,
+     grpc_rb_channel_credentials_free,
+     GRPC_RB_MEMSIZE_UNAVAILABLE,
+     {NULL, NULL}},
+    NULL,
+    NULL,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+/* Allocates ChannelCredential instances.
+   Provides safe initial defaults for the instance fields. */
+static VALUE grpc_rb_channel_credentials_alloc(VALUE cls) {
+  grpc_ruby_init();
+  grpc_rb_channel_credentials* wrapper = ALLOC(grpc_rb_channel_credentials);
+  wrapper->wrapped = NULL;
+  wrapper->mark = Qnil;
+  return TypedData_Wrap_Struct(cls, &grpc_rb_channel_credentials_data_type,
+                               wrapper);
+}
+
+/* Creates a wrapping object for a given channel credentials. This should only
+ * be called with grpc_channel_credentials objects that are not already
+ * associated with any Ruby object. */
+VALUE grpc_rb_wrap_channel_credentials(grpc_channel_credentials* c,
+                                       VALUE mark) {
+  VALUE rb_wrapper;
+  grpc_rb_channel_credentials* wrapper;
+  if (c == NULL) {
+    return Qnil;
+  }
+  rb_wrapper = grpc_rb_channel_credentials_alloc(grpc_rb_cChannelCredentials);
+  TypedData_Get_Struct(rb_wrapper, grpc_rb_channel_credentials,
+                       &grpc_rb_channel_credentials_data_type, wrapper);
+  wrapper->wrapped = c;
+  wrapper->mark = mark;
+  return rb_wrapper;
+}
+
+/* The attribute used on the mark object to hold the pem_root_certs. */
+static ID id_pem_root_certs;
+
+/* The attribute used on the mark object to hold the pem_private_key. */
+static ID id_pem_private_key;
+
+/* The attribute used on the mark object to hold the pem_private_key. */
+static ID id_pem_cert_chain;
+
+/*
+  call-seq:
+    creds1 = Credentials.new()
+    ...
+    creds2 = Credentials.new(pem_root_certs)
+    ...
+    creds3 = Credentials.new(pem_root_certs, pem_private_key,
+                             pem_cert_chain)
+    pem_root_certs: (optional) PEM encoding of the server root certificate
+    pem_private_key: (optional) PEM encoding of the client's private key
+    pem_cert_chain: (optional) PEM encoding of the client's cert chain
+    Initializes Credential instances. */
+static VALUE grpc_rb_channel_credentials_init(int argc, VALUE* argv,
+                                              VALUE self) {
+  VALUE pem_root_certs = Qnil;
+  VALUE pem_private_key = Qnil;
+  VALUE pem_cert_chain = Qnil;
+  grpc_rb_channel_credentials* wrapper = NULL;
+  grpc_channel_credentials* creds = NULL;
+  grpc_ssl_pem_key_cert_pair key_cert_pair;
+  const char* pem_root_certs_cstr = NULL;
+  MEMZERO(&key_cert_pair, grpc_ssl_pem_key_cert_pair, 1);
+
+  /* "03" == no mandatory arg, 3 optional */
+  rb_scan_args(argc, argv, "03", &pem_root_certs, &pem_private_key,
+               &pem_cert_chain);
+
+  TypedData_Get_Struct(self, grpc_rb_channel_credentials,
+                       &grpc_rb_channel_credentials_data_type, wrapper);
+  if (pem_root_certs != Qnil) {
+    pem_root_certs_cstr = RSTRING_PTR(pem_root_certs);
+  }
+  if (pem_private_key == Qnil && pem_cert_chain == Qnil) {
+    creds = grpc_ssl_credentials_create(pem_root_certs_cstr, NULL, NULL, NULL);
+  } else {
+    if (pem_private_key == Qnil) {
+      rb_raise(
+          rb_eRuntimeError,
+          "could not create a credentials because pem_private_key is NULL");
+    }
+    if (pem_cert_chain == Qnil) {
+      rb_raise(rb_eRuntimeError,
+               "could not create a credentials because pem_cert_chain is NULL");
+    }
+    key_cert_pair.private_key = RSTRING_PTR(pem_private_key);
+    key_cert_pair.cert_chain = RSTRING_PTR(pem_cert_chain);
+    creds = grpc_ssl_credentials_create(pem_root_certs_cstr, &key_cert_pair,
+                                        NULL, NULL);
+  }
+  if (creds == NULL) {
+    rb_raise(rb_eRuntimeError,
+             "the call to grpc_ssl_credentials_create() failed, could not "
+             "create a credentials, see "
+             "https://github.com/grpc/grpc/blob/master/TROUBLESHOOTING.md for "
+             "debugging tips");
+    return Qnil;
+  }
+  wrapper->wrapped = creds;
+
+  /* Add the input objects as hidden fields to preserve them. */
+  rb_ivar_set(self, id_pem_cert_chain, pem_cert_chain);
+  rb_ivar_set(self, id_pem_private_key, pem_private_key);
+  rb_ivar_set(self, id_pem_root_certs, pem_root_certs);
+
+  return self;
+}
+
+static VALUE grpc_rb_channel_credentials_compose(int argc, VALUE* argv,
+                                                 VALUE self) {
+  grpc_channel_credentials* creds;
+  grpc_call_credentials* other;
+  grpc_channel_credentials* prev = NULL;
+  VALUE mark;
+  if (argc == 0) {
+    return self;
+  }
+  mark = rb_ary_new();
+  rb_ary_push(mark, self);
+  creds = grpc_rb_get_wrapped_channel_credentials(self);
+  for (int i = 0; i < argc; i++) {
+    rb_ary_push(mark, argv[i]);
+    other = grpc_rb_get_wrapped_call_credentials(argv[i]);
+    creds = grpc_composite_channel_credentials_create(creds, other, NULL);
+    if (prev != NULL) {
+      grpc_channel_credentials_release(prev);
+    }
+    prev = creds;
+
+    if (creds == NULL) {
+      rb_raise(rb_eRuntimeError,
+               "Failed to compose channel and call credentials");
+    }
+  }
+  return grpc_rb_wrap_channel_credentials(creds, mark);
+}
+
+static grpc_ssl_roots_override_result get_ssl_roots_override(
+    char** pem_root_certs_ptr) {
+  *pem_root_certs_ptr = pem_root_certs;
+  if (pem_root_certs == NULL) {
+    return GRPC_SSL_ROOTS_OVERRIDE_FAIL;
+  } else {
+    return GRPC_SSL_ROOTS_OVERRIDE_OK;
+  }
+}
+
+static VALUE grpc_rb_set_default_roots_pem(VALUE self, VALUE roots) {
+  char* roots_ptr = StringValueCStr(roots);
+  size_t length = strlen(roots_ptr);
+  (void)self;
+  pem_root_certs = gpr_malloc((length + 1) * sizeof(char));
+  memcpy(pem_root_certs, roots_ptr, length + 1);
+  return Qnil;
+}
+
+void Init_grpc_channel_credentials() {
+  grpc_rb_cChannelCredentials = rb_define_class_under(
+      grpc_rb_mGrpcCore, "ChannelCredentials", rb_cObject);
+
+  /* Allocates an object managed by the ruby runtime */
+  rb_define_alloc_func(grpc_rb_cChannelCredentials,
+                       grpc_rb_channel_credentials_alloc);
+
+  /* Provides a ruby constructor and support for dup/clone. */
+  rb_define_method(grpc_rb_cChannelCredentials, "initialize",
+                   grpc_rb_channel_credentials_init, -1);
+  rb_define_method(grpc_rb_cChannelCredentials, "initialize_copy",
+                   grpc_rb_cannot_init_copy, 1);
+  rb_define_method(grpc_rb_cChannelCredentials, "compose",
+                   grpc_rb_channel_credentials_compose, -1);
+  rb_define_module_function(grpc_rb_cChannelCredentials,
+                            "set_default_roots_pem",
+                            grpc_rb_set_default_roots_pem, 1);
+
+  grpc_set_ssl_roots_override_callback(get_ssl_roots_override);
+
+  id_pem_cert_chain = rb_intern("__pem_cert_chain");
+  id_pem_private_key = rb_intern("__pem_private_key");
+  id_pem_root_certs = rb_intern("__pem_root_certs");
+}
+
+/* Gets the wrapped grpc_channel_credentials from the ruby wrapper */
+grpc_channel_credentials* grpc_rb_get_wrapped_channel_credentials(VALUE v) {
+  grpc_rb_channel_credentials* wrapper = NULL;
+  Check_TypedStruct(v, &grpc_rb_channel_credentials_data_type);
+  TypedData_Get_Struct(v, grpc_rb_channel_credentials,
+                       &grpc_rb_channel_credentials_data_type, wrapper);
+  return wrapper->wrapped;
+}
+
+/* Check if v is kind of ChannelCredentials */
+bool grpc_rb_is_channel_credentials(VALUE v) {
+  return rb_typeddata_is_kind_of(v, &grpc_rb_channel_credentials_data_type);
+}

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

@@ -0,0 +1,37 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_RB_CREDENTIALS_H_
+#define GRPC_RB_CREDENTIALS_H_
+
+#include <ruby/ruby.h>
+
+#include <stdbool.h>
+
+#include <grpc/grpc_security.h>
+
+/* Initializes the ruby ChannelCredentials class. */
+void Init_grpc_channel_credentials();
+
+/* Gets the wrapped credentials from the ruby wrapper */
+grpc_channel_credentials* grpc_rb_get_wrapped_channel_credentials(VALUE v);
+
+/* Check if v is kind of ChannelCredentials */
+bool grpc_rb_is_channel_credentials(VALUE v);
+
+#endif /* GRPC_RB_CREDENTIALS_H_ */

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

@@ -0,0 +1,101 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <ruby/ruby.h>
+
+#include "rb_completion_queue.h"
+
+#include <ruby/thread.h>
+
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
+/* Used to allow grpc_completion_queue_next call to release the GIL */
+typedef struct next_call_stack {
+  grpc_completion_queue* cq;
+  grpc_event event;
+  gpr_timespec timeout;
+  void* tag;
+  volatile int interrupted;
+} next_call_stack;
+
+/* Calls grpc_completion_queue_pluck without holding the ruby GIL */
+static void* grpc_rb_completion_queue_pluck_no_gil(void* param) {
+  next_call_stack* const next_call = (next_call_stack*)param;
+  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);
+  return NULL;
+}
+
+/* Helper function to free a completion queue. */
+void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq) {
+  /* Every function that adds an event to a queue also synchronously plucks
+     that event from the queue, and holds a reference to the Ruby object that
+     holds the queue, so we only get to this point if all of those functions
+     have completed, and the queue is empty */
+  grpc_completion_queue_shutdown(cq);
+  grpc_completion_queue_destroy(cq);
+}
+
+static void unblock_func(void* param) {
+  next_call_stack* const next_call = (next_call_stack*)param;
+  next_call->interrupted = 1;
+}
+
+/* Does the same thing as grpc_completion_queue_pluck, while properly releasing
+   the GVL and handling interrupts */
+grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
+                                     gpr_timespec deadline, void* reserved) {
+  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);
+  return next_call.event;
+}