grpc 0.5.0

data/ext/grpc/rb_channel_args.h

@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_RB_CHANNEL_ARGS_H_
+#define GRPC_RB_CHANNEL_ARGS_H_
+
+#include <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);
+
+#endif /* GRPC_RB_CHANNEL_ARGS_H_ */

data/ext/grpc/rb_completion_queue.c

@@ -0,0 +1,185 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "rb_completion_queue.h"
+
+#include <ruby.h>
+
+#include <grpc/grpc.h>
+#include <grpc/support/time.h>
+#include "rb_grpc.h"
+#include "rb_event.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;
+} 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) {
+  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) {
+  next_call->event = grpc_completion_queue_pluck(next_call->cq, next_call->tag,
+                                                 next_call->timeout);
+  return NULL;
+}
+
+/* Shuts down and drains the completion queue if necessary.
+ *
+ * This is done when the ruby completion queue object is about to be GCed.
+ */
+static void grpc_rb_completion_queue_shutdown_drain(grpc_completion_queue *cq) {
+  next_call_stack next_call;
+  grpc_completion_type type;
+  int drained = 0;
+  MEMZERO(&next_call, next_call_stack, 1);
+
+  grpc_completion_queue_shutdown(cq);
+  next_call.cq = cq;
+  next_call.event = NULL;
+  /* TODO: the timeout should be a module level constant that defaults
+   * to gpr_inf_future.
+   *
+   * - at the moment this does not work, it stalls.  Using a small timeout like
+   *   this one works, and leads to fast test run times; a longer timeout was
+   *   causing unnecessary delays in the test runs.
+   *
+   * - investigate further, this is probably another example of C-level cleanup
+   * not working consistently in all cases.
+   */
+  next_call.timeout = gpr_time_add(gpr_now(), gpr_time_from_micros(5e3));
+  do {
+    rb_thread_call_without_gvl(grpc_rb_completion_queue_next_no_gil,
+                               (void *)&next_call, NULL, NULL);
+    if (next_call.event == NULL) {
+      break;
+    }
+    type = next_call.event->type;
+    if (type != GRPC_QUEUE_SHUTDOWN) {
+      ++drained;
+      rb_warning("completion queue shutdown: %d undrained events", drained);
+    }
+    grpc_event_finish(next_call.event);
+    next_call.event = NULL;
+  } while (type != GRPC_QUEUE_SHUTDOWN);
+}
+
+/* Helper function to free a completion queue. */
+static void grpc_rb_completion_queue_destroy(void *p) {
+  grpc_completion_queue *cq = NULL;
+  if (p == NULL) {
+    return;
+  }
+  cq = (grpc_completion_queue *)p;
+  grpc_rb_completion_queue_shutdown_drain(cq);
+  grpc_completion_queue_destroy(cq);
+}
+
+/* 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);
+}
+
+/* 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);
+  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,
+                             (void *)&next_call, NULL, NULL);
+  if (next_call.event == NULL) {
+    return Qnil;
+  }
+  return grpc_rb_new_event(next_call.event);
+}
+
+/* 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) {
+  next_call_stack next_call;
+  MEMZERO(&next_call, next_call_stack, 1);
+  Data_Get_Struct(self, grpc_completion_queue, 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 grpc_rb_new_event(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);
+
+  /* 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);
+
+  /* Add the next method that waits for the next event. */
+  rb_define_method(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);
+}
+
+/* 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);
+  return cq;
+}

data/ext/grpc/rb_completion_queue.h

@@ -0,0 +1,50 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_RB_COMPLETION_QUEUE_H_
+#define GRPC_RB_COMPLETION_QUEUE_H_
+
+#include <grpc/grpc.h>
+#include <ruby.h>
+
+/* 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;
+
+/* Initializes the CompletionQueue class. */
+void Init_grpc_completion_queue();
+
+#endif /* GRPC_RB_COMPLETION_QUEUE_H_ */

data/ext/grpc/rb_credentials.c

