grpc 0.6.0 → 0.6.1

data/ext/grpc/rb_call.h

@@ -46,12 +46,12 @@ VALUE grpc_rb_wrap_call(grpc_call* c);
 /* Provides the details of an call error */
 const char* grpc_call_error_detail_of(grpc_call_error err);
 
-/* rb_cCall is the Call class whose instances proxy grpc_call. */
-extern VALUE rb_cCall;
+/* Converts a metadata array to a hash. */
+VALUE grpc_rb_md_ary_to_h(grpc_metadata_array *md_ary);
 
-/* rb_cCallError is the ruby class of the exception thrown during call
+/* grpc_rb_eCallError is the ruby class of the exception thrown during call
    operations. */
-extern VALUE rb_eCallError;
+extern VALUE grpc_rb_eCallError;
 
 /* Initializes the Call class. */
 void Init_grpc_call();

data/ext/grpc/rb_channel.c

@@ -49,12 +49,20 @@
 static ID id_channel;
 
 /* id_target is the name of the hidden ivar that preserves a reference to the
- * target string used to create the call, preserved so that is does not get
+ * target string used to create the call, preserved so that it does not get
  * GCed before the channel */
 static ID id_target;
 
+/* id_cqueue is the name of the hidden ivar that preserves a reference to the
+ * completion queue used to create the call, preserved so that it does not get
+ * GCed before the channel */
+static ID id_cqueue;
+
+/* grpc_rb_cChannel is the ruby class that proxies grpc_channel. */
+static VALUE grpc_rb_cChannel = Qnil;
+
 /* Used during the conversion of a hash to channel args during channel setup */
-static VALUE rb_cChannelArgs;
+static VALUE grpc_rb_cChannelArgs;
 
 /* grpc_rb_channel wraps a grpc_channel.  It provides a peer ruby object,
  * 'mark' to minimize copying when a channel is created from ruby. */
@@ -97,13 +105,19 @@ static void grpc_rb_channel_mark(void *p) {
   }
 }
 
