grpc 0.5.0

data/bin/noproto_client.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+# 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.
+
+# Sample app that helps validate RpcServer without protobuf serialization.
+#
+# Usage: $ ruby -S path/to/noproto_client.rb
+
+this_dir = File.expand_path(File.dirname(__FILE__))
+lib_dir = File.join(File.dirname(this_dir), 'lib')
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'grpc'
+require 'optparse'
+
+# a simple non-protobuf message class.
+class NoProtoMsg
+  def self.marshal(_o)
+    ''
+  end
+
+  def self.unmarshal(_o)
+    NoProtoMsg.new
+  end
+end
+
+# service the uses the non-protobuf message class.
+class NoProtoService
+  include GRPC::GenericService
+  rpc :AnRPC, NoProtoMsg, NoProtoMsg
+end
+
+NoProtoStub = NoProtoService.rpc_stub_class
+
+def load_test_certs
+  this_dir = File.expand_path(File.dirname(__FILE__))
+  data_dir = File.join(File.dirname(this_dir), 'spec/testdata')
+  files = ['ca.pem', 'server1.key', 'server1.pem']
+  files.map { |f| File.open(File.join(data_dir, f)).read }
+end
+
+def test_creds
+  certs = load_test_certs
+  GRPC::Core::Credentials.new(certs[0])
+end
+
+def main
+  options = {
+    'host' => 'localhost:7071',
+    'secure' => false
+  }
+  OptionParser.new do |opts|
+    opts.banner = 'Usage: [--host <hostname>:<port>] [--secure|-s]'
+    opts.on('--host HOST', '<hostname>:<port>') do |v|
+      options['host'] = v
+    end
+    opts.on('-s', '--secure', 'access using test creds') do |v|
+      options['secure'] = v
+    end
+  end.parse!
+
+  if options['secure']
+    stub_opts = {
+      :creds => test_creds,
+      GRPC::Core::Channel::SSL_TARGET => 'foo.test.google.fr'
+    }
+    p stub_opts
+    p options['host']
+    stub = NoProtoStub.new(options['host'], **stub_opts)
+    logger.info("... connecting securely on #{options['host']}")
+  else
+    stub = NoProtoStub.new(options['host'])
+    logger.info("... connecting insecurely on #{options['host']}")
+  end
+
+  logger.info('sending a NoProto rpc')
+  resp = stub.an_rpc(NoProtoMsg.new)
+  logger.info("got a response: #{resp}")
+end
+
+main

data/bin/noproto_server.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+
+# 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.
+
+# Sample app that helps validate RpcServer without protobuf serialization.
+#
+# Usage: $ path/to/noproto_server.rb
+
+this_dir = File.expand_path(File.dirname(__FILE__))
+lib_dir = File.join(File.dirname(this_dir), 'lib')
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'grpc'
+require 'optparse'
+
+# a simple non-protobuf message class.
+class NoProtoMsg
+  def self.marshal(_o)
+    ''
+  end
+
+  def self.unmarshal(_o)
+    NoProtoMsg.new
+  end
+end
+
+# service the uses the non-protobuf message class.
+class NoProtoService
+  include GRPC::GenericService
+  rpc :AnRPC, NoProtoMsg, NoProtoMsg
+end
+
+# an implementation of the non-protobuf service.
+class NoProto < NoProtoService
+  def initialize(_default_var = 'ignored')
+  end
+
+  def an_rpc(req, _call)
+    logger.info('echo service received a request')
+    req
+  end
+end
+
+def load_test_certs
+  this_dir = File.expand_path(File.dirname(__FILE__))
+  data_dir = File.join(File.dirname(this_dir), 'spec/testdata')
+  files = ['ca.pem', 'server1.key', 'server1.pem']
+  files.map { |f| File.open(File.join(data_dir, f)).read }
+end
+
+def test_server_creds
+  certs = load_test_certs
+  GRPC::Core::ServerCredentials.new(nil, certs[1], certs[2])
+end
+
+def main
+  options = {
+    'host' => 'localhost:9090',
+    'secure' => false
+  }
+  OptionParser.new do |opts|
+    opts.banner = 'Usage: [--host <hostname>:<port>] [--secure|-s]'
+    opts.on('--host HOST', '<hostname>:<port>') do |v|
+      options['host'] = v
+    end
+    opts.on('-s', '--secure', 'access using test creds') do |v|
+      options['secure'] = v
+    end
+  end.parse!
+
+  if options['secure']
+    s = GRPC::RpcServer.new(creds: test_server_creds)
+    s.add_http2_port(options['host'], true)
+    logger.info("... running securely on #{options['host']}")
+  else
+    s = GRPC::RpcServer.new
+    s.add_http2_port(options['host'])
+    logger.info("... running insecurely on #{options['host']}")
+  end
+
+  s.handle(NoProto)
+  s.run
+end
+
+main

data/ext/grpc/extconf.rb

@@ -0,0 +1,76 @@
+# 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.
+
+require 'mkmf'
+
+LIBDIR = RbConfig::CONFIG['libdir']
+INCLUDEDIR = RbConfig::CONFIG['includedir']
+
+HEADER_DIRS = [
+  # Search /opt/local (Mac source install)
+  '/opt/local/include',
+
+  # Search /usr/local (Source install)
+  '/usr/local/include',
+
+  # Check the ruby install locations
+  INCLUDEDIR
+]
+
+LIB_DIRS = [
+  # Search /opt/local (Mac source install)
+  '/opt/local/lib',
+
+  # Search /usr/local (Source install)
+  '/usr/local/lib',
+
+  # Check the ruby install locations
+  LIBDIR
+]
+
+def crash(msg)
+  print(" extconf failure: #{msg}\n")
+  exit 1
+end
+
+dir_config('grpc', HEADER_DIRS, LIB_DIRS)
+
+$CFLAGS << ' -std=c89 '
+$CFLAGS << ' -Wno-implicit-function-declaration '
+$CFLAGS << ' -Wno-pointer-sign '
+$CFLAGS << ' -Wno-return-type '
+$CFLAGS << ' -Wall '
+$CFLAGS << ' -pedantic '
+
+$LDFLAGS << ' -lgrpc -lgpr -ldl'
+
+crash('need grpc lib') unless have_library('grpc', 'grpc_channel_destroy')
+have_library('grpc', 'grpc_channel_destroy')
+crash('need gpr lib') unless have_library('gpr', 'gpr_now')
+create_makefile('grpc/grpc')

data/ext/grpc/rb_byte_buffer.c

@@ -0,0 +1,241 @@
+/*
+ *
+ * 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_byte_buffer.h"
+
+#include <ruby.h>
+
+#include <grpc/grpc.h>
+#include <grpc/support/slice.h>
+#include "rb_grpc.h"
+
+/* grpc_rb_byte_buffer wraps a grpc_byte_buffer.  It provides a peer ruby
+ * object, 'mark' to minimize copying when a byte_buffer is created from
+ * ruby. */
+typedef struct grpc_rb_byte_buffer {
+  /* Holder of ruby objects involved in constructing the status */
+  VALUE mark;
+  /* The actual status */
+  grpc_byte_buffer *wrapped;
+} grpc_rb_byte_buffer;
+
+/* Destroys ByteBuffer instances. */
+static void grpc_rb_byte_buffer_free(void *p) {
+  grpc_rb_byte_buffer *bb = NULL;
+  if (p == NULL) {
+    return;
+  };
+  bb = (grpc_rb_byte_buffer *)p;
+
+  /* Deletes the wrapped object if the mark object is Qnil, which indicates
+   * that no other object is the actual owner. */
+  if (bb->wrapped != NULL && bb->mark == Qnil) {
+    grpc_byte_buffer_destroy(bb->wrapped);
+  }
+
+  xfree(p);
+}
+
+/* Protects the mark object from GC */
+static void grpc_rb_byte_buffer_mark(void *p) {
+  grpc_rb_byte_buffer *bb = NULL;
+  if (p == NULL) {
+    return;
+  }
+  bb = (grpc_rb_byte_buffer *)p;
+
+  /* If it's not already cleaned up, mark the mark object */
+  if (bb->mark != Qnil && BUILTIN_TYPE(bb->mark) != T_NONE) {
+    rb_gc_mark(bb->mark);
+  }
+}
+
+/* id_source is the name of the hidden ivar the preserves the original
+ * byte_buffer source string */
+static ID id_source;
+
+/* Allocates ByteBuffer instances.
+
+   Provides safe default values for the byte_buffer fields. */
+static VALUE grpc_rb_byte_buffer_alloc(VALUE cls) {
+  grpc_rb_byte_buffer *wrapper = ALLOC(grpc_rb_byte_buffer);
+  wrapper->wrapped = NULL;
+  wrapper->mark = Qnil;
+  return Data_Wrap_Struct(cls, grpc_rb_byte_buffer_mark,
+                          grpc_rb_byte_buffer_free, wrapper);
+}
+
+/* Clones ByteBuffer instances.
+
+   Gives ByteBuffer a consistent implementation of Ruby's object copy/dup
+   protocol. */
+static VALUE grpc_rb_byte_buffer_init_copy(VALUE copy, VALUE orig) {
+  grpc_rb_byte_buffer *orig_bb = NULL;
+  grpc_rb_byte_buffer *copy_bb = NULL;
+
+  if (copy == orig) {
+    return copy;
+  }
+
+  /* Raise an error if orig is not a metadata object or a subclass. */
+  if (TYPE(orig) != T_DATA ||
+      RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_byte_buffer_free) {
+    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(rb_cByteBuffer));
+  }
+
+  Data_Get_Struct(orig, grpc_rb_byte_buffer, orig_bb);
+  Data_Get_Struct(copy, grpc_rb_byte_buffer, copy_bb);
+
+  /* use ruby's MEMCPY to make a byte-for-byte copy of the metadata wrapper
+   * object. */
+  MEMCPY(copy_bb, orig_bb, grpc_rb_byte_buffer, 1);
+  return copy;
+}
+
+/* id_empty is used to return the empty string from to_s when necessary. */
+static ID id_empty;
+
+static VALUE grpc_rb_byte_buffer_to_s(VALUE self) {
+  grpc_rb_byte_buffer *wrapper = NULL;
+  grpc_byte_buffer *bb = NULL;
+  grpc_byte_buffer_reader *reader = NULL;
+  char *output = NULL;
+  size_t length = 0;
+  size_t offset = 0;
+  VALUE output_obj = Qnil;
+  gpr_slice next;
+
+  Data_Get_Struct(self, grpc_rb_byte_buffer, wrapper);
+  output_obj = rb_ivar_get(wrapper->mark, id_source);
+  if (output_obj != Qnil) {
+    /* From ruby, ByteBuffers are immutable so if a source is set, return that
+     * as the to_s value */
+    return output_obj;
+  }
+
+  /* Read the bytes. */
+  bb = wrapper->wrapped;
+  if (bb == NULL) {
+    return rb_id2str(id_empty);
+  }
+  length = grpc_byte_buffer_length(bb);
+  if (length == 0) {
+    return rb_id2str(id_empty);
+  }
+  reader = grpc_byte_buffer_reader_create(bb);
+  output = xmalloc(length);
+  while (grpc_byte_buffer_reader_next(reader, &next) != 0) {
+    memcpy(output + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
+    offset += GPR_SLICE_LENGTH(next);
+  }
+  output_obj = rb_str_new(output, length);
+
+  /* Save a references to the computed string in the mark object so that the
+   * calling to_s does not do any allocations. */
+  wrapper->mark = rb_class_new_instance(0, NULL, rb_cObject);
+  rb_ivar_set(wrapper->mark, id_source, output_obj);
+
+  return output_obj;
+}
+
+/* Initializes ByteBuffer instances. */
+static VALUE grpc_rb_byte_buffer_init(VALUE self, VALUE src) {
+  gpr_slice a_slice;
+  grpc_rb_byte_buffer *wrapper = NULL;
+  grpc_byte_buffer *byte_buffer = NULL;
+
+  if (TYPE(src) != T_STRING) {
+    rb_raise(rb_eTypeError, "bad byte_buffer arg: got <%s>, want <String>",
+             rb_obj_classname(src));
+    return Qnil;
+  }
+  Data_Get_Struct(self, grpc_rb_byte_buffer, wrapper);
+  a_slice = gpr_slice_malloc(RSTRING_LEN(src));
+  memcpy(GPR_SLICE_START_PTR(a_slice), RSTRING_PTR(src), RSTRING_LEN(src));
+  byte_buffer = grpc_byte_buffer_create(&a_slice, 1);
+  gpr_slice_unref(a_slice);
+
+  if (byte_buffer == NULL) {
+    rb_raise(rb_eArgError, "could not create a byte_buffer, not sure why");
+    return Qnil;
+  }
+  wrapper->wrapped = byte_buffer;
+
+  /* Save a references to the original string in the mark object so that the
+   * pointers used there is valid for the lifetime of the object. */
+  wrapper->mark = rb_class_new_instance(0, NULL, rb_cObject);
+  rb_ivar_set(wrapper->mark, id_source, src);
+
+  return self;
+}
+
+/* rb_cByteBuffer is the ruby class that proxies grpc_byte_buffer. */
+VALUE rb_cByteBuffer = Qnil;
+
+void Init_grpc_byte_buffer() {
+  rb_cByteBuffer =
+      rb_define_class_under(rb_mGrpcCore, "ByteBuffer", rb_cObject);
+
+  /* Allocates an object managed by the ruby runtime */
+  rb_define_alloc_func(rb_cByteBuffer, grpc_rb_byte_buffer_alloc);
+
+  /* Provides a ruby constructor and support for dup/clone. */
+  rb_define_method(rb_cByteBuffer, "initialize", grpc_rb_byte_buffer_init, 1);
+  rb_define_method(rb_cByteBuffer, "initialize_copy",
+                   grpc_rb_byte_buffer_init_copy, 1);
+
+  /* Provides a to_s method that returns the buffer value */
+  rb_define_method(rb_cByteBuffer, "to_s", grpc_rb_byte_buffer_to_s, 0);
+
+  id_source = rb_intern("__source");
+  id_empty = rb_intern("");
+}
+
+VALUE grpc_rb_byte_buffer_create_with_mark(VALUE mark, grpc_byte_buffer *bb) {
+  grpc_rb_byte_buffer *byte_buffer = NULL;
+  if (bb == NULL) {
+    return Qnil;
+  }
+  byte_buffer = ALLOC(grpc_rb_byte_buffer);
+  byte_buffer->wrapped = bb;
+  byte_buffer->mark = mark;
+  return Data_Wrap_Struct(rb_cByteBuffer, grpc_rb_byte_buffer_mark,
+                          grpc_rb_byte_buffer_free, byte_buffer);
+}
+
+/* Gets the wrapped byte_buffer from the ruby wrapper */
+grpc_byte_buffer *grpc_rb_get_wrapped_byte_buffer(VALUE v) {
+  grpc_rb_byte_buffer *wrapper = NULL;
+  Data_Get_Struct(v, grpc_rb_byte_buffer, wrapper);
+  return wrapper->wrapped;
+}