@@ -0,0 +1,281 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "rb_credentials.h"
+
+#include <ruby.h>
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+
+#include "rb_grpc.h"
+
+/* grpc_rb_credentials wraps a grpc_credentials.  It provides a
+ * peer ruby object, 'mark' to minimize copying when a credential is
+ * created from ruby. */
+typedef struct grpc_rb_credentials {
+  /* Holder of ruby objects involved in constructing the credentials */
+  VALUE mark;
+
+  /* The actual credentials */
+  grpc_credentials *wrapped;
+} grpc_rb_credentials;
+
+/* Destroys the credentials instances. */
+static void grpc_rb_credentials_free(void *p) {
+  grpc_rb_credentials *wrapper = NULL;
+  if (p == NULL) {
+    return;
+  };
+  wrapper = (grpc_rb_credentials *)p;
+
+  /* Delete the wrapped object if the mark object is Qnil, which indicates that
+   * no other object is the actual owner. */
+  if (wrapper->wrapped != NULL && wrapper->mark == Qnil) {
+    grpc_credentials_release(wrapper->wrapped);
+    wrapper->wrapped = NULL;
+  }
+
+  xfree(p);
+}
+
+/* Protects the mark object from GC */
+static void grpc_rb_credentials_mark(void *p) {
+  grpc_rb_credentials *wrapper = NULL;
+  if (p == NULL) {
+    return;
+  }
+  wrapper = (grpc_rb_credentials *)p;
+
+  /* If it's not already cleaned up, mark the mark object */
+  if (wrapper->mark != Qnil) {
+    rb_gc_mark(wrapper->mark);
+  }
+}
+
+/* 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);
+}
+
+/* Clones Credentials instances.
+   Gives Credentials a consistent implementation of Ruby's object copy/dup
+   protocol. */
+static VALUE grpc_rb_credentials_init_copy(VALUE copy, VALUE orig) {
+  grpc_rb_credentials *orig_cred = NULL;
+  grpc_rb_credentials *copy_cred = NULL;
+
+  if (copy == orig) {
+    return copy;
+  }
+
+  /* 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));
+  }
+
+  Data_Get_Struct(orig, grpc_rb_credentials, orig_cred);
+  Data_Get_Struct(copy, grpc_rb_credentials, copy_cred);
+
+  /* use ruby's MEMCPY to make a byte-for-byte copy of the credentials
+   * wrapper object. */
+  MEMCPY(copy_cred, orig_cred, grpc_rb_credentials, 1);
+  return copy;
+}
+
+/*
+  call-seq:
+    creds = Credentials.default()
+    Creates the default credential instances. */
+static VALUE grpc_rb_default_credentials_create(VALUE cls) {
+  grpc_rb_credentials *wrapper = ALLOC(grpc_rb_credentials);
+  wrapper->wrapped = grpc_google_default_credentials_create();
+  if (wrapper->wrapped == NULL) {
+    rb_raise(rb_eRuntimeError,
+             "could not create default credentials, not sure why");
+    return Qnil;
+  }
+
+  wrapper->mark = Qnil;
+  return Data_Wrap_Struct(cls, grpc_rb_credentials_mark,
+                          grpc_rb_credentials_free, wrapper);
+}
+
+/*
+  call-seq:
+    creds = Credentials.compute_engine()
+    Creates the default credential instances. */
+static VALUE grpc_rb_compute_engine_credentials_create(VALUE cls) {
+  grpc_rb_credentials *wrapper = ALLOC(grpc_rb_credentials);
+  wrapper->wrapped = grpc_compute_engine_credentials_create();
+  if (wrapper->wrapped == NULL) {
+    rb_raise(rb_eRuntimeError,
+             "could not create composite engine credentials, not sure why");
+    return Qnil;
+  }
+
+  wrapper->mark = Qnil;
+  return Data_Wrap_Struct(cls, grpc_rb_credentials_mark,
+                          grpc_rb_credentials_free, wrapper);
+}
+
+/*
+  call-seq:
+    creds1 = ...
+    creds2 = ...
+    creds3 = creds1.add(creds2)
+    Creates the default credential instances. */
+static VALUE grpc_rb_composite_credentials_create(VALUE self, VALUE other) {
+  grpc_rb_credentials *self_wrapper = NULL;
+  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);
+  wrapper = ALLOC(grpc_rb_credentials);
+  wrapper->wrapped = grpc_composite_credentials_create(self_wrapper->wrapped,
+                                                       other_wrapper->wrapped);
+  if (wrapper->wrapped == NULL) {
+    rb_raise(rb_eRuntimeError,
+             "could not create composite credentials, not sure why");
+    return Qnil;
+  }
+
+  wrapper->mark = Qnil;
+  return Data_Wrap_Struct(rb_cCredentials, grpc_rb_credentials_mark,
+                          grpc_rb_credentials_free, 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(pem_root_certs)
+    ...
+    creds2 = Credentials.new(pem_root_certs, pem_private_key,
+                             pem_cert_chain)
+    pem_root_certs: (required) 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_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_credentials *wrapper = NULL;
+  grpc_credentials *creds = NULL;
+  grpc_ssl_pem_key_cert_pair key_cert_pair;
+  MEMZERO(&key_cert_pair, grpc_ssl_pem_key_cert_pair, 1);
+  /* TODO: Remove mandatory arg when we support default roots. */
+  /* "12" == 1 mandatory arg, 2 (credentials) is optional */
+  rb_scan_args(argc, argv, "12", &pem_root_certs, &pem_private_key,
+               &pem_cert_chain);
+
+  Data_Get_Struct(self, grpc_rb_credentials, wrapper);
+  if (pem_root_certs == Qnil) {
+    rb_raise(rb_eRuntimeError,
+             "could not create a credential: nil pem_root_certs");
+    return Qnil;
+  }
+  if (pem_private_key == Qnil && pem_cert_chain == Qnil) {
+    creds = grpc_ssl_credentials_create(RSTRING_PTR(pem_root_certs), NULL);
+  } 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);
+  }
+  if (creds == NULL) {
+    rb_raise(rb_eRuntimeError, "could not create a credentials, not sure why");
+    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;
+}
+
+/* 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);
+
+  /* Allocates an object managed by the ruby runtime */
+  rb_define_alloc_func(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",
+                   grpc_rb_credentials_init_copy, 1);
+
+  /* Provide static funcs that create new special instances. */
+  rb_define_singleton_method(rb_cCredentials, "default",
+                             grpc_rb_default_credentials_create, 0);
+
+  rb_define_singleton_method(rb_cCredentials, "compute_engine",
+                             grpc_rb_compute_engine_credentials_create, 0);
+
+  /* Provide other methods. */
+  rb_define_method(rb_cCredentials, "compose",
+                   grpc_rb_composite_credentials_create, 1);
+
+  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_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);
+  return wrapper->wrapped;
+}