grpc 0.6.1 → 0.9.2

data/grpc.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake', '~> 10.4'
   s.add_development_dependency 'rake-compiler', '~> 0.9'
   s.add_development_dependency 'rspec', '~> 3.2'
-  s.add_development_dependency 'rubocop', '~> 0.30'
+  s.add_development_dependency 'rubocop', '~> 0.30.0'
 
   s.extensions = %w(ext/grpc/extconf.rb)
 end

data/lib/grpc/core/time_consts.rb

@@ -58,7 +58,7 @@ module GRPC
                "Cannot make an absolute deadline from #{timeish.inspect}")
         elsif timeish < 0
           TimeConsts::INFINITE_FUTURE
-        elsif timeish == 0
+        elsif timeish.zero?
           TimeConsts::ZERO
         else
           Time.now + timeish

data/lib/grpc/generic/active_call.rb

@@ -39,6 +39,7 @@ 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] }]
@@ -54,7 +55,6 @@ 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,6 +128,11 @@ 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
@@ -161,6 +166,7 @@ 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
 
@@ -177,6 +183,7 @@ module GRPC
           @call.metadata.merge!(batch_result.status.metadata)
         end
       end
+      @call.status = batch_result.status
       batch_result.check_status
     end
 
@@ -188,7 +195,7 @@ module GRPC
     # @param marshalled [false, true] indicates if the object is already
     # marshalled.
     def remote_send(req, marshalled = false)
-      logger.debug("sending #{req}, marshalled? #{marshalled}")
+      GRPC.logger.debug("sending #{req}, marshalled? #{marshalled}")
       if marshalled
         payload = req
       else
@@ -230,14 +237,14 @@ module GRPC
         @call.metadata = batch_result.metadata
         @metadata_tag = nil
       end
-      logger.debug("received req: #{batch_result}")
+      GRPC.logger.debug("received req: #{batch_result}")
       unless batch_result.nil? || batch_result.message.nil?
-        logger.debug("received req.to_s: #{batch_result.message}")
+        GRPC.logger.debug("received req.to_s: #{batch_result.message}")
         res = @unmarshal.call(batch_result.message)
-        logger.debug("received_req (unmarshalled): #{res.inspect}")
+        GRPC.logger.debug("received_req (unmarshalled): #{res.inspect}")
         return res
       end
-      logger.debug('found nil; the final response has been sent')
+      GRPC.logger.debug('found nil; the final response has been sent')
       nil
     end
 
@@ -409,9 +416,6 @@ 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,11 +78,9 @@ 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 = start_write_loop(requests)
+      @enq_th = Thread.new { write_loop(requests) }
       @loop_th = start_read_loop
-      replies = each_queued_msg
-      return replies if blk.nil?
-      replies.each { |r| blk.call(r) }
+      each_queued_msg(&blk)
     end
 
     # Begins orchestration of the Bidi stream for a server generating replies.
@@ -98,8 +96,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
@@ -115,78 +113,76 @@ module GRPC
       return enum_for(:each_queued_msg) unless block_given?
       count = 0
       loop do
-        logger.debug("each_queued_msg: msg##{count}")
+        GRPC.logger.debug("each_queued_msg: waiting##{count}")
         count += 1
         req = @readq.pop
-        logger.debug("each_queued_msg: req = #{req}")
+        GRPC.logger.debug("each_queued_msg: req = #{req}")
         throw req if req.is_a? StandardError
         break if req.equal?(END_OF_READS)
         yield req
       end
-      @enq_th.join if @enq_th.alive?
     end
 
-    # 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|
-            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
-            logger.debug("bidi-write-loop: sent #{count}, waiting to finish")
-            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
-          logger.warn('bidi-write_loop: failed')
-          logger.warn(e)
-          raise e
-        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}")
+      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
-            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)
-              logger.debug('bidi-read-loop: done reading!')
+              GRPC.logger.debug('bidi-read-loop: done reading!')
               break
             end
 
             # push the latest read onto the queue and continue reading
-            logger.debug("received req: #{batch_result.message}")
             res = @unmarshal.call(batch_result.message)
             @readq.push(res)
           end
-
         rescue StandardError => e
-          logger.warn('bidi: read_loop failed')
-          logger.warn(e)
+          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

@@ -84,22 +84,22 @@ module GRPC
     rescue BadStatus => e
       # this is raised by handlers that want GRPC to send an application error
       # code and detail message and some additional app-specific metadata.
-      logger.debug("app err: #{active_call}, status:#{e.code}:#{e.details}")
+      GRPC.logger.debug("app err:#{active_call}, status:#{e.code}:#{e.details}")
       send_status(active_call, e.code, e.details, **e.metadata)
     rescue Core::CallError => e
       # This is raised by GRPC internals but should rarely, if ever happen.
       # Log it, but don't notify the other endpoint..
-      logger.warn("failed call: #{active_call}\n#{e}")
+      GRPC.logger.warn("failed call: #{active_call}\n#{e}")
     rescue Core::OutOfTime
       # This is raised when active_call#method.call exceeeds the deadline
       # event.  Send a status of deadline exceeded