+static rb_data_type_t grpc_channel_data_type = {
+    "grpc_channel",
+    {grpc_rb_channel_mark, grpc_rb_channel_free, GRPC_RB_MEMSIZE_UNAVAILABLE},
+    NULL, NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 /* Allocates grpc_rb_channel instances. */
 static VALUE grpc_rb_channel_alloc(VALUE cls) {
   grpc_rb_channel *wrapper = ALLOC(grpc_rb_channel);
   wrapper->wrapped = NULL;
   wrapper->mark = Qnil;
-  return Data_Wrap_Struct(cls, grpc_rb_channel_mark, grpc_rb_channel_free,
-                          wrapper);
+  return TypedData_Wrap_Struct(cls, &grpc_channel_data_type, wrapper);
 }
 
 /*
@@ -127,7 +141,7 @@ static VALUE grpc_rb_channel_init(int argc, VALUE *argv, VALUE self) {
   /* "21" == 2 mandatory args, 1 (credentials) is optional */
   rb_scan_args(argc, argv, "21", &target, &channel_args, &credentials);
 
-  Data_Get_Struct(self, grpc_rb_channel, wrapper);
+  TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
   target_chars = StringValueCStr(target);
   grpc_rb_hash_convert_to_channel_args(channel_args, &args);
   if (credentials == Qnil) {
@@ -142,6 +156,7 @@ static VALUE grpc_rb_channel_init(int argc, VALUE *argv, VALUE self) {
   if (ch == NULL) {
     rb_raise(rb_eRuntimeError, "could not create an rpc channel to target:%s",
              target_chars);
+    return Qnil;
   }
   rb_ivar_set(self, id_target, target);
   wrapper->wrapped = ch;
@@ -163,11 +178,12 @@ static VALUE grpc_rb_channel_init_copy(VALUE copy, VALUE orig) {
   /* Raise an error if orig is not a channel object or a subclass. */
   if (TYPE(orig) != T_DATA ||
       RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_channel_free) {
-    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(rb_cChannel));
+    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(grpc_rb_cChannel));
+    return Qnil;
   }
 
-  Data_Get_Struct(orig, grpc_rb_channel, orig_ch);
-  Data_Get_Struct(copy, grpc_rb_channel, copy_ch);
+  TypedData_Get_Struct(orig, grpc_rb_channel, &grpc_channel_data_type, orig_ch);
+  TypedData_Get_Struct(copy, grpc_rb_channel, &grpc_channel_data_type, copy_ch);
 
   /* use ruby's MEMCPY to make a byte-for-byte copy of the channel wrapper
    * object. */
@@ -177,34 +193,42 @@ static VALUE grpc_rb_channel_init_copy(VALUE copy, VALUE orig) {
 
 /* Create a call given a grpc_channel, in order to call method. The request
    is not sent until grpc_call_invoke is called. */
-static VALUE grpc_rb_channel_create_call(VALUE self, VALUE method, VALUE host,
-                                         VALUE deadline) {
+static VALUE grpc_rb_channel_create_call(VALUE self, VALUE cqueue, VALUE method,
+                                         VALUE host, VALUE deadline) {
   VALUE res = Qnil;
   grpc_rb_channel *wrapper = NULL;
-  grpc_channel *ch = NULL;
   grpc_call *call = NULL;
+  grpc_channel *ch = NULL;
+  grpc_completion_queue *cq = NULL;
   char *method_chars = StringValueCStr(method);
   char *host_chars = StringValueCStr(host);
 
-  Data_Get_Struct(self, grpc_rb_channel, wrapper);
+  cq = grpc_rb_get_wrapped_completion_queue(cqueue);
+  TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
   ch = wrapper->wrapped;
   if (ch == NULL) {
     rb_raise(rb_eRuntimeError, "closed!");
+    return Qnil;
   }
 
   call =
-      grpc_channel_create_call_old(ch, method_chars, host_chars,
-                                   grpc_rb_time_timeval(deadline,
-                                                        /* absolute time */ 0));
+      grpc_channel_create_call(ch, cq, method_chars, host_chars,
+                               grpc_rb_time_timeval(deadline,
+                                                    /* absolute time */ 0));
   if (call == NULL) {
     rb_raise(rb_eRuntimeError, "cannot create call with method %s",
              method_chars);
+    return Qnil;
   }
   res = grpc_rb_wrap_call(call);
 
-  /* Make this channel an instance attribute of the call so that is is not GCed
+  /* Make this channel an instance attribute of the call so that it is not GCed
    * before the call. */
   rb_ivar_set(res, id_channel, self);
+
+  /* Make the completion queue an instance attribute of the call so that it is
+   * not GCed before the call. */
+  rb_ivar_set(res, id_cqueue, cqueue);
   return res;
 }
 
@@ -213,7 +237,7 @@ static VALUE grpc_rb_channel_destroy(VALUE self) {
   grpc_rb_channel *wrapper = NULL;
   grpc_channel *ch = NULL;
 
-  Data_Get_Struct(self, grpc_rb_channel, wrapper);
+  TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
   ch = wrapper->wrapped;
   if (ch != NULL) {
     grpc_channel_destroy(ch);
@@ -224,41 +248,41 @@ static VALUE grpc_rb_channel_destroy(VALUE self) {
   return Qnil;
 }
 
-/* rb_cChannel is the ruby class that proxies grpc_channel. */
-VALUE rb_cChannel = Qnil;
-
 void Init_grpc_channel() {
-  rb_cChannelArgs = rb_define_class("TmpChannelArgs", rb_cObject);
-  rb_cChannel = rb_define_class_under(rb_mGrpcCore, "Channel", rb_cObject);
+  grpc_rb_cChannelArgs = rb_define_class("TmpChannelArgs", rb_cObject);
+  grpc_rb_cChannel =
+      rb_define_class_under(grpc_rb_mGrpcCore, "Channel", rb_cObject);
 
   /* Allocates an object managed by the ruby runtime */
-  rb_define_alloc_func(rb_cChannel, grpc_rb_channel_alloc);
+  rb_define_alloc_func(grpc_rb_cChannel, grpc_rb_channel_alloc);
 
   /* Provides a ruby constructor and support for dup/clone. */
-  rb_define_method(rb_cChannel, "initialize", grpc_rb_channel_init, -1);
-  rb_define_method(rb_cChannel, "initialize_copy", grpc_rb_channel_init_copy,
-                   1);
+  rb_define_method(grpc_rb_cChannel, "initialize", grpc_rb_channel_init, -1);
+  rb_define_method(grpc_rb_cChannel, "initialize_copy",
+                   grpc_rb_channel_init_copy, 1);
 
   /* Add ruby analogues of the Channel methods. */
-  rb_define_method(rb_cChannel, "create_call", grpc_rb_channel_create_call, 3);
-  rb_define_method(rb_cChannel, "destroy", grpc_rb_channel_destroy, 0);
-  rb_define_alias(rb_cChannel, "close", "destroy");
+  rb_define_method(grpc_rb_cChannel, "create_call",
+                   grpc_rb_channel_create_call, 4);
+  rb_define_method(grpc_rb_cChannel, "destroy", grpc_rb_channel_destroy, 0);
+  rb_define_alias(grpc_rb_cChannel, "close", "destroy");
 
   id_channel = rb_intern("__channel");
+  id_cqueue = rb_intern("__cqueue");
   id_target = rb_intern("__target");
-  rb_define_const(rb_cChannel, "SSL_TARGET",
+  rb_define_const(grpc_rb_cChannel, "SSL_TARGET",
                   ID2SYM(rb_intern(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)));
-  rb_define_const(rb_cChannel, "ENABLE_CENSUS",
+  rb_define_const(grpc_rb_cChannel, "ENABLE_CENSUS",
                   ID2SYM(rb_intern(GRPC_ARG_ENABLE_CENSUS)));
-  rb_define_const(rb_cChannel, "MAX_CONCURRENT_STREAMS",
+  rb_define_const(grpc_rb_cChannel, "MAX_CONCURRENT_STREAMS",
                   ID2SYM(rb_intern(GRPC_ARG_MAX_CONCURRENT_STREAMS)));
-  rb_define_const(rb_cChannel, "MAX_MESSAGE_LENGTH",
+  rb_define_const(grpc_rb_cChannel, "MAX_MESSAGE_LENGTH",
                   ID2SYM(rb_intern(GRPC_ARG_MAX_MESSAGE_LENGTH)));
 }
 
 /* Gets the wrapped channel from the ruby wrapper */
 grpc_channel *grpc_rb_get_wrapped_channel(VALUE v) {
   grpc_rb_channel *wrapper = NULL;
-  Data_Get_Struct(v, grpc_rb_channel, wrapper);
+  TypedData_Get_Struct(v, grpc_rb_channel, &grpc_channel_data_type, wrapper);
   return wrapper->wrapped;
 }

data/ext/grpc/rb_channel.h

@@ -37,9 +37,6 @@
 #include <ruby.h>
 #include <grpc/grpc.h>
 
-/* rb_cChannel is the Channel class whose instances proxy grpc_channel. */
-extern VALUE rb_cChannel;
-
 /* Initializes the Channel class. */
 void Init_grpc_channel();
 

data/ext/grpc/rb_channel_args.c

@@ -38,6 +38,13 @@
 
 #include "rb_grpc.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,
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 /* 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,
@@ -60,7 +67,8 @@ static int grpc_rb_channel_create_in_process_add_args_hash_cb(VALUE key,
       return ST_STOP;
   }
 
-  Data_Get_Struct(args_obj, grpc_channel_args, args);
+  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));
@@ -109,7 +117,7 @@ typedef struct channel_convert_params {
 
 static VALUE grpc_rb_hash_convert_to_channel_args0(VALUE as_value) {
   ID id_size = rb_intern("size");
-  VALUE rb_cChannelArgs = rb_define_class("TmpChannelArgs", rb_cObject);
+  VALUE grpc_rb_cChannelArgs = rb_define_class("TmpChannelArgs", rb_cObject);
   channel_convert_params* params = (channel_convert_params*)as_value;
   size_t num_args = 0;
 
@@ -126,8 +134,9 @@ static VALUE grpc_rb_hash_convert_to_channel_args0(VALUE as_value) {
     MEMZERO(params->dst->args, grpc_arg, num_args);
     rb_hash_foreach(params->src_hash,
                     grpc_rb_channel_create_in_process_add_args_hash_cb,
-                    Data_Wrap_Struct(rb_cChannelArgs, GC_NOT_MARKED,
-                                     GC_DONT_FREE, params->dst));
+                    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;

data/ext/grpc/rb_completion_queue.c

@@ -33,12 +33,16 @@
 
 #include "rb_completion_queue.h"
 
-#include <ruby.h>
+#include <ruby/ruby.h>
+#include <ruby/thread.h>
 
 #include <grpc/grpc.h>
 #include <grpc/support/time.h>
 #include "rb_grpc.h"
-#include "rb_event.h"
+
+/* grpc_rb_cCompletionQueue is the ruby class that proxies
+ * grpc_completion_queue. */
+static VALUE grpc_rb_cCompletionQueue = Qnil;
 
 /* Used to allow grpc_completion_queue_next call to release the GIL */
 typedef struct next_call_stack {
@@ -49,14 +53,16 @@ typedef struct next_call_stack {
 } next_call_stack;
 
 /* Calls grpc_completion_queue_next without holding the ruby GIL */
-static void *grpc_rb_completion_queue_next_no_gil(next_call_stack *next_call) {
+static void *grpc_rb_completion_queue_next_no_gil(void *param) {
+  next_call_stack *const next_call = (next_call_stack*)param;
   next_call->event =
       grpc_completion_queue_next(next_call->cq, next_call->timeout);
   return NULL;
 }
 
 /* Calls grpc_completion_queue_pluck without holding the ruby GIL */
-static void *grpc_rb_completion_queue_pluck_no_gil(next_call_stack *next_call) {
+static void *grpc_rb_completion_queue_pluck_no_gil(void *param) {
+  next_call_stack *const next_call = (next_call_stack*)param;
   next_call->event = grpc_completion_queue_pluck(next_call->cq, next_call->tag,
                                                  next_call->timeout);
   return NULL;
@@ -113,21 +119,31 @@ static void grpc_rb_completion_queue_destroy(void *p) {
   grpc_completion_queue_destroy(cq);
 }
 
+static rb_data_type_t grpc_rb_completion_queue_data_type = {
+    "grpc_completion_queue",
+    {GRPC_RB_GC_NOT_MARKED, grpc_rb_completion_queue_destroy,
+     GRPC_RB_MEMSIZE_UNAVAILABLE},
+    NULL, NULL,
+    /* cannot immediately free because grpc_rb_completion_queue_shutdown_drain
+     * calls rb_thread_call_without_gvl. */
+    0
+};
+
 /* Allocates a completion queue. */
 static VALUE grpc_rb_completion_queue_alloc(VALUE cls) {
   grpc_completion_queue *cq = grpc_completion_queue_create();
   if (cq == NULL) {
     rb_raise(rb_eArgError, "could not create a completion queue: not sure why");
   }
-  return Data_Wrap_Struct(cls, GC_NOT_MARKED, grpc_rb_completion_queue_destroy,
-                          cq);
+  return TypedData_Wrap_Struct(cls, &grpc_rb_completion_queue_data_type, cq);
 }
 
 /* Blocks until the next event is available, and returns the event. */
 static VALUE grpc_rb_completion_queue_next(VALUE self, VALUE timeout) {
   next_call_stack next_call;
   MEMZERO(&next_call, next_call_stack, 1);
-  Data_Get_Struct(self, grpc_completion_queue, next_call.cq);
+  TypedData_Get_Struct(self, grpc_completion_queue,
+                       &grpc_rb_completion_queue_data_type, next_call.cq);
   next_call.timeout = grpc_rb_time_timeval(timeout, /* absolute time*/ 0);
   next_call.event = NULL;
   rb_thread_call_without_gvl(grpc_rb_completion_queue_next_no_gil,
@@ -140,46 +156,57 @@ static VALUE grpc_rb_completion_queue_next(VALUE self, VALUE timeout) {
 
 /* Blocks until the next event for given tag is available, and returns the
  * event. */
-static VALUE grpc_rb_completion_queue_pluck(VALUE self, VALUE tag,
-                                            VALUE timeout) {
+VALUE grpc_rb_completion_queue_pluck(VALUE self, VALUE tag,
+                                     VALUE timeout) {
+  grpc_event *ev = grpc_rb_completion_queue_pluck_event(self, tag, timeout);
+  if (ev == NULL) {
+    return Qnil;
+  }
+  return grpc_rb_new_event(ev);
+}
+
+/* Blocks until the next event for given tag is available, and returns the
+ * event. */
+grpc_event* grpc_rb_completion_queue_pluck_event(VALUE self, VALUE tag,
+                                                 VALUE timeout) {
   next_call_stack next_call;
   MEMZERO(&next_call, next_call_stack, 1);
-  Data_Get_Struct(self, grpc_completion_queue, next_call.cq);
+  TypedData_Get_Struct(self, grpc_completion_queue,
+                       &grpc_rb_completion_queue_data_type, next_call.cq);
   next_call.timeout = grpc_rb_time_timeval(timeout, /* absolute time*/ 0);
   next_call.tag = ROBJECT(tag);
   next_call.event = NULL;
   rb_thread_call_without_gvl(grpc_rb_completion_queue_pluck_no_gil,
                              (void *)&next_call, NULL, NULL);
   if (next_call.event == NULL) {
-    return Qnil;
+    return NULL;
   }
-  return grpc_rb_new_event(next_call.event);
+  return next_call.event;
 }
 
-/* rb_cCompletionQueue is the ruby class that proxies grpc_completion_queue. */
-VALUE rb_cCompletionQueue = Qnil;
-
 void Init_grpc_completion_queue() {
-  rb_cCompletionQueue =
-      rb_define_class_under(rb_mGrpcCore, "CompletionQueue", rb_cObject);
+  grpc_rb_cCompletionQueue =
+      rb_define_class_under(grpc_rb_mGrpcCore, "CompletionQueue", rb_cObject);
 
   /* constructor: uses an alloc func without an initializer. Using a simple
      alloc func works here as the grpc header does not specify any args for
      this func, so no separate initialization step is necessary. */
-  rb_define_alloc_func(rb_cCompletionQueue, grpc_rb_completion_queue_alloc);
+  rb_define_alloc_func(grpc_rb_cCompletionQueue,
+                       grpc_rb_completion_queue_alloc);
 
   /* Add the next method that waits for the next event. */
-  rb_define_method(rb_cCompletionQueue, "next", grpc_rb_completion_queue_next,
-                   1);
+  rb_define_method(grpc_rb_cCompletionQueue, "next",
+                   grpc_rb_completion_queue_next, 1);
 
   /* Add the pluck method that waits for the next event of given tag */
-  rb_define_method(rb_cCompletionQueue, "pluck", grpc_rb_completion_queue_pluck,
-                   2);
+  rb_define_method(grpc_rb_cCompletionQueue, "pluck",
+                   grpc_rb_completion_queue_pluck, 2);
 }
 
 /* Gets the wrapped completion queue from the ruby wrapper */
 grpc_completion_queue *grpc_rb_get_wrapped_completion_queue(VALUE v) {
   grpc_completion_queue *cq = NULL;
-  Data_Get_Struct(v, grpc_completion_queue, cq);
+  TypedData_Get_Struct(v, grpc_completion_queue,
+                       &grpc_rb_completion_queue_data_type, cq);
   return cq;
 }

data/ext/grpc/rb_completion_queue.h

@@ -40,9 +40,13 @@
 /* Gets the wrapped completion queue from the ruby wrapper */
 grpc_completion_queue *grpc_rb_get_wrapped_completion_queue(VALUE v);
 
-/* rb_cCompletionQueue is the CompletionQueue class whose instances proxy
-   grpc_completion_queue. */
-extern VALUE rb_cCompletionQueue;
+/**
+ * Makes the implementation of CompletionQueue#pluck available in other files
+ *
+ * This avoids having code that holds the GIL repeated at multiple sites.
+ */
+grpc_event* grpc_rb_completion_queue_pluck_event(VALUE cqueue, VALUE tag,
+                                                 VALUE timeout);
 
 /* Initializes the CompletionQueue class. */
 void Init_grpc_completion_queue();

data/ext/grpc/rb_credentials.c

@@ -40,6 +40,9 @@
 
 #include "rb_grpc.h"
 
+/* grpc_rb_cCredentials is the ruby class that proxies grpc_credentials. */
+static VALUE grpc_rb_cCredentials = Qnil;
+
 /* grpc_rb_credentials wraps a grpc_credentials.  It provides a
  * peer ruby object, 'mark' to minimize copying when a credential is
  * created from ruby. */
@@ -83,14 +86,21 @@ static void grpc_rb_credentials_mark(void *p) {
   }
 }
 
+static rb_data_type_t grpc_rb_credentials_data_type = {
+    "grpc_credentials",
+    {grpc_rb_credentials_mark, grpc_rb_credentials_free,
+     GRPC_RB_MEMSIZE_UNAVAILABLE},
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY};
+
 /* Allocates Credential instances.
    Provides safe initial defaults for the instance fields. */
 static VALUE grpc_rb_credentials_alloc(VALUE cls) {
   grpc_rb_credentials *wrapper = ALLOC(grpc_rb_credentials);
   wrapper->wrapped = NULL;
   wrapper->mark = Qnil;
-  return Data_Wrap_Struct(cls, grpc_rb_credentials_mark,
-                          grpc_rb_credentials_free, wrapper);
+  return TypedData_Wrap_Struct(cls, &grpc_rb_credentials_data_type, wrapper);
 }
 
 /* Clones Credentials instances.
@@ -107,11 +117,13 @@ static VALUE grpc_rb_credentials_init_copy(VALUE copy, VALUE orig) {
   /* Raise an error if orig is not a credentials object or a subclass. */
   if (TYPE(orig) != T_DATA ||
       RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_credentials_free) {
-    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(rb_cCredentials));
+    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(grpc_rb_cCredentials));
   }
 
-  Data_Get_Struct(orig, grpc_rb_credentials, orig_cred);
-  Data_Get_Struct(copy, grpc_rb_credentials, copy_cred);
+  TypedData_Get_Struct(orig, grpc_rb_credentials,
+                       &grpc_rb_credentials_data_type, orig_cred);
+  TypedData_Get_Struct(copy, grpc_rb_credentials,
+                       &grpc_rb_credentials_data_type, copy_cred);
 
   /* use ruby's MEMCPY to make a byte-for-byte copy of the credentials
    * wrapper object. */
@@ -133,8 +145,7 @@ static VALUE grpc_rb_default_credentials_create(VALUE cls) {
   }
 
   wrapper->mark = Qnil;
-  return Data_Wrap_Struct(cls, grpc_rb_credentials_mark,
-                          grpc_rb_credentials_free, wrapper);
+  return TypedData_Wrap_Struct(cls, &grpc_rb_credentials_data_type, wrapper);
 }
 
 /*
@@ -151,8 +162,7 @@ static VALUE grpc_rb_compute_engine_credentials_create(VALUE cls) {
   }
 
   wrapper->mark = Qnil;
-  return Data_Wrap_Struct(cls, grpc_rb_credentials_mark,
-                          grpc_rb_credentials_free, wrapper);
+  return TypedData_Wrap_Struct(cls, &grpc_rb_credentials_data_type, wrapper);
 }
 
 /*
@@ -166,8 +176,10 @@ static VALUE grpc_rb_composite_credentials_create(VALUE self, VALUE other) {
   grpc_rb_credentials *other_wrapper = NULL;
   grpc_rb_credentials *wrapper = NULL;
 
-  Data_Get_Struct(self, grpc_rb_credentials, self_wrapper);
-  Data_Get_Struct(other, grpc_rb_credentials, other_wrapper);
+  TypedData_Get_Struct(self, grpc_rb_credentials,
+                       &grpc_rb_credentials_data_type, self_wrapper);
+  TypedData_Get_Struct(other, grpc_rb_credentials,
+                       &grpc_rb_credentials_data_type, other_wrapper);
   wrapper = ALLOC(grpc_rb_credentials);
   wrapper->wrapped = grpc_composite_credentials_create(self_wrapper->wrapped,
                                                        other_wrapper->wrapped);
@@ -178,8 +190,8 @@ static VALUE grpc_rb_composite_credentials_create(VALUE self, VALUE other) {
   }
 
   wrapper->mark = Qnil;
-  return Data_Wrap_Struct(rb_cCredentials, grpc_rb_credentials_mark,
-                          grpc_rb_credentials_free, wrapper);
+  return TypedData_Wrap_Struct(grpc_rb_cCredentials,
+                               &grpc_rb_credentials_data_type, wrapper);
 }
 
 /* The attribute used on the mark object to hold the pem_root_certs. */
@@ -214,7 +226,8 @@ static VALUE grpc_rb_credentials_init(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "12", &pem_root_certs, &pem_private_key,
                &pem_cert_chain);
 
-  Data_Get_Struct(self, grpc_rb_credentials, wrapper);
+  TypedData_Get_Struct(self, grpc_rb_credentials,
+                       &grpc_rb_credentials_data_type, wrapper);
   if (pem_root_certs == Qnil) {
     rb_raise(rb_eRuntimeError,
              "could not create a credential: nil pem_root_certs");
@@ -225,8 +238,8 @@ static VALUE grpc_rb_credentials_init(int argc, VALUE *argv, VALUE self) {
   } else {
     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(
-        RSTRING_PTR(pem_root_certs), &key_cert_pair);
+    creds = grpc_ssl_credentials_create(RSTRING_PTR(pem_root_certs),
+                                        &key_cert_pair);
   }
   if (creds == NULL) {
     rb_raise(rb_eRuntimeError, "could not create a credentials, not sure why");
@@ -242,30 +255,28 @@ static VALUE grpc_rb_credentials_init(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
-/* rb_cCredentials is the ruby class that proxies grpc_credentials. */
-VALUE rb_cCredentials = Qnil;
-
 void Init_grpc_credentials() {
-  rb_cCredentials =
-      rb_define_class_under(rb_mGrpcCore, "Credentials", rb_cObject);
+  grpc_rb_cCredentials =
+      rb_define_class_under(grpc_rb_mGrpcCore, "Credentials", rb_cObject);
 
   /* Allocates an object managed by the ruby runtime */
-  rb_define_alloc_func(rb_cCredentials, grpc_rb_credentials_alloc);
+  rb_define_alloc_func(grpc_rb_cCredentials, grpc_rb_credentials_alloc);
 
   /* Provides a ruby constructor and support for dup/clone. */
-  rb_define_method(rb_cCredentials, "initialize", grpc_rb_credentials_init, -1);
-  rb_define_method(rb_cCredentials, "initialize_copy",
+  rb_define_method(grpc_rb_cCredentials, "initialize", grpc_rb_credentials_init,
+                   -1);
+  rb_define_method(grpc_rb_cCredentials, "initialize_copy",
                    grpc_rb_credentials_init_copy, 1);
 
   /* Provide static funcs that create new special instances. */
-  rb_define_singleton_method(rb_cCredentials, "default",
+  rb_define_singleton_method(grpc_rb_cCredentials, "default",
                              grpc_rb_default_credentials_create, 0);
 
-  rb_define_singleton_method(rb_cCredentials, "compute_engine",
+  rb_define_singleton_method(grpc_rb_cCredentials, "compute_engine",
                              grpc_rb_compute_engine_credentials_create, 0);
 
   /* Provide other methods. */
-  rb_define_method(rb_cCredentials, "compose",
+  rb_define_method(grpc_rb_cCredentials, "compose",
                    grpc_rb_composite_credentials_create, 1);
 
   id_pem_cert_chain = rb_intern("__pem_cert_chain");
@@ -276,6 +287,7 @@ void Init_grpc_credentials() {
 /* Gets the wrapped grpc_credentials from the ruby wrapper */
 grpc_credentials *grpc_rb_get_wrapped_credentials(VALUE v) {
   grpc_rb_credentials *wrapper = NULL;
-  Data_Get_Struct(v, grpc_rb_credentials, wrapper);
+  TypedData_Get_Struct(v, grpc_rb_credentials, &grpc_rb_credentials_data_type,
+                       wrapper);
   return wrapper->wrapped;
 }