grpc 0.6.0 → 0.6.1

data/ext/grpc/rb_credentials.h

@@ -37,10 +37,6 @@
 #include <ruby.h>
 #include <grpc/grpc_security.h>
 
-/* rb_cCredentials is the ruby class whose instances proxy
-   grpc_credentials. */
-extern VALUE rb_cCredentials;
-
 /* Initializes the ruby Credentials class. */
 void Init_grpc_credentials();
 

data/ext/grpc/rb_grpc.c

@@ -34,26 +34,27 @@
 #include "rb_grpc.h"
 
 #include <math.h>
-#include <ruby.h>
+#include <ruby/ruby.h>
+#include <ruby/vm.h>
 #include <sys/time.h>
 
 #include <grpc/grpc.h>
 #include <grpc/support/time.h>
-#include "rb_byte_buffer.h"
 #include "rb_call.h"
 #include "rb_channel.h"
 #include "rb_completion_queue.h"
-#include "rb_event.h"
-#include "rb_metadata.h"
 #include "rb_server.h"
 #include "rb_credentials.h"
 #include "rb_server_credentials.h"
 
-/* Define common vars and funcs declared in rb.h */
-const RUBY_DATA_FUNC GC_NOT_MARKED = NULL;
-const RUBY_DATA_FUNC GC_DONT_FREE = NULL;
+static VALUE grpc_rb_cTimeVal = Qnil;
 
-VALUE rb_cTimeVal = Qnil;
+static rb_data_type_t grpc_rb_timespec_data_type = {
+    "gpr_timespec",
+    {GRPC_RB_GC_NOT_MARKED, GRPC_RB_GC_DONT_FREE, GRPC_RB_MEMSIZE_UNAVAILABLE},
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY};
 
 /* Alloc func that blocks allocation of a given object by raising an
  * exception. */
@@ -99,8 +100,9 @@ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) {
 
   switch (TYPE(time)) {
     case T_DATA:
-      if (CLASS_OF(time) == rb_cTimeVal) {
-        Data_Get_Struct(time, gpr_timespec, time_const);
+      if (CLASS_OF(time) == grpc_rb_cTimeVal) {
+        TypedData_Get_Struct(time, gpr_timespec, &grpc_rb_timespec_data_type,
+                             time_const);
         t = *time_const;
       } else if (CLASS_OF(time) == rb_cTime) {
         t.tv_sec = NUM2INT(rb_funcall(time, id_tv_sec, 0));
@@ -153,37 +155,43 @@ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) {
   return t;
 }
 
-void Init_grpc_status_codes() {
+static void Init_grpc_status_codes() {
   /* Constants representing the status codes or grpc_status_code in status.h */
-  VALUE rb_mStatusCodes =
-      rb_define_module_under(rb_mGrpcCore, "StatusCodes");
-  rb_define_const(rb_mStatusCodes, "OK", INT2NUM(GRPC_STATUS_OK));
-  rb_define_const(rb_mStatusCodes, "CANCELLED", INT2NUM(GRPC_STATUS_CANCELLED));
-  rb_define_const(rb_mStatusCodes, "UNKNOWN", INT2NUM(GRPC_STATUS_UNKNOWN));
-  rb_define_const(rb_mStatusCodes, "INVALID_ARGUMENT",
+  VALUE grpc_rb_mStatusCodes =
+      rb_define_module_under(grpc_rb_mGrpcCore, "StatusCodes");
+  rb_define_const(grpc_rb_mStatusCodes, "OK", INT2NUM(GRPC_STATUS_OK));
+  rb_define_const(grpc_rb_mStatusCodes, "CANCELLED",
+                  INT2NUM(GRPC_STATUS_CANCELLED));
+  rb_define_const(grpc_rb_mStatusCodes, "UNKNOWN",
+                  INT2NUM(GRPC_STATUS_UNKNOWN));
+  rb_define_const(grpc_rb_mStatusCodes, "INVALID_ARGUMENT",
                   INT2NUM(GRPC_STATUS_INVALID_ARGUMENT));
-  rb_define_const(rb_mStatusCodes, "DEADLINE_EXCEEDED",
+  rb_define_const(grpc_rb_mStatusCodes, "DEADLINE_EXCEEDED",
                   INT2NUM(GRPC_STATUS_DEADLINE_EXCEEDED));
-  rb_define_const(rb_mStatusCodes, "NOT_FOUND", INT2NUM(GRPC_STATUS_NOT_FOUND));
-  rb_define_const(rb_mStatusCodes, "ALREADY_EXISTS",
+  rb_define_const(grpc_rb_mStatusCodes, "NOT_FOUND",
+                  INT2NUM(GRPC_STATUS_NOT_FOUND));
+  rb_define_const(grpc_rb_mStatusCodes, "ALREADY_EXISTS",
                   INT2NUM(GRPC_STATUS_ALREADY_EXISTS));
-  rb_define_const(rb_mStatusCodes, "PERMISSION_DENIED",
+  rb_define_const(grpc_rb_mStatusCodes, "PERMISSION_DENIED",
                   INT2NUM(GRPC_STATUS_PERMISSION_DENIED));
-  rb_define_const(rb_mStatusCodes, "UNAUTHENTICATED",
+  rb_define_const(grpc_rb_mStatusCodes, "UNAUTHENTICATED",
                   INT2NUM(GRPC_STATUS_UNAUTHENTICATED));
-  rb_define_const(rb_mStatusCodes, "RESOURCE_EXHAUSTED",
+  rb_define_const(grpc_rb_mStatusCodes, "RESOURCE_EXHAUSTED",
                   INT2NUM(GRPC_STATUS_RESOURCE_EXHAUSTED));
-  rb_define_const(rb_mStatusCodes, "FAILED_PRECONDITION",
+  rb_define_const(grpc_rb_mStatusCodes, "FAILED_PRECONDITION",
                   INT2NUM(GRPC_STATUS_FAILED_PRECONDITION));
-  rb_define_const(rb_mStatusCodes, "ABORTED", INT2NUM(GRPC_STATUS_ABORTED));
-  rb_define_const(rb_mStatusCodes, "OUT_OF_RANGE",
+  rb_define_const(grpc_rb_mStatusCodes, "ABORTED",
+                  INT2NUM(GRPC_STATUS_ABORTED));
+  rb_define_const(grpc_rb_mStatusCodes, "OUT_OF_RANGE",
                   INT2NUM(GRPC_STATUS_OUT_OF_RANGE));
-  rb_define_const(rb_mStatusCodes, "UNIMPLEMENTED",
+  rb_define_const(grpc_rb_mStatusCodes, "UNIMPLEMENTED",
                   INT2NUM(GRPC_STATUS_UNIMPLEMENTED));
-  rb_define_const(rb_mStatusCodes, "INTERNAL", INT2NUM(GRPC_STATUS_INTERNAL));
-  rb_define_const(rb_mStatusCodes, "UNAVAILABLE",
+  rb_define_const(grpc_rb_mStatusCodes, "INTERNAL",
+                  INT2NUM(GRPC_STATUS_INTERNAL));
+  rb_define_const(grpc_rb_mStatusCodes, "UNAVAILABLE",
                   INT2NUM(GRPC_STATUS_UNAVAILABLE));
-  rb_define_const(rb_mStatusCodes, "DATA_LOSS", INT2NUM(GRPC_STATUS_DATA_LOSS));
+  rb_define_const(grpc_rb_mStatusCodes, "DATA_LOSS",
+                  INT2NUM(GRPC_STATUS_DATA_LOSS));
 }
 
 /* id_at is the constructor method of the ruby standard Time class. */
@@ -195,42 +203,46 @@ static ID id_inspect;
 /* id_to_s is the to_s method found on various ruby objects. */
 static ID id_to_s;
 
-/* Converts `a wrapped time constant to a standard time. */
-VALUE grpc_rb_time_val_to_time(VALUE self) {
+/* Converts a wrapped time constant to a standard time. */
+static VALUE grpc_rb_time_val_to_time(VALUE self) {
   gpr_timespec *time_const = NULL;
-  Data_Get_Struct(self, gpr_timespec, time_const);
+  TypedData_Get_Struct(self, gpr_timespec, &grpc_rb_timespec_data_type,
+                       time_const);
   return rb_funcall(rb_cTime, id_at, 2, INT2NUM(time_const->tv_sec),
                     INT2NUM(time_const->tv_nsec));
 }
 
 /* Invokes inspect on the ctime version of the time val. */
-VALUE grpc_rb_time_val_inspect(VALUE self) {
+static VALUE grpc_rb_time_val_inspect(VALUE self) {
   return rb_funcall(grpc_rb_time_val_to_time(self), id_inspect, 0);
 }
 
 /* Invokes to_s on the ctime version of the time val. */
-VALUE grpc_rb_time_val_to_s(VALUE self) {
+static VALUE grpc_rb_time_val_to_s(VALUE self) {
   return rb_funcall(grpc_rb_time_val_to_time(self), id_to_s, 0);
 }
 
 /* Adds a module with constants that map to gpr's static timeval structs. */
-void Init_grpc_time_consts() {
-  VALUE rb_mTimeConsts =
-      rb_define_module_under(rb_mGrpcCore, "TimeConsts");
-  rb_cTimeVal =
-      rb_define_class_under(rb_mGrpcCore, "TimeSpec", rb_cObject);
-  rb_define_const(rb_mTimeConsts, "ZERO",
-                  Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED, GC_DONT_FREE,
-                                   (void *)&gpr_time_0));
-  rb_define_const(rb_mTimeConsts, "INFINITE_FUTURE",
-                  Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED, GC_DONT_FREE,
-                                   (void *)&gpr_inf_future));
-  rb_define_const(rb_mTimeConsts, "INFINITE_PAST",
-                  Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED, GC_DONT_FREE,
-                                   (void *)&gpr_inf_past));
-  rb_define_method(rb_cTimeVal, "to_time", grpc_rb_time_val_to_time, 0);
-  rb_define_method(rb_cTimeVal, "inspect", grpc_rb_time_val_inspect, 0);
-  rb_define_method(rb_cTimeVal, "to_s", grpc_rb_time_val_to_s, 0);
+static void Init_grpc_time_consts() {
+  VALUE grpc_rb_mTimeConsts =
+      rb_define_module_under(grpc_rb_mGrpcCore, "TimeConsts");
+  grpc_rb_cTimeVal =
+      rb_define_class_under(grpc_rb_mGrpcCore, "TimeSpec", rb_cObject);
+  rb_define_const(
+      grpc_rb_mTimeConsts, "ZERO",
+      TypedData_Wrap_Struct(grpc_rb_cTimeVal, &grpc_rb_timespec_data_type,
+                            (void *)&gpr_time_0));
+  rb_define_const(
+      grpc_rb_mTimeConsts, "INFINITE_FUTURE",
+      TypedData_Wrap_Struct(grpc_rb_cTimeVal, &grpc_rb_timespec_data_type,
+                            (void *)&gpr_inf_future));
+  rb_define_const(
+      grpc_rb_mTimeConsts, "INFINITE_PAST",
+      TypedData_Wrap_Struct(grpc_rb_cTimeVal, &grpc_rb_timespec_data_type,
+                            (void *)&gpr_inf_past));
+  rb_define_method(grpc_rb_cTimeVal, "to_time", grpc_rb_time_val_to_time, 0);
+  rb_define_method(grpc_rb_cTimeVal, "inspect", grpc_rb_time_val_inspect, 0);
+  rb_define_method(grpc_rb_cTimeVal, "to_s", grpc_rb_time_val_to_s, 0);
   id_at = rb_intern("at");
   id_inspect = rb_intern("inspect");
   id_to_s = rb_intern("to_s");
@@ -238,35 +250,42 @@ void Init_grpc_time_consts() {
   id_tv_nsec = rb_intern("tv_nsec");
 }
 
-void grpc_rb_shutdown(void *vm) { grpc_shutdown(); }
+static void grpc_rb_shutdown(ruby_vm_t *vm) { grpc_shutdown(); }
 
 /* Initialize the GRPC module structs */
 
-/* rb_sNewServerRpc is the struct that holds new server rpc details. */
-VALUE rb_sNewServerRpc = Qnil;
-/* rb_sStatus is the struct that holds status details. */
-VALUE rb_sStatus = Qnil;
+/* grpc_rb_sNewServerRpc is the struct that holds new server rpc details. */
+VALUE grpc_rb_sNewServerRpc = Qnil;
+/* grpc_rb_sStatus is the struct that holds status details. */
+VALUE grpc_rb_sStatus = Qnil;
 
 /* Initialize the GRPC module. */
-VALUE rb_mGRPC = Qnil;
-VALUE rb_mGrpcCore = Qnil;
+VALUE grpc_rb_mGRPC = Qnil;
+VALUE grpc_rb_mGrpcCore = Qnil;
+
+/* cached Symbols for members in Status struct */
+VALUE sym_code = Qundef;
+VALUE sym_details = Qundef;
+VALUE sym_metadata = Qundef;
 
 void Init_grpc() {
   grpc_init();
   ruby_vm_at_exit(grpc_rb_shutdown);
-  rb_mGRPC = rb_define_module("GRPC");
-  rb_mGrpcCore = rb_define_module_under(rb_mGRPC, "Core");
-  rb_sNewServerRpc = rb_struct_define("NewServerRpc", "method", "host",
-                                      "deadline", "metadata", NULL);
-  rb_sStatus = rb_struct_define("Status", "code", "details", "metadata", NULL);
+  grpc_rb_mGRPC = rb_define_module("GRPC");
+  grpc_rb_mGrpcCore = rb_define_module_under(grpc_rb_mGRPC, "Core");
+  grpc_rb_sNewServerRpc =
+      rb_struct_define("NewServerRpc", "method", "host",
+                       "deadline", "metadata", "call", NULL);
+  grpc_rb_sStatus =
+      rb_struct_define("Status", "code", "details", "metadata", NULL);
+  sym_code = ID2SYM(rb_intern("code"));
+  sym_details = ID2SYM(rb_intern("details"));
+  sym_metadata = ID2SYM(rb_intern("metadata"));
 
-  Init_grpc_byte_buffer();
-  Init_grpc_event();
   Init_grpc_channel();
   Init_grpc_completion_queue();
   Init_grpc_call();
   Init_grpc_credentials();
-  Init_grpc_metadata();
   Init_grpc_server();
   Init_grpc_server_credentials();
   Init_grpc_status_codes();

data/ext/grpc/rb_grpc.h

@@ -38,26 +38,36 @@
 #include <ruby.h>
 #include <grpc/support/time.h>
 
-/* rb_mGrpcCore is the module containing the ruby wrapper GRPC classes. */
-extern VALUE rb_mGrpcCore;
+/* grpc_rb_mGrpcCore is the module containing the ruby wrapper GRPC classes. */
+extern VALUE grpc_rb_mGrpcCore;
 
-/* Class used to wrap timeval structs. */
-extern VALUE rb_cTimeVal;
+/* grpc_rb_sNewServerRpc is the struct that holds new server rpc details. */
+extern VALUE grpc_rb_sNewServerRpc;
 
-/* rb_sNewServerRpc is the struct that holds new server rpc details. */
-extern VALUE rb_sNewServerRpc;
+/* grpc_rb_sStruct is the struct that holds status details. */
+extern VALUE grpc_rb_sStatus;
 
-/* rb_sStruct is the struct that holds status details. */
-extern VALUE rb_sStatus;
+/* sym_code is the symbol for the code attribute of grpc_rb_sStatus. */
+extern VALUE sym_code;
+
+/* sym_details is the symbol for the details attribute of grpc_rb_sStatus. */
+extern VALUE sym_details;
+
+/* sym_metadata is the symbol for the metadata attribute of grpc_rb_sStatus. */
+extern VALUE sym_metadata;
 
 /* GC_NOT_MARKED is used in calls to Data_Wrap_Struct to indicate that the
    wrapped struct does not need to participate in ruby gc. */
-extern const RUBY_DATA_FUNC GC_NOT_MARKED;
+#define GRPC_RB_GC_NOT_MARKED (RUBY_DATA_FUNC)(NULL)
 
 /* GC_DONT_FREED is used in calls to Data_Wrap_Struct to indicate that the
    wrapped struct should not be freed the wrapped ruby object is released by
    the garbage collector. */
-extern const RUBY_DATA_FUNC GC_DONT_FREE;
+#define GRPC_RB_GC_DONT_FREE (RUBY_DATA_FUNC)(NULL)
+
+/* GRPC_RB_MEMSIZE_UNAVAILABLE is used in rb_data_type_t to indicate that the
+ * number of bytes used by the wrapped struct is not available. */
+#define GRPC_RB_MEMSIZE_UNAVAILABLE (size_t (*)(const void*))(NULL)
 
 /* A ruby object alloc func that fails by raising an exception. */
 VALUE grpc_rb_cannot_alloc(VALUE cls);

data/ext/grpc/rb_server.c

@@ -43,8 +43,11 @@
 #include "rb_server_credentials.h"
 #include "rb_grpc.h"
 
-/* rb_cServer is the ruby class that proxies grpc_server. */
-VALUE rb_cServer = Qnil;
+/* grpc_rb_cServer is the ruby class that proxies grpc_server. */
+static VALUE grpc_rb_cServer = Qnil;
+
+/* id_at is the constructor method of the ruby standard Time class. */
+static ID id_at;
 
 /* grpc_rb_server wraps a grpc_server.  It provides a peer ruby object,
   'mark' to minimize copying when a server is created from ruby. */
@@ -85,13 +88,23 @@ static void grpc_rb_server_mark(void *p) {
   }
 }
 
+static const rb_data_type_t grpc_rb_server_data_type = {
+    "grpc_server",
+    {grpc_rb_server_mark, grpc_rb_server_free, GRPC_RB_MEMSIZE_UNAVAILABLE},
+    NULL,
+    NULL,
+    /* It is unsafe to specify RUBY_TYPED_FREE_IMMEDIATELY because the free function would block
+     * and we might want to unlock GVL
+     * TODO(yugui) Unlock GVL?
+     */
+    0};
+
 /* Allocates grpc_rb_server instances. */
 static VALUE grpc_rb_server_alloc(VALUE cls) {
   grpc_rb_server *wrapper = ALLOC(grpc_rb_server);
   wrapper->wrapped = NULL;
   wrapper->mark = Qnil;
-  return Data_Wrap_Struct(cls, grpc_rb_server_mark, grpc_rb_server_free,
-                          wrapper);
+  return TypedData_Wrap_Struct(cls, &grpc_rb_server_data_type, wrapper);
 }
 
 /*
@@ -107,7 +120,8 @@ static VALUE grpc_rb_server_init(VALUE self, VALUE cqueue, VALUE channel_args) {
   grpc_channel_args args;
   MEMZERO(&args, grpc_channel_args, 1);
   cq = grpc_rb_get_wrapped_completion_queue(cqueue);
-  Data_Get_Struct(self, grpc_rb_server, wrapper);
+  TypedData_Get_Struct(self, grpc_rb_server, &grpc_rb_server_data_type,
+                       wrapper);
   grpc_rb_hash_convert_to_channel_args(channel_args, &args);
   srv = grpc_server_create(cq, &args);
 
@@ -140,11 +154,13 @@ static VALUE grpc_rb_server_init_copy(VALUE copy, VALUE orig) {
   /* Raise an error if orig is not a server object or a subclass. */
   if (TYPE(orig) != T_DATA ||
       RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_server_free) {
-    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(rb_cServer));
+    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(grpc_rb_cServer));
   }
 
-  Data_Get_Struct(orig, grpc_rb_server, orig_srv);
-  Data_Get_Struct(copy, grpc_rb_server, copy_srv);
+  TypedData_Get_Struct(orig, grpc_rb_server, &grpc_rb_server_data_type,
+                       orig_srv);
+  TypedData_Get_Struct(copy, grpc_rb_server, &grpc_rb_server_data_type,
+                       copy_srv);
 
   /* use ruby's MEMCPY to make a byte-for-byte copy of the server wrapper
      object. */
@@ -152,25 +168,97 @@ static VALUE grpc_rb_server_init_copy(VALUE copy, VALUE orig) {
   return copy;
 }
 
-static VALUE grpc_rb_server_request_call(VALUE self, VALUE tag_new) {
-  grpc_call_error err;
+/* request_call_stack holds various values used by the
+ * grpc_rb_server_request_call function */
+typedef struct request_call_stack {
+  grpc_call_details details;
+  grpc_metadata_array md_ary;
+} request_call_stack;
+
+/* grpc_request_call_stack_init ensures the request_call_stack is properly
+ * initialized */
+static void grpc_request_call_stack_init(request_call_stack* st) {
+  MEMZERO(st, request_call_stack, 1);
+  grpc_metadata_array_init(&st->md_ary);
+  grpc_call_details_init(&st->details);
+  st->details.method = NULL;
+  st->details.host = NULL;
+}
+
+/* grpc_request_call_stack_cleanup ensures the request_call_stack is properly
+ * cleaned up */
+static void grpc_request_call_stack_cleanup(request_call_stack* st) {
+  grpc_metadata_array_destroy(&st->md_ary);
+  grpc_call_details_destroy(&st->details);
+}
+
+/* call-seq:
+   cq = CompletionQueue.new
+   tag = Object.new
+   timeout = 10
+   server.request_call(cqueue, tag, timeout)
+
+   Requests notification of a new call on a server. */
+static VALUE grpc_rb_server_request_call(VALUE self, VALUE cqueue,
+                                         VALUE tag_new, VALUE timeout) {
   grpc_rb_server *s = NULL;
-  Data_Get_Struct(self, grpc_rb_server, s);
+  grpc_call *call = NULL;
+  grpc_event *ev = NULL;
+  grpc_call_error err;
+  request_call_stack st;
+  VALUE result;
+  TypedData_Get_Struct(self, grpc_rb_server, &grpc_rb_server_data_type, s);
   if (s->wrapped == NULL) {
     rb_raise(rb_eRuntimeError, "closed!");
+    return Qnil;
   } else {
-    err = grpc_server_request_call_old(s->wrapped, ROBJECT(tag_new));
+    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,
+        grpc_rb_get_wrapped_completion_queue(cqueue),
+        ROBJECT(tag_new));
     if (err != GRPC_CALL_OK) {
-      rb_raise(rb_eCallError, "server request failed: %s (code=%d)",
+      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 = grpc_rb_completion_queue_pluck_event(cqueue, tag_new, timeout);
+    if (ev == NULL) {
+      grpc_request_call_stack_cleanup(&st);
+      return Qnil;
+    }
+    if (ev->data.op_complete != GRPC_OP_OK) {
+      grpc_request_call_stack_cleanup(&st);
+      grpc_event_finish(ev);
+      rb_raise(grpc_rb_eCallError, "request_call completion failed: (code=%d)",
+               ev->data.op_complete);
+      return Qnil;
+    }
+
+    /* build the NewServerRpc struct result */
+    result = rb_struct_new(
+        grpc_rb_sNewServerRpc,
+        rb_str_new2(st.details.method),
+        rb_str_new2(st.details.host),
+        rb_funcall(rb_cTime, id_at, 2, INT2NUM(st.details.deadline.tv_sec),
+                   INT2NUM(st.details.deadline.tv_nsec)),
+        grpc_rb_md_ary_to_h(&st.md_ary),
+        grpc_rb_wrap_call(call),
+        NULL);
+    grpc_event_finish(ev);
+    grpc_request_call_stack_cleanup(&st);
+    return result;
   }
   return Qnil;
 }
 
 static VALUE grpc_rb_server_start(VALUE self) {
   grpc_rb_server *s = NULL;
-  Data_Get_Struct(self, grpc_rb_server, s);
+  TypedData_Get_Struct(self, grpc_rb_server, &grpc_rb_server_data_type, s);
   if (s->wrapped == NULL) {
     rb_raise(rb_eRuntimeError, "closed!");
   } else {
@@ -181,7 +269,7 @@ static VALUE grpc_rb_server_start(VALUE self) {
 
 static VALUE grpc_rb_server_destroy(VALUE self) {
   grpc_rb_server *s = NULL;
-  Data_Get_Struct(self, grpc_rb_server, s);
+  TypedData_Get_Struct(self, grpc_rb_server, &grpc_rb_server_data_type, s);
   if (s->wrapped != NULL) {
     grpc_server_shutdown(s->wrapped);
     grpc_server_destroy(s->wrapped);
@@ -213,7 +301,7 @@ static VALUE grpc_rb_server_add_http2_port(int argc, VALUE *argv, VALUE self) {
   /* "11" == 1 mandatory args, 1 (rb_creds) is optional */
   rb_scan_args(argc, argv, "11", &port, &rb_creds);
 
-  Data_Get_Struct(self, grpc_rb_server, s);
+  TypedData_Get_Struct(self, grpc_rb_server, &grpc_rb_server_data_type, s);
   if (s->wrapped == NULL) {
     rb_raise(rb_eRuntimeError, "closed!");
     return Qnil;
@@ -239,27 +327,32 @@ static VALUE grpc_rb_server_add_http2_port(int argc, VALUE *argv, VALUE self) {
 }
 
 void Init_grpc_server() {
-  rb_cServer = rb_define_class_under(rb_mGrpcCore, "Server", rb_cObject);
+  grpc_rb_cServer =
+      rb_define_class_under(grpc_rb_mGrpcCore, "Server", rb_cObject);
 
   /* Allocates an object managed by the ruby runtime */
-  rb_define_alloc_func(rb_cServer, grpc_rb_server_alloc);
+  rb_define_alloc_func(grpc_rb_cServer, grpc_rb_server_alloc);
 
   /* Provides a ruby constructor and support for dup/clone. */
-  rb_define_method(rb_cServer, "initialize", grpc_rb_server_init, 2);
-  rb_define_method(rb_cServer, "initialize_copy", grpc_rb_server_init_copy, 1);
+  rb_define_method(grpc_rb_cServer, "initialize", grpc_rb_server_init, 2);
+  rb_define_method(grpc_rb_cServer, "initialize_copy",
+                   grpc_rb_server_init_copy, 1);
 
   /* Add the server methods. */
-  rb_define_method(rb_cServer, "request_call", grpc_rb_server_request_call, 1);
-  rb_define_method(rb_cServer, "start", grpc_rb_server_start, 0);
-  rb_define_method(rb_cServer, "destroy", grpc_rb_server_destroy, 0);
-  rb_define_alias(rb_cServer, "close", "destroy");
-  rb_define_method(rb_cServer, "add_http2_port", grpc_rb_server_add_http2_port,
+  rb_define_method(grpc_rb_cServer, "request_call",
+                   grpc_rb_server_request_call, 3);
+  rb_define_method(grpc_rb_cServer, "start", grpc_rb_server_start, 0);
+  rb_define_method(grpc_rb_cServer, "destroy", grpc_rb_server_destroy, 0);
+  rb_define_alias(grpc_rb_cServer, "close", "destroy");
+  rb_define_method(grpc_rb_cServer, "add_http2_port",
+                   grpc_rb_server_add_http2_port,
                    -1);
+  id_at = rb_intern("at");
 }
 
 /* Gets the wrapped server from the ruby wrapper */
 grpc_server *grpc_rb_get_wrapped_server(VALUE v) {
   grpc_rb_server *wrapper = NULL;
-  Data_Get_Struct(v, grpc_rb_server, wrapper);
+  TypedData_Get_Struct(v, grpc_rb_server, &grpc_rb_server_data_type, wrapper);
   return wrapper->wrapped;
 }