grpc 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 221227b572c4b9f61daafa02b2b58360b049af09
-  data.tar.gz: 2e9a6e8f6aef5ef48f1afc87987ecbf53c080301
+  metadata.gz: afd38727276d84cb2b01390533f09692b589e4d1
+  data.tar.gz: f078ad52dabd03355354f6ff78b58219462ca35f
 SHA512:
-  metadata.gz: 3b48e42e01ffa5c924308fa0fba2f891b131f94dbf257cdb1b391b46ed7087faeae72b1c1a8e7823cf46c20eedddf5191405b0ef62e8edbf699dd8fc09d8fc01
-  data.tar.gz: 79144378a34d9a4314964faa7735b30b1119ce73fed524b130b3f36fb8d6a764991c2d06bd20fc0dabbacc7db500f3689848e642385f161634feef47d2458f0d
+  metadata.gz: 026fa39524d37611c0ed74ce7f3167a2ad66a617ada90b1fa4e22d56c803a352ede5e3f0264a6b46f8c8c64de52c026f45fa63177a30cab5ea877b070612b18b
+  data.tar.gz: fda00623627a68c253f10e8d61404ecdb4760ac46a57796b684336456bbc015c74ceb7dad82e62ba289c7810a91409bf882ab5c02e87797f70badad3d7d0ae2f

data/README.md

@@ -4,44 +4,48 @@ gRPC Ruby
 A Ruby implementation of gRPC.
 
 Status
-------
+-------
 
 Alpha : Ready for early adopters
 
-PREREQUISITES
--------------
+INSTALLATION PREREQUISITES
+--------------------------
 
-- Ruby 2.x. The gRPC API uses keyword args.
-- [homebrew][] on Mac OS X, [linuxbrew][] on Linux.  These simplify the installation of the gRPC C core.
+This requires Ruby 2.1, as the RPC API surface uses keyword args.
 
-INSTALLATION
+
+QUICK - INSTALL
 ---------------
-On Mac OS X, install [homebrew][]. On Linux, install [linuxbrew][].
-Run the following command to install gRPC Ruby.
+
+- Clone this repository.
+- Follow the instructions in [INSTALL](../../INSTALL) to install the gRPC C core.
+- If you don't have Ruby 2.1 installed, switch to the more detailed instructions below
+- Use bundler to install
 ```sh
-$ curl -fsSL https://goo.gl/getgrpc | bash -s ruby
+$ # from this directory
+$ gem install bundler && bundle install
 ```
-This will download and run the [gRPC install script][], then install the latest version of gRPC Ruby gem.  It also installs Protocol Buffers compiler (_protoc_) and the gRPC _protoc_ plugin for ruby.
 
-BUILD FROM SOURCE
----------------------
-- Clone this repository
+Installing from source
+----------------------
+
 - Build the gRPC C core
-E.g, from the root of the gRPC [Git repository](https://github.com/google/grpc)
+E.g, from the root of the gRPC [git repo](https://github.com/google/grpc)
 ```sh
 $ cd ../..
 $ make && sudo make install
 ```
 
-- Install Ruby 2.x. Consider doing this with [RVM](http://rvm.io), it's a nice way of controlling
+- Install Ruby 2.1. Consider doing this with [RVM](http://rvm.io), it's a nice way of controlling
   the exact ruby version that's used.
 ```sh
 $ command curl -sSL https://rvm.io/mpapis.asc | gpg --import -
-$ \curl -sSL https://get.rvm.io | bash -s stable --ruby=ruby-2
+$ \curl -sSL https://get.rvm.io | bash -s stable --ruby=ruby-2.1
 $
 $ # follow the instructions to ensure that your're using the latest stable version of Ruby
 $ # and that the rvm command is installed
 ```
+
 - Make sure your run `source $HOME/.rvm/scripts/rvm` as instructed to complete the set up of RVM
 
 - Install [bundler](http://bundler.io/)
@@ -49,36 +53,30 @@ $ # and that the rvm command is installed
 $ gem install bundler
 ```
 
-- Finally,  build and install the gRPC gem locally.
+- Finally, install the gRPC gem locally.
 ```sh
 $ # from this directory
 $ bundle install  # creates the ruby bundle, including building the grpc extension
 $ rake  # runs the unit tests, see rake -T for other options
 ```
 
-DOCUMENTATION
--------------
-- rubydoc for the gRPC gem is available online at [rubydoc][].
-- the gRPC Ruby reference documentation is available online at [grpc.io][]
-
 CONTENTS
 --------
-Directory structure is the layout for [ruby extensions][]
-- ext: the gRPC ruby extension
-- lib: the entrypoint gRPC ruby library to be used in a 'require' statement
-- spec: Rspec unittests
-- bin: example gRPC clients and servers, e.g,
-
-  ```ruby
-  stub = Math::Math::Stub.new('my.test.math.server.com:8080')
-  req = Math::DivArgs.new(dividend: 7, divisor: 3)
-  GRPC.logger.info("div(7/3): req=#{req.inspect}")
-  resp = stub.div(req)
-  GRPC.logger.info("Answer: #{resp.inspect}")
-  ```
-[homebrew]:http://brew.sh
-[linuxbrew]:https://github.com/Homebrew/linuxbrew#installation
-[gRPC install script]:https://raw.githubusercontent.com/grpc/homebrew-grpc/master/scripts/install
-[ruby extensions]:http://guides.rubygems.org/gems-with-extensions/
-[rubydoc]: http://www.rubydoc.info/gems/grpc
-[grpc.io]: http://www.grpc.io/docs/installation/ruby.html
+
+Directory structure is the layout for [ruby extensions](http://guides.rubygems.org/gems-with-extensions/)
+
+- ext:
+  the gRPC ruby extension
+- lib:
+  the entrypoint gRPC ruby library to be used in a 'require' statement
+- spec:
+  Rspec unittest
+- bin:
+  example gRPC clients and servers, e.g,
+```ruby
+stub = Math::Math::Stub.new('my.test.math.server.com:8080')
+req = Math::DivArgs.new(dividend: 7, divisor: 3)
+logger.info("div(7/3): req=#{req.inspect}")
+resp = stub.div(req)
+logger.info("Answer: #{resp.inspect}")
+```

data/bin/interop/interop_client.rb

@@ -274,7 +274,6 @@ class NamedTests
     op = @stub.streaming_input_call(reqs, return_op: true)
     op.cancel
     assert_raises(GRPC::Cancelled) { op.execute }
-    assert(op.cancelled, 'call operation should be CANCELLED')
     p 'OK: cancel_after_begin'
   end
 
@@ -283,8 +282,7 @@ class NamedTests
     ppp = PingPongPlayer.new(msg_sizes)
     op = @stub.full_duplex_call(ppp.each_item, return_op: true)
     ppp.canceller_op = op  # causes ppp to cancel after the 1st message
-    op.execute.each { |r| ppp.queue.push(r) }
-    assert(op.cancelled, 'call operation should be CANCELLED')
+    assert_raises(GRPC::Cancelled) { op.execute.each { |r| ppp.queue.push(r) } }
     p 'OK: cancel_after_first_response'
   end
 

data/bin/interop/interop_server.rb

@@ -128,19 +128,16 @@ class TestTarget < Grpc::Testing::TestService::Service
     cls = StreamingOutputCallResponse
     Thread.new do
       begin
-        GRPC.logger.info('interop-server: started receiving')
         reqs.each do |req|
+          GRPC.logger.info("read #{req.inspect}")
           resp_size = req.response_parameters[0].size
-          GRPC.logger.info("read a req, response size is #{resp_size}")
           resp = cls.new(payload: Payload.new(type: req.response_type,
                                               body: nulls(resp_size)))
           q.push(resp)
         end
-        GRPC.logger.info('interop-server: finished receiving')
+        GRPC.logger.info('finished reads')
         q.push(self)
       rescue StandardError => e
-        GRPC.logger.info('interop-server: failed')
-        GRPC.logger.warn(e)
         q.push(e)  # share the exception with the enumerator
       end
     end

data/ext/grpc/rb_byte_buffer.c

@@ -36,7 +36,6 @@
 #include <ruby/ruby.h>
 
 #include <grpc/grpc.h>
-#include <grpc/byte_buffer_reader.h>
 #include <grpc/support/slice.h>
 #include "rb_grpc.h"
 
@@ -51,7 +50,7 @@ VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer) {
   size_t length = 0;
   char *string = NULL;
   size_t offset = 0;
-  grpc_byte_buffer_reader reader;
+  grpc_byte_buffer_reader *reader = NULL;
   gpr_slice next;
   if (buffer == NULL) {
     return Qnil;
@@ -59,8 +58,8 @@ VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer) {
   }
   length = grpc_byte_buffer_length(buffer);
   string = xmalloc(length + 1);
-  grpc_byte_buffer_reader_init(&reader, buffer);
-  while (grpc_byte_buffer_reader_next(&reader, &next) != 0) {
+  reader = grpc_byte_buffer_reader_create(buffer);
+  while (grpc_byte_buffer_reader_next(reader, &next) != 0) {
     memcpy(string + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
     offset += GPR_SLICE_LENGTH(next);
   }

data/lib/grpc/generic/active_call.rb

@@ -39,7 +39,6 @@ class Struct
       return nil if status.nil?
       fail GRPC::Cancelled if status.code == GRPC::Core::StatusCodes::CANCELLED
       if status.code != GRPC::Core::StatusCodes::OK
-        GRPC.logger.debug("Failing with status #{status}")
         # raise BadStatus, propagating the metadata if present.
         md = status.metadata
         with_sym_keys = Hash[md.each_pair.collect { |x, y| [x.to_sym, y] }]
@@ -55,6 +54,7 @@ module GRPC
   # The ActiveCall class provides simple methods for sending marshallable
   # data to a call
   class ActiveCall
+    include Core::StatusCodes
     include Core::TimeConsts
     include Core::CallOps
     extend Forwardable
@@ -128,11 +128,6 @@ module GRPC
       @output_metadata ||= {}
     end
 
-    # cancelled indicates if the call was cancelled
-    def cancelled
-      !@call.status.nil? && @call.status.code == Core::StatusCodes::CANCELLED
-    end
-
     # multi_req_view provides a restricted view of this ActiveCall for use
     # in a server client-streaming handler.
     def multi_req_view
@@ -166,7 +161,6 @@ module GRPC
       ops[RECV_STATUS_ON_CLIENT] = nil if assert_finished
       batch_result = @call.run_batch(@cq, self, INFINITE_FUTURE, ops)
       return unless assert_finished
-      @call.status = batch_result.status
       batch_result.check_status
     end
 
@@ -183,7 +177,6 @@ module GRPC
           @call.metadata.merge!(batch_result.status.metadata)
         end
       end
-      @call.status = batch_result.status
       batch_result.check_status
     end
 
@@ -416,6 +409,9 @@ module GRPC
       start_call(**kw) unless @started
       bd = BidiCall.new(@call, @cq, @marshal, @unmarshal, @deadline)
       bd.run_on_client(requests, &blk)
+    rescue GRPC::Core::CallError => e
+      finished  # checks for Cancelled
+      raise e
     end
 
     # run_server_bidi orchestrates a BiDi stream processing on a server.

data/lib/grpc/generic/bidi_call.rb

@@ -78,9 +78,11 @@ module GRPC
     # @param requests the Enumerable of requests to send
     # @return an Enumerator of requests to yield
     def run_on_client(requests, &blk)
-      @enq_th = Thread.new { write_loop(requests) }
+      @enq_th = start_write_loop(requests)
       @loop_th = start_read_loop
-      each_queued_msg(&blk)
+      replies = each_queued_msg
+      return replies if blk.nil?
+      replies.each { |r| blk.call(r) }
     end
 
     # Begins orchestration of the Bidi stream for a server generating replies.
@@ -96,8 +98,8 @@ module GRPC
     # @param gen_each_reply [Proc] generates the BiDi stream replies.
     def run_on_server(gen_each_reply)
       replys = gen_each_reply.call(each_queued_msg)
+      @enq_th = start_write_loop(replys, is_client: false)
       @loop_th = start_read_loop
-      write_loop(replys, is_client: false)
     end
 
     private
@@ -113,7 +115,7 @@ module GRPC
       return enum_for(:each_queued_msg) unless block_given?
       count = 0
       loop do
-        GRPC.logger.debug("each_queued_msg: waiting##{count}")
+        GRPC.logger.debug("each_queued_msg: msg##{count}")
         count += 1
         req = @readq.pop
         GRPC.logger.debug("each_queued_msg: req = #{req}")
@@ -121,68 +123,70 @@ module GRPC
         break if req.equal?(END_OF_READS)
         yield req
       end
+      @enq_th.join if @enq_th.alive?
     end
 
-    def write_loop(requests, is_client: true)
-      GRPC.logger.debug('bidi-write-loop: starting')
-      write_tag = Object.new
-      count = 0
-      requests.each do |req|
-        GRPC.logger.debug("bidi-write-loop: #{count}")
-        count += 1
-        payload = @marshal.call(req)
-        @call.run_batch(@cq, write_tag, INFINITE_FUTURE,
-                        SEND_MESSAGE => payload)
-      end
-      GRPC.logger.debug("bidi-write-loop: #{count} writes done")
-      if is_client
-        GRPC.logger.debug("bidi-write-loop: client sent #{count}, waiting")
-        batch_result = @call.run_batch(@cq, write_tag, INFINITE_FUTURE,
-                                       SEND_CLOSE_FROM_CLIENT => nil,
-                                       RECV_STATUS_ON_CLIENT => nil)
-        @call.status = batch_result.status
-        batch_result.check_status
-        GRPC.logger.debug("bidi-write-loop: done status #{@call.status}")
+    # during bidi-streaming, read the requests to send from a separate thread
+    # read so that read_loop does not block waiting for requests to read.
+    def start_write_loop(requests, is_client: true)
+      Thread.new do  # TODO: run on a thread pool
+        write_tag = Object.new
+        begin
+          count = 0
+          requests.each do |req|
+            GRPC.logger.debug("bidi-write_loop: #{count}")
+            count += 1
+            payload = @marshal.call(req)
+            @call.run_batch(@cq, write_tag, INFINITE_FUTURE,
+                            SEND_MESSAGE => payload)
+          end
+          if is_client
+            GRPC.logger.debug("bidi-write-loop: sent #{count}, waiting")
+            batch_result = @call.run_batch(@cq, write_tag, INFINITE_FUTURE,
+                                           SEND_CLOSE_FROM_CLIENT => nil,
+                                           RECV_STATUS_ON_CLIENT => nil)
+            batch_result.check_status
+          end
+        rescue StandardError => e
+          GRPC.logger.warn('bidi-write_loop: failed')
+          GRPC.logger.warn(e)
+          raise e
+        end
       end
-      GRPC.logger.debug('bidi-write-loop: finished')
-    rescue StandardError => e
-      GRPC.logger.warn('bidi-write-loop: failed')
-      GRPC.logger.warn(e)
-      raise e
     end
 
     # starts the read loop
     def start_read_loop
       Thread.new do
-        GRPC.logger.debug('bidi-read-loop: starting')
         begin
           read_tag = Object.new
           count = 0
+
           # queue the initial read before beginning the loop
           loop do
-            GRPC.logger.debug("bidi-read-loop: #{count}")
+            GRPC.logger.debug("bidi-read_loop: #{count}")
             count += 1
             # TODO: ensure metadata is read if available, currently it's not
             batch_result = @call.run_batch(@cq, read_tag, INFINITE_FUTURE,
                                            RECV_MESSAGE => nil)
             # handle the next message
             if batch_result.message.nil?
-              GRPC.logger.debug("bidi-read-loop: null batch #{batch_result}")
               @readq.push(END_OF_READS)
               GRPC.logger.debug('bidi-read-loop: done reading!')
               break
             end
 
             # push the latest read onto the queue and continue reading
+            GRPC.logger.debug("received req: #{batch_result.message}")
             res = @unmarshal.call(batch_result.message)
             @readq.push(res)
           end
+
         rescue StandardError => e
-          GRPC.logger.warn('bidi: read-loop failed')
+          GRPC.logger.warn('bidi: read_loop failed')
           GRPC.logger.warn(e)
           @readq.push(e)  # let each_queued_msg terminate with this error
         end
-        GRPC.logger.debug('bidi-read-loop: finished')
       end
     end
   end

data/lib/grpc/generic/rpc_desc.rb

@@ -137,7 +137,6 @@ module GRPC
 
     def send_status(active_client, code, details, **kw)
       details = 'Not sure why' if details.nil?
-      GRPC.logger.debug("Sending status  #{code}:#{details}")
       active_client.send_status(code, details, code == OK, **kw)
     rescue StandardError => e
       GRPC.logger.warn("Could not send status #{code}:#{details}")

data/lib/grpc/version.rb

@@ -29,5 +29,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '0.9.3'
+  VERSION = '0.9.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grpc
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - gRPC Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-04 00:00:00.000000000 Z
+date: 2015-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf