grpc 0.5.0

data/ext/grpc/rb_metadata.h

@@ -0,0 +1,53 @@
+/*
+ *
+ * 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_METADATA_H_
+#define GRPC_RB_METADATA_H_
+
+#include <grpc/grpc.h>
+#include <ruby.h>
+
+/* rb_cMetadata is the Metadata class whose instances proxy grpc_metadata. */
+extern VALUE rb_cMetadata;
+
+/* grpc_rb_metadata_create_with_mark creates a grpc_rb_metadata with a ruby mark
+ * object that will be kept alive while the metadata is alive. */
+extern VALUE grpc_rb_metadata_create_with_mark(VALUE mark, grpc_metadata* md);
+
+/* Gets the wrapped metadata from the ruby wrapper */
+grpc_metadata* grpc_rb_get_wrapped_metadata(VALUE v);
+
+/* Initializes the Metadata class. */
+void Init_grpc_metadata();
+
+#endif /* GRPC_RB_METADATA_H_ */

data/ext/grpc/rb_server.c

@@ -0,0 +1,278 @@
+/*
+ *
+ * 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_server.h"
+
+#include <ruby.h>
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include "rb_call.h"
+#include "rb_channel_args.h"
+#include "rb_completion_queue.h"
+#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_server wraps a grpc_server.  It provides a peer ruby object,
+  'mark' to minimize copying when a server is created from ruby. */
+typedef struct grpc_rb_server {
+  /* Holder of ruby objects involved in constructing the server */
+  VALUE mark;
+  /* The actual server */
+  grpc_server *wrapped;
+} grpc_rb_server;
+
+/* Destroys server instances. */
+static void grpc_rb_server_free(void *p) {
+  grpc_rb_server *svr = NULL;
+  if (p == NULL) {
+    return;
+  };
+  svr = (grpc_rb_server *)p;
+
+  /* Deletes the wrapped object if the mark object is Qnil, which indicates
+     that no other object is the actual owner. */
+  if (svr->wrapped != NULL && svr->mark == Qnil) {
+    grpc_server_shutdown(svr->wrapped);
+    grpc_server_destroy(svr->wrapped);
+  }
+
+  xfree(p);
+}
+
+/* Protects the mark object from GC */
+static void grpc_rb_server_mark(void *p) {
+  grpc_rb_server *server = NULL;
+  if (p == NULL) {
+    return;
+  }
+  server = (grpc_rb_server *)p;
+  if (server->mark != Qnil) {
+    rb_gc_mark(server->mark);
+  }
+}
+
+/* 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);
+}
+
+/*
+  call-seq:
+    cq = CompletionQueue.new
+    insecure_server = Server.new(cq, {'arg1': 'value1'})
+    server_creds = ...
+    secure_server = Server.new(cq, {'arg1': 'value1'}, server_creds)
+
+  Initializes server instances. */
+static VALUE grpc_rb_server_init(int argc, VALUE *argv, VALUE self) {
+  VALUE cqueue = Qnil;
+  VALUE credentials = Qnil;
+  VALUE channel_args = Qnil;
+  grpc_completion_queue *cq = NULL;
+  grpc_server_credentials *creds = NULL;
+  grpc_rb_server *wrapper = NULL;
+  grpc_server *srv = NULL;
+  grpc_channel_args args;
+  MEMZERO(&args, grpc_channel_args, 1);
+
+  /* "21" == 2 mandatory args, 1 (credentials) is optional */
+  rb_scan_args(argc, argv, "21", &cqueue, &channel_args, &credentials);
+  cq = grpc_rb_get_wrapped_completion_queue(cqueue);
+
+  Data_Get_Struct(self, grpc_rb_server, wrapper);
+  grpc_rb_hash_convert_to_channel_args(channel_args, &args);
+  srv = grpc_server_create(cq, &args);
+  if (credentials == Qnil) {
+    srv = grpc_server_create(cq, &args);
+  } else {
+    creds = grpc_rb_get_wrapped_server_credentials(credentials);
+    srv = grpc_secure_server_create(creds, cq, &args);
+  }
+
+  if (args.args != NULL) {
+    xfree(args.args); /* Allocated by grpc_rb_hash_convert_to_channel_args */
+  }
+  if (srv == NULL) {
+    rb_raise(rb_eRuntimeError, "could not create a gRPC server, not sure why");
+  }
+  wrapper->wrapped = srv;
+
+  /* Add the cq as the server's mark object. This ensures the ruby cq can't be
+     GCed before the server */
+  wrapper->mark = cqueue;
+  return self;
+}
+
+/* Clones Server instances.
+
+   Gives Server a consistent implementation of Ruby's object copy/dup
+   protocol. */
+static VALUE grpc_rb_server_init_copy(VALUE copy, VALUE orig) {
+  grpc_rb_server *orig_srv = NULL;
+  grpc_rb_server *copy_srv = NULL;
+
+  if (copy == orig) {
+    return copy;
+  }
+
+  /* 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));
+  }
+
+  Data_Get_Struct(orig, grpc_rb_server, orig_srv);
+  Data_Get_Struct(copy, grpc_rb_server, copy_srv);
+
+  /* use ruby's MEMCPY to make a byte-for-byte copy of the server wrapper
+     object. */
+  MEMCPY(copy_srv, orig_srv, grpc_rb_server, 1);
+  return copy;
+}
+
+static VALUE grpc_rb_server_request_call(VALUE self, VALUE tag_new) {
+  grpc_call_error err;
+  grpc_rb_server *s = NULL;
+  Data_Get_Struct(self, grpc_rb_server, s);
+  if (s->wrapped == NULL) {
+    rb_raise(rb_eRuntimeError, "closed!");
+  } else {
+    err = grpc_server_request_call_old(s->wrapped, ROBJECT(tag_new));
+    if (err != GRPC_CALL_OK) {
+      rb_raise(rb_eCallError, "server request failed: %s (code=%d)",
+               grpc_call_error_detail_of(err), err);
+    }
+  }
+  return Qnil;
+}
+
+static VALUE grpc_rb_server_start(VALUE self) {
+  grpc_rb_server *s = NULL;
+  Data_Get_Struct(self, grpc_rb_server, s);
+  if (s->wrapped == NULL) {
+    rb_raise(rb_eRuntimeError, "closed!");
+  } else {
+    grpc_server_start(s->wrapped);
+  }
+  return Qnil;
+}
+
+static VALUE grpc_rb_server_destroy(VALUE self) {
+  grpc_rb_server *s = NULL;
+  Data_Get_Struct(self, grpc_rb_server, s);
+  if (s->wrapped != NULL) {
+    grpc_server_shutdown(s->wrapped);
+    grpc_server_destroy(s->wrapped);
+    s->wrapped = NULL;
+    s->mark = Qnil;
+  }
+  return Qnil;
+}
+
+/*
+  call-seq:
+    // insecure port
+    insecure_server = Server.new(cq, {'arg1': 'value1'})
+    insecure_server.add_http2_port('mydomain:7575')
+
+    // secure port
+    server_creds = ...
+    secure_server = Server.new(cq, {'arg1': 'value1'}, creds)
+    secure_server.add_http_port('mydomain:7575', True)
+
+    Adds a http2 port to server */
+static VALUE grpc_rb_server_add_http2_port(int argc, VALUE *argv, VALUE self) {
+  VALUE port = Qnil;
+  VALUE is_secure = Qnil;
+  grpc_rb_server *s = NULL;
+  int recvd_port = 0;
+
+  /* "11" == 1 mandatory args, 1 (is_secure) is optional */
+  rb_scan_args(argc, argv, "11", &port, &is_secure);
+
+  Data_Get_Struct(self, grpc_rb_server, s);
+  if (s->wrapped == NULL) {
+    rb_raise(rb_eRuntimeError, "closed!");
+    return Qnil;
+  } else if (is_secure == Qnil || TYPE(is_secure) != T_TRUE) {
+    recvd_port = grpc_server_add_http2_port(s->wrapped, StringValueCStr(port));
+    if (recvd_port == 0) {
+      rb_raise(rb_eRuntimeError,
+               "could not add port %s to server, not sure why",
+               StringValueCStr(port));
+    }
+  } else if (TYPE(is_secure) != T_FALSE) {
+    recvd_port =
+        grpc_server_add_secure_http2_port(s->wrapped, StringValueCStr(port));
+    if (recvd_port == 0) {
+      rb_raise(rb_eRuntimeError,
+               "could not add secure port %s to server, not sure why",
+               StringValueCStr(port));
+    }
+  }
+  return INT2NUM(recvd_port);
+}
+
+void Init_grpc_server() {
+  rb_cServer = rb_define_class_under(rb_mGrpcCore, "Server", rb_cObject);
+
+  /* Allocates an object managed by the ruby runtime */
+  rb_define_alloc_func(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, -1);
+  rb_define_method(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,
+                   -1);
+}
+
+/* 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);
+  return wrapper->wrapped;
+}

data/ext/grpc/rb_server.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_SERVER_H_
+#define GRPC_RB_SERVER_H_
+
+#include <ruby.h>
+#include <grpc/grpc.h>
+
+/* rb_cServer is the Server class whose instances proxy
+   grpc_byte_buffer. */
+extern VALUE rb_cServer;
+
+/* Initializes the Server class. */
+void Init_grpc_server();
+
+/* Gets the wrapped server from the ruby wrapper */
+grpc_server* grpc_rb_get_wrapped_server(VALUE v);
+
+#endif /* GRPC_RB_SERVER_H_ */

data/ext/grpc/rb_server_credentials.c

@@ -0,0 +1,210 @@
+/*
+ *
+ * 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_server_credentials.h"
+
+#include <ruby.h>
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+
+#include "rb_grpc.h"
+
+/* grpc_rb_server_credentials wraps a grpc_server_credentials.  It provides a
+   peer ruby object, 'mark' to minimize copying when a server credential is
+   created from ruby. */
+typedef struct grpc_rb_server_credentials {
+  /* Holder of ruby objects involved in constructing the server credentials */
+  VALUE mark;
+  /* The actual server credentials */
+  grpc_server_credentials *wrapped;
+} grpc_rb_server_credentials;
+
+/* Destroys the server credentials instances. */
+static void grpc_rb_server_credentials_free(void *p) {
+  grpc_rb_server_credentials *wrapper = NULL;
+  if (p == NULL) {
+    return;
+  };
+  wrapper = (grpc_rb_server_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_server_credentials_release(wrapper->wrapped);
+    wrapper->wrapped = NULL;
+  }
+
+  xfree(p);
+}
+
+/* Protects the mark object from GC */
+static void grpc_rb_server_credentials_mark(void *p) {
+  grpc_rb_server_credentials *wrapper = NULL;
+  if (p == NULL) {
+    return;
+  }
+  wrapper = (grpc_rb_server_credentials *)p;
+
+  /* If it's not already cleaned up, mark the mark object */
+  if (wrapper->mark != Qnil) {
+    rb_gc_mark(wrapper->mark);
+  }
+}
+
+/* Allocates ServerCredential instances.
+
+   Provides safe initial defaults for the instance fields. */
+static VALUE grpc_rb_server_credentials_alloc(VALUE cls) {
+  grpc_rb_server_credentials *wrapper = ALLOC(grpc_rb_server_credentials);
+  wrapper->wrapped = NULL;
+  wrapper->mark = Qnil;
+  return Data_Wrap_Struct(cls, grpc_rb_server_credentials_mark,
+                          grpc_rb_server_credentials_free, wrapper);
+}
+
+/* Clones ServerCredentials instances.
+
+   Gives ServerCredentials a consistent implementation of Ruby's object copy/dup
+   protocol. */
+static VALUE grpc_rb_server_credentials_init_copy(VALUE copy, VALUE orig) {
+  grpc_rb_server_credentials *orig_ch = NULL;
+  grpc_rb_server_credentials *copy_ch = NULL;
+
+  if (copy == orig) {
+    return copy;
+  }
+
+  /* Raise an error if orig is not a server_credentials object or a subclass. */
+  if (TYPE(orig) != T_DATA ||
+      RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_server_credentials_free) {
+    rb_raise(rb_eTypeError, "not a %s",
+             rb_obj_classname(rb_cServerCredentials));
+  }
+
+  Data_Get_Struct(orig, grpc_rb_server_credentials, orig_ch);
+  Data_Get_Struct(copy, grpc_rb_server_credentials, copy_ch);
+
+  /* use ruby's MEMCPY to make a byte-for-byte copy of the server_credentials
+     wrapper object. */
+  MEMCPY(copy_ch, orig_ch, grpc_rb_server_credentials, 1);
+  return copy;
+}
+
+/* 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:
+    creds = ServerCredentials.new(pem_root_certs, pem_private_key,
+                                  pem_cert_chain)
+    creds = ServerCredentials.new(nil, 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 server's private key
+    pem_cert_chain: (optional) PEM encoding of the server's cert chain
+
+    Initializes ServerCredential instances. */
+static VALUE grpc_rb_server_credentials_init(VALUE self, VALUE pem_root_certs,
+                                             VALUE pem_private_key,
+                                             VALUE pem_cert_chain) {
+  /* TODO support multiple key cert pairs in the ruby API. */
+  grpc_rb_server_credentials *wrapper = NULL;
+  grpc_server_credentials *creds = NULL;
+  grpc_ssl_pem_key_cert_pair key_cert_pair = {NULL, NULL};
+  Data_Get_Struct(self, grpc_rb_server_credentials, wrapper);
+  if (pem_cert_chain == Qnil) {
+    rb_raise(rb_eRuntimeError,
+             "could not create a server credential: nil pem_cert_chain");
+    return Qnil;
+  } else if (pem_private_key == Qnil) {
+    rb_raise(rb_eRuntimeError,
+             "could not create a server credential: nil pem_private_key");
+    return Qnil;
+  }
+  key_cert_pair.private_key = RSTRING_PTR(pem_private_key);
+  key_cert_pair.cert_chain = RSTRING_PTR(pem_cert_chain);
+  if (pem_root_certs == Qnil) {
+    creds = grpc_ssl_server_credentials_create(NULL, &key_cert_pair, 1);
+  } else {
+    creds = grpc_ssl_server_credentials_create(RSTRING_PTR(pem_root_certs),
+                                               &key_cert_pair, 1);
+  }
+  if (creds == NULL) {
+    rb_raise(rb_eRuntimeError, "could not create a credentials, not sure why");
+  }
+  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_cServerCredentials is the ruby class that proxies
+   grpc_server_credentials. */
+VALUE rb_cServerCredentials = Qnil;
+
+void Init_grpc_server_credentials() {
+  rb_cServerCredentials =
+      rb_define_class_under(rb_mGrpcCore, "ServerCredentials", rb_cObject);
+
+  /* Allocates an object managed by the ruby runtime */
+  rb_define_alloc_func(rb_cServerCredentials, grpc_rb_server_credentials_alloc);
+
+  /* Provides a ruby constructor and support for dup/clone. */
+  rb_define_method(rb_cServerCredentials, "initialize",
+                   grpc_rb_server_credentials_init, 3);
+  rb_define_method(rb_cServerCredentials, "initialize_copy",
+                   grpc_rb_server_credentials_init_copy, 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_server_credentials from the ruby wrapper */
+grpc_server_credentials *grpc_rb_get_wrapped_server_credentials(VALUE v) {
+  grpc_rb_server_credentials *wrapper = NULL;
+  Data_Get_Struct(v, grpc_rb_server_credentials, wrapper);
+  return wrapper->wrapped;
+}