-      logger.warn("late call: #{active_call}")
+      GRPC.logger.warn("late call: #{active_call}")
       send_status(active_call, DEADLINE_EXCEEDED, 'late')
     rescue StandardError => e
       # This will usuaally be an unhandled error in the handling code.
       # Send back a UNKNOWN status to the client
-      logger.warn("failed handler: #{active_call}; sending status:UNKNOWN")
-      logger.warn(e)
+      GRPC.logger.warn("failed handler: #{active_call}; sending status:UNKNOWN")
+      GRPC.logger.warn(e)
       send_status(active_call, UNKNOWN, 'no reason given')
     end
 
@@ -137,10 +137,11 @@ 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
-      logger.warn("Could not send status #{code}:#{details}")
-      logger.warn(e)
+      GRPC.logger.warn("Could not send status #{code}:#{details}")
+      GRPC.logger.warn(e)
     end
   end
 end

data/lib/grpc/generic/rpc_server.rb

@@ -76,7 +76,7 @@ module GRPC
       @jobs = Queue.new
       @size = size
       @stopped = false
-      @stop_mutex = Mutex.new
+      @stop_mutex = Mutex.new # needs to be held when accessing @stopped
       @stop_cond = ConditionVariable.new
       @workers = []
       @keep_alive = keep_alive
@@ -92,10 +92,15 @@ module GRPC
     # @param args the args passed blk when it is called
     # @param blk the block to call
     def schedule(*args, &blk)
-      fail 'already stopped' if @stopped
       return if blk.nil?
-      logger.info('schedule another job')
-      @jobs << [blk, args]
+      @stop_mutex.synchronize do
+        if @stopped
+          GRPC.logger.warn('did not schedule job, already stopped')
+          return
+        end
+        GRPC.logger.info('schedule another job')
+        @jobs << [blk, args]
+      end
     end
 
     # Starts running the jobs in the thread pool.
@@ -114,14 +119,14 @@ module GRPC
 
     # Stops the jobs in the pool
     def stop
-      logger.info('stopping, will wait for all the workers to exit')
+      GRPC.logger.info('stopping, will wait for all the workers to exit')
       @workers.size.times { schedule { throw :exit } }
-      @stopped = true
       @stop_mutex.synchronize do  # wait @keep_alive for works to stop
+        @stopped = true
         @stop_cond.wait(@stop_mutex, @keep_alive) if @workers.size > 0
       end
       forcibly_stop_workers
-      logger.info('stopped, all workers are shutdown')
+      GRPC.logger.info('stopped, all workers are shutdown')
     end
 
     protected
@@ -129,14 +134,14 @@ module GRPC
     # Forcibly shutdown any threads that are still alive.
     def forcibly_stop_workers
       return unless @workers.size > 0
-      logger.info("forcibly terminating #{@workers.size} worker(s)")
+      GRPC.logger.info("forcibly terminating #{@workers.size} worker(s)")
       @workers.each do |t|
         next unless t.alive?
         begin
           t.exit
         rescue StandardError => e
-          logger.warn('error while terminating a worker')
-          logger.warn(e)
+          GRPC.logger.warn('error while terminating a worker')
+          GRPC.logger.warn(e)
         end
       end
     end
@@ -146,7 +151,7 @@ module GRPC
     def remove_current_thread
       @stop_mutex.synchronize do
         @workers.delete(Thread.current)
-        @stop_cond.signal if @workers.size == 0
+        @stop_cond.signal if @workers.size.zero?
       end
     end
 
@@ -156,8 +161,8 @@ module GRPC
           blk, args = @jobs.pop
           blk.call(*args)
         rescue StandardError => e
-          logger.warn('Error in worker thread')
-          logger.warn(e)
+          GRPC.logger.warn('Error in worker thread')
+          GRPC.logger.warn(e)
         end
       end
     end
@@ -249,15 +254,18 @@ module GRPC
                    server_override:nil,
                    connect_md_proc:nil,
                    **kw)
-      @cq = RpcServer.setup_cq(completion_queue_override)
-      @server = RpcServer.setup_srv(server_override, @cq, **kw)
       @connect_md_proc = RpcServer.setup_connect_md_proc(connect_md_proc)
-      @pool_size = pool_size
+      @cq = RpcServer.setup_cq(completion_queue_override)
       @max_waiting_requests = max_waiting_requests
       @poll_period = poll_period
-      @run_mutex = Mutex.new
-      @run_cond = ConditionVariable.new
+      @pool_size = pool_size
       @pool = Pool.new(@pool_size)
+      @run_cond = ConditionVariable.new
+      @run_mutex = Mutex.new
+      @running = false
+      @server = RpcServer.setup_srv(server_override, @cq, **kw)
+      @stopped = false
+      @stop_mutex = Mutex.new
     end
 
     # stops a running server
@@ -266,20 +274,23 @@ module GRPC
     # server's current call loop is it's last.
     def stop
       return unless @running
-      @stopped = true
+      @stop_mutex.synchronize do
+        @stopped = true
+      end
       @pool.stop
+      @server.close
+    end
 
-      # TODO: uncomment this:
-      #
-      # This segfaults in the c layer, so its commented out for now.  Shutdown
-      # still occurs, but the c layer has to do the cleanup.
-      #
-      # @server.close
+    # determines if the server has been stopped
+    def stopped?
+      @stop_mutex.synchronize do
+        return @stopped
+      end
     end
 
     # determines if the server is currently running
     def running?
-      @running ||= false
+      @running
     end
 
     # Is called from other threads to wait for #run to start up the server.
@@ -311,11 +322,6 @@ module GRPC
       t.join
     end
 
-    # Determines if the server is currently stopped
-    def stopped?
-      @stopped ||= false
-    end
-
     # handle registration of classes
     #
     # service is either a class that includes GRPC::GenericService and whose
@@ -364,8 +370,8 @@ module GRPC
     # - #running? returns true after this is called, until #stop cause the
     #   the server to stop.
     def run
-      if rpc_descs.size == 0
-        logger.warn('did not run as no services were present')
+      if rpc_descs.size.zero?
+        GRPC.logger.warn('did not run as no services were present')
         return
       end
       @run_mutex.synchronize do
@@ -381,9 +387,9 @@ module GRPC
     # Sends UNAVAILABLE if there are too many unprocessed jobs
     def available?(an_rpc)
       jobs_count, max = @pool.jobs_waiting, @max_waiting_requests
-      logger.info("waiting: #{jobs_count}, max: #{max}")
+      GRPC.logger.info("waiting: #{jobs_count}, max: #{max}")
       return an_rpc if @pool.jobs_waiting <= @max_waiting_requests
-      logger.warn("NOT AVAILABLE: too many jobs_waiting: #{an_rpc}")
+      GRPC.logger.warn("NOT AVAILABLE: too many jobs_waiting: #{an_rpc}")
       noop = proc { |x| x }
       c = ActiveCall.new(an_rpc.call, @cq, noop, noop, an_rpc.deadline)
       c.send_status(StatusCodes::UNAVAILABLE, '')
@@ -394,7 +400,7 @@ module GRPC
     def found?(an_rpc)
       mth = an_rpc.method.to_sym
       return an_rpc if rpc_descs.key?(mth)
-      logger.warn("NOT_FOUND: #{an_rpc}")
+      GRPC.logger.warn("NOT_FOUND: #{an_rpc}")
       noop = proc { |x| x }
       c = ActiveCall.new(an_rpc.call, @cq, noop, noop, an_rpc.deadline)
       c.send_status(StatusCodes::NOT_FOUND, '')
@@ -407,7 +413,13 @@ module GRPC
       request_call_tag = Object.new
       until stopped?
         deadline = from_relative_time(@poll_period)
-        an_rpc = @server.request_call(@cq, request_call_tag, deadline)
+        begin
+          an_rpc = @server.request_call(@cq, request_call_tag, deadline)
+        rescue Core::CallError, RuntimeError => e
+          # can happen during server shutdown
+          GRPC.logger.warn("server call failed: #{e}")
+          next
+        end
         c = new_active_server_call(an_rpc)
         unless c.nil?
           mth = an_rpc.method.to_sym
@@ -434,7 +446,7 @@ module GRPC
       return nil unless found?(an_rpc)
 
       # Create the ActiveCall
-      logger.info("deadline is #{an_rpc.deadline}; (now=#{Time.now})")
+      GRPC.logger.info("deadline is #{an_rpc.deadline}; (now=#{Time.now})")
       rpc_desc = rpc_descs[an_rpc.method.to_sym]
       ActiveCall.new(an_rpc.call, @cq,
                      rpc_desc.marshal_proc, rpc_desc.unmarshal_proc(:input),
@@ -455,7 +467,7 @@ module GRPC
       unless cls.include?(GenericService)
         fail "#{cls} must 'include GenericService'"
       end
-      if cls.rpc_descs.size == 0
+      if cls.rpc_descs.size.zero?
         fail "#{cls} should specify some rpc descriptions"
       end
       cls.assert_rpc_descs_have_methods
@@ -468,12 +480,13 @@ module GRPC
         route = "/#{cls.service_name}/#{name}".to_sym
         fail "already registered: rpc #{route} from #{spec}" if specs.key? route
         specs[route] = spec
+        rpc_name = GenericService.underscore(name.to_s).to_sym
         if service.is_a?(Class)
-          handlers[route] = cls.new.method(name.to_s.underscore.to_sym)
+          handlers[route] = cls.new.method(rpc_name)
         else
-          handlers[route] = service.method(name.to_s.underscore.to_sym)
+          handlers[route] = service.method(rpc_name)
         end
-        logger.info("handling #{route} with #{handlers[route]}")
+        GRPC.logger.info("handling #{route} with #{handlers[route]}")
       end
     end
   end