grpc_kit 0.3.7 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dad9e00f7b8c87f220a4c1c4f576e85567e14b2069c74df52c714c928db4d672
-  data.tar.gz: 54eaa519ea0fd92195b26aae853a17bf1bbdd53d8bb29a3e749627fa172eb666
+  metadata.gz: 854c24c4b4668ac76230b5c262893ae24f66ea7c644e1b46389e2546783004f6
+  data.tar.gz: 5b3cc154a4fbed3ebabffc62611b328a26f8d4006f692b15c397ce292880171f
 SHA512:
-  metadata.gz: 70578d578f866b8f4e6a974a7fa0279bf80ed911e3abecf12ea3f699fe7bbc7c405159714caff7fb14df898c231b14354da3d1aa45a86d0e9e5806b1ccdf4298
-  data.tar.gz: afaa1d45665349cf62e5b75a334d7c15f98caba35f3579ca5a4320b4aa507a3b89c152295ebb954212552f8dc10445d211438e9a8a1393c48f23cca9e310b201
+  metadata.gz: ba44498c88cb8040c2b6cc9bbc183f7d452f72b47496cdde90c26ae3e72a60496ee47ec2c2fc5659c44ca5ab0ab32bd2f4fa9ecd727cf2ea3096b708d15eefcc
+  data.tar.gz: b9ef8c8d03788525a4927d93ed38c66afffc58eaef70865c152a04f0dbe5936d1edabde8357dfb8db8b70b38a0e31b0edc7d2321882eb2a2290f726a607cbfd7

data/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: ci
+on: 
+  push:
+    branches:
+      - master
+  pull_request: {}
+
+jobs:
+  ruby:
+    name: ruby
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby_version:
+          - 2.5
+          - 2.6
+          - 2.7
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '${{ matrix.ruby_version }}'
+          bundler-cache: true
+
+      - run: 'bundle exec rake'

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## v0.5.1 (2021-05-19)
+
+- improve: Set END_STREAM flag on the last DATA frame on request stream ([#34](https://github.com/cookpad/grpc_kit/pull/34))
+
+## v0.5.0 (2021-04-22)
+
+- improve: Configurable max_receive_message_size and max_send_message_size ([#33](https://github.com/cookpad/grpc_kit/pull/33))
+
+## v0.4.0 (2020-10-23)
+
+- bug: Fix Ruby 2.7 keyword argument separation warnings ([#27](https://github.com/cookpad/grpc_kit/pull/27))
+- bug: HTTP/2 Trailer (grpc-status) might not be sent due to race condition ([#30](https://github.com/cookpad/grpc_kit/pull/30))
+- improve: Reduce number of select(2) calls by adding pipe(2) to wake blocking threads ([#28](https://github.com/cookpad/grpc_kit/pull/28))
+- improve: Improved performance when receiving streaming messages by blocking queue. ([#31](https://github.com/cookpad/grpc_kit/pull/31))
+

data/README.md

@@ -1,6 +1,6 @@
 # GrpcKit
 
-[![Build Status](https://travis-ci.org/ganmacs/grpc_kit.svg?branch=master)](https://travis-ci.org/ganmacs/grpc_kit)
+[![Build Sttaus](https://github.com/cookpad/grpc_kit/workflows/ci/badge.svg)](https://github.com/cookpad/grpc_kit/actions)
 [![Gem Version](https://badge.fury.io/rb/grpc_kit.svg)](https://badge.fury.io/rb/grpc_kit)
 
 A kit for creating [gRPC](https://grpc.io/) server/client in Ruby.
@@ -27,7 +27,7 @@ $ gem install grpc_kit
 
 ## Usage
 
-More Details in [examples directory](https://github.com/ganmacs/grpc_kit/tree/master/examples).
+More Details in [examples directory](https://github.com/cookpad/grpc_kit/tree/master/examples).
 
 ##### Server
 
@@ -59,11 +59,11 @@ $ bundle install
 
 ## Projects using grpc_kit
 
-* [griffin](https://github.com/ganmacs/griffin) Multi process gRPC server in Ruby
+* [griffin](https://github.com/cookpad/griffin) Multi process gRPC server in Ruby
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/ganmacs/grpc_kit.
+Bug reports and pull requests are welcome on GitHub at https://github.com/cookpad/grpc_kit.
 
 ## License
 

data/lib/grpc_kit/calls/client_bidi_streamer.rb

@@ -10,10 +10,13 @@ module GrpcKit
 
       alias outgoing_metadata metadata
 
-      def initialize(*)
+      def initialize(**)
         super
-        @mutex = Mutex.new
+        @recv_mutex = Mutex.new
+
         @send = false
+        @send_cv = Thread::ConditionVariable.new
+        @send_mutex = Mutex.new
       end
 
       # @param data [Object] request message
@@ -23,29 +26,21 @@ module GrpcKit
           raise "Upstream returns an error status: #{@reason}"
         end
 
-        @mutex.synchronize do
+        @send_mutex.synchronize do
           @stream.send_msg(data, metadata: outgoing_metadata)
+          @send = true
+          @send_cv.broadcast
         end
-
-        @send = true
       end
 
-      # This method not is expected to be call in the main thread where #send_msg is called
-      #
+      # Receive a message from peer. This method is not thread safe, never call from multiple threads at once.
       # @return [Object] response object
+      # @raise [StopIteration]
       def recv
-        sleep 0.1 until @send
-
-        loop do
-          msg = @mutex.synchronize do
-            @stream.recv_msg(blocking: false)
-          end
-
-          unless msg == :wait_readable
-            return msg
-          end
-        end
+        @send_mutex.synchronize { @send_cv.wait(@send_mutex) until @send } unless @send
 
+        msg = @stream.recv_msg(blocking: true)
+        return msg if msg
         raise StopIteration
       rescue GrpcKit::Errors::BadStatus => e
         @reason = e
@@ -53,14 +48,16 @@ module GrpcKit
       end
 
       def close_and_send
-        @mutex.synchronize do
+        @send_mutex.synchronize do
           @stream.close_and_send
         end
       end
 
       # @yieldparam response [Object] each response object of bidi streaming RPC
       def each
-        loop { yield(recv) }
+        @recv_mutex.synchronize do
+          loop { yield(recv) }
+        end
       end
     end
   end

data/lib/grpc_kit/calls/client_server_streamer.rb

@@ -16,6 +16,7 @@ module GrpcKit
         @stream.send_msg(data, last: true, metadata: outgoing_metadata)
       end
 
+      # This method is not thread safe, never call from multiple threads at once.
       # @return [Object] response object
       def recv
         @stream.recv_msg

data/lib/grpc_kit/calls/server_bidi_streamer.rb

@@ -11,7 +11,7 @@ module GrpcKit
       attr_reader :outgoing_initial_metadata, :outgoing_trailing_metadata
       alias incoming_metadata metadata
 
-      def initialize(*)
+      def initialize(**)
         super
 
         @outgoing_initial_metadata = {}
@@ -30,6 +30,7 @@ module GrpcKit
         )
       end
 
+      # This method is not thread safe, never call from multiple threads at once.
       # @return [Object] response object
       def recv
         @stream.recv_msg(@codec, limit_size: @config.max_receive_message_size)

data/lib/grpc_kit/calls/server_client_streamer.rb

@@ -11,7 +11,7 @@ module GrpcKit
       attr_reader :outgoing_initial_metadata, :outgoing_trailing_metadata
       alias incoming_metadata metadata
 
-      def initialize(*)
+      def initialize(**)
         super
 
         @outgoing_initial_metadata = {}
@@ -31,6 +31,7 @@ module GrpcKit
         )
       end
 
+      # This method is not thread safe, never call from multiple threads at once.
       # @return [Object] response object
       def recv
         @stream.recv_msg(@codec, limit_size: @config.max_receive_message_size)

data/lib/grpc_kit/calls/server_request_response.rb

@@ -9,7 +9,7 @@ module GrpcKit
       attr_reader :outgoing_initial_metadata, :outgoing_trailing_metadata
       alias incoming_metadata metadata
 
-      def initialize(*)
+      def initialize(**)
         super
 
         @outgoing_initial_metadata = {}

data/lib/grpc_kit/calls/server_server_streamer.rb

@@ -9,7 +9,7 @@ module GrpcKit
       attr_reader :outgoing_initial_metadata, :outgoing_trailing_metadata
       alias incoming_metadata metadata
 
-      def initialize(*)
+      def initialize(**)
         super
 
         @outgoing_initial_metadata = {}

data/lib/grpc_kit/client.rb

@@ -12,7 +12,9 @@ module GrpcKit
     # @param authority [nil, String]
     # @param interceptors [Array<GrpcKit::Grpc::ClientInterceptor>] list of interceptors
     # @param timeout [nil, Integer, String]
-    def initialize(sock, authority: nil, interceptors: [], timeout: nil)
+    # @param max_receive_message_size [Integer, nil] Specify the default maximum size of inbound message in bytes. Default to 4MB.
+    # @param max_send_message_size [Integer, nil] Specify the default maximum size of outbound message in bytes. Default to 4MB.
+    def initialize(sock, authority: nil, interceptors: [], timeout: nil, max_receive_message_size: nil, max_send_message_size: nil)
       @sock = sock
       @authority =
         if authority
@@ -24,38 +26,43 @@ module GrpcKit
 
       @timeout = timeout && GrpcKit::GrpcTime.new(timeout)
 
-      build_rpcs(interceptors)
+      # Defined at GrpcKit::Grpc::Dsl#.rpc_stub_class
+      build_rpcs(
+        interceptors,
+        max_receive_message_size: max_receive_message_size,
+        max_send_message_size: max_send_message_size,
+      )
     end
 
     # @param rpc [GrpcKit::Rpcs::Client::RequestResponse]
     # @param request [Object]
     # @param opts [Hash]
-    def request_response(rpc, request, opts = {})
+    def request_response(rpc, request, **opts)
       GrpcKit.logger.debug('Calling request_respose')
-      do_request(rpc, request, opts)
+      do_request(rpc, request, **opts)
     end
 
     # @param rpc [GrpcKit::Rpcs::Client::ClientStreamer]
     # @param opts [Hash]
-    def client_streamer(rpc, opts = {})
+    def client_streamer(rpc, **opts)
       GrpcKit.logger.debug('Calling client_streamer')
-      do_request(rpc, nil, opts)
+      do_request(rpc, nil, **opts)
     end
 
     # @param rpc [GrpcKit::Rpcs::Client::ServerStreamer]
     # @param request [Object]
     # @param opts [Hash]
-    def server_streamer(rpc, request, opts = {})
+    def server_streamer(rpc, request, **opts)
       GrpcKit.logger.debug('Calling server_streamer')
-      do_request(rpc, request, opts)
+      do_request(rpc, request, **opts)
     end
 
     # @param rpc [GrpcKit::Rpcs::Client::ServerStreamer]
     # @param _requests [Object] it's for compatibility, no use
     # @param opts [Hash]
-    def bidi_streamer(rpc, _requests, opts = {})
+    def bidi_streamer(rpc, _requests, **opts)
       GrpcKit.logger.debug('Calling bidi_streamer')
-      do_request(rpc, nil, opts)
+      do_request(rpc, nil, **opts)
     end
 
     private

data/lib/grpc_kit/grpc/dsl.rb

@@ -7,6 +7,8 @@ require 'grpc_kit/grpc/stream'
 
 module GrpcKit
   module Grpc
+    # Methods under GrpcKit::Grpc::Dsl is available for classes include GRPC::GenericService.
+    # See also: GrpcKit::Grpc::GenericService
     module Dsl
       # @param value [String]
       attr_accessor :service_name
@@ -68,34 +70,34 @@ module GrpcKit
         end
 
         Class.new(GrpcKit::Client) do
-          def initialize(*)
+          def initialize(*, **)
             @rpcs = {}
             super
           end
 
-          define_method(:build_rpcs) do |interceptors|
+          define_method(:build_rpcs) do |interceptors, **options|
             rpc_descs_.each do |method_name, rpc_desc|
-              @rpcs[method_name] = rpc_desc.build_client(interceptors: interceptors)
+              @rpcs[method_name] = rpc_desc.build_client(interceptors: interceptors, **options)
             end
           end
           private :build_rpcs
 
           rpc_descs_.each do |method_name, rpc_desc|
             if rpc_desc.request_response?
-              define_method(method_name) do |request, opts = {}|
-                request_response(@rpcs.fetch(method_name), request, opts)
+              define_method(method_name) do |request, **opts|
+                request_response(@rpcs.fetch(method_name), request, **opts)
               end
             elsif rpc_desc.client_streamer?
-              define_method(method_name) do |opts = {}|
-                client_streamer(@rpcs.fetch(method_name), opts)
+              define_method(method_name) do |**opts|
+                client_streamer(@rpcs.fetch(method_name), **opts)
               end
             elsif rpc_desc.server_streamer?
-              define_method(method_name) do |request, opts = {}|
-                server_streamer(@rpcs.fetch(method_name), request, opts)
+              define_method(method_name) do |request, **opts|
+                server_streamer(@rpcs.fetch(method_name), request, **opts)
               end
             elsif rpc_desc.bidi_streamer?
-              define_method(method_name) do |requests, opts = {}, &blk|
-                bidi_streamer(@rpcs.fetch(method_name), requests, opts, &blk)
+              define_method(method_name) do |requests, **opts, &blk|
+                bidi_streamer(@rpcs.fetch(method_name), requests, **opts, &blk)
               end
             else
               raise "unknown #{rpc_desc}"

data/lib/grpc_kit/method_config.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 module GrpcKit
+  MAX_SERVER_RECEIVE_MESSAGE_SIZE = 1024 * 1024 * 4
+  MAX_SERVER_SEND_MESSAGE_SIZE = 1024 * 1024 * 4
+  MAX_CLIENT_RECEIVE_MESSAGE_SIZE = 1024 * 1024 * 4
+  MAX_CLIENT_SEND_MESSAGE_SIZE = 1024 * 1024 * 4
+
   MethodConfig = Struct.new(
     :path,
     :ruby_style_method_name,
@@ -12,11 +17,6 @@ module GrpcKit
     :max_send_message_size,
     :compressor_type,
   ) do
-    MAX_SERVER_RECEIVE_MESSAGE_SIZE = 1024 * 1024 * 4
-    MAX_SERVER_SEND_MESSAGE_SIZE = 1024 * 1024 * 4
-    MAX_CLIENT_RECEIVE_MESSAGE_SIZE = 1024 * 1024 * 4
-    MAX_CLIENT_SEND_MESSAGE_SIZE = 1024 * 1024 * 4
-
     def self.build_for_server(
           path:, ruby_style_method_name:, codec:, service_name:, method_name:, interceptor:,
           max_receive_message_size: MAX_SERVER_RECEIVE_MESSAGE_SIZE, max_send_message_size: MAX_SERVER_SEND_MESSAGE_SIZE, compressor_type: ''

data/lib/grpc_kit/rpc_desc.rb

@@ -38,10 +38,21 @@ module GrpcKit
       @service_name = service_name
     end
 
+    # @return [String]
+    attr_reader :name, :service_name
+
+    # @return [Class, GrpcKit::Grpc::Stream]
+    attr_reader :marshal, :unmarshal
+
+    # @return [Symbol]
+    attr_reader :marshal_method, :unmarshal_method
+
     # @param handler [GrpcKit::Grpc::GenericService]
     # @param interceptors [Array<GrpcKit::Grpc::ServerInterceptor>]
+    # @param max_receive_message_size [Integer, nil]
+    # @param max_send_message_size [Integer, nil]
     # @return [#invoke] Server version of rpc class
-    def build_server(handler, interceptors: [])
+    def build_server(handler, interceptors: [], max_send_message_size: nil, max_receive_message_size: nil)
       inter = interceptors.empty? ? nil : server_interceptor.new(interceptors)
 
       config = GrpcKit::MethodConfig.build_for_server(
@@ -51,13 +62,17 @@ module GrpcKit
         service_name: @service_name,
         method_name: @name,
         interceptor: inter,
+        max_receive_message_size: max_receive_message_size || GrpcKit::MAX_SERVER_RECEIVE_MESSAGE_SIZE,
+        max_send_message_size: max_send_message_size || GrpcKit::MAX_SERVER_SEND_MESSAGE_SIZE,
       )
       server.new(handler, config)
     end
 
     # @param interceptors [Array<GrpcKit::Grpc::ClientInterceptor>]
+    # @param max_receive_message_size [Integer, nil]
+    # @param max_send_message_size [Integer, nil]
     # @return [#invoke] Client version of rpc class
-    def build_client(interceptors: [])
+    def build_client(interceptors: [], max_send_message_size: nil, max_receive_message_size: nil)
       inter = interceptors.empty? ? nil : client_interceptor.new(interceptors)
 
       config = GrpcKit::MethodConfig.build_for_client(
@@ -67,6 +82,8 @@ module GrpcKit
         service_name: @service_name,
         method_name: @name,
         interceptor: inter,
+        max_receive_message_size: max_receive_message_size || GrpcKit::MAX_CLIENT_RECEIVE_MESSAGE_SIZE,
+        max_send_message_size: max_send_message_size || GrpcKit::MAX_CLIENT_SEND_MESSAGE_SIZE,
       )
       client.new(config)
     end

data/lib/grpc_kit/rpcs.rb

@@ -19,6 +19,9 @@ module GrpcKit
     end
 
     class ServerRpc
+      # @return [GrpcKit::MethodConfig]
+      attr_reader :config
+
       # @param handler [GrpcKit::Grpc::GenericService]
       # @param config [GrpcKit::MethodConfig]
       def initialize(handler, config)

data/lib/grpc_kit/server.rb

@@ -10,15 +10,20 @@ module GrpcKit
     # @param shutdown_timeout [Integer] Number of seconds to wait for the server shutdown
     # @param min_pool_size [Integer] A mininum thread pool size
     # @param max_pool_size [Integer] A maximum thread pool size
-    def initialize(interceptors: [], shutdown_timeout: 30, min_pool_size: nil, max_pool_size: nil)
+    # @param max_receive_message_size [Integer, nil] Specify the maximum size of inbound message in bytes. Default to 4MB.
+    # @param max_send_message_size [Integer, nil] Specify the maximum size of outbound message in bytes. Default to 4MB.
+    def initialize(interceptors: [], shutdown_timeout: 30, min_pool_size: nil, max_pool_size: nil, settings: [], max_receive_message_size: nil, max_send_message_size: nil)
       @interceptors = interceptors
       @shutdown_timeout = shutdown_timeout
       @min_pool_size = min_pool_size || GrpcKit::RpcDispatcher::DEFAULT_MIN
       @max_pool_size = max_pool_size || GrpcKit::RpcDispatcher::DEFAULT_MAX
+      @max_receive_message_size = max_receive_message_size
+      @max_send_message_size = max_send_message_size
       @sessions = []
       @rpc_descs = {}
       @mutex = Mutex.new
       @stopping = false
+      @settings = settings
 
       GrpcKit.logger.debug("Launched grpc_kit(v#{GrpcKit::VERSION})")
     end
@@ -36,8 +41,12 @@ module GrpcKit
           raise "Duplicated method registered #{path}, class: #{klass}"
         end
 
-        s = handler.is_a?(Class) ? handler.new : handler
-        @rpc_descs[path] = rpc_desc.build_server(s, interceptors: @interceptors)
+        @rpc_descs[path] = rpc_desc.build_server(
+          handler.is_a?(Class) ? handler.new : handler,
+          interceptors: @interceptors,
+          max_receive_message_size: @max_receive_message_size,
+          max_send_message_size: @max_send_message_size,
+        )
       end
     end
 
@@ -47,7 +56,7 @@ module GrpcKit
       raise 'Stopping server' if @stopping
 
       establish_session(conn) do |s|
-        s.submit_settings([])
+        s.submit_settings(@settings)
         s.start
       end
     end

data/lib/grpc_kit/session/client_session.rb

@@ -18,7 +18,7 @@ module GrpcKit
 
       # @param io [GrpcKit::Session::IO]
       # @param opts [Hash]
-      def initialize(io, opts = {})
+      def initialize(io, **opts)
         super() # initialize DS9::Session
 
         @io = io
@@ -27,6 +27,7 @@ module GrpcKit
         @draining = false
         @stop = false
         @no_write_data = false
+        @mutex = Mutex.new
       end
 
       # @param headers [Hash<String,String>]
@@ -47,7 +48,8 @@ module GrpcKit
       # @param stream_id [Integer]
       # @return [void]
       def start(stream_id)
-        stream = @streams.fetch(stream_id)
+        stream = @streams[stream_id]
+        return unless stream # stream might have already close
 
         loop do
           if (!want_read? && !want_write?) || stream.close?
@@ -63,26 +65,28 @@ module GrpcKit
 
       # @return [void]
       def run_once
-        return if @stop
-
-        if @draining && @drain_time < Time.now
-          raise 'trasport is closing'
-        end
-
-        if @no_write_data
-          @io.wait_readable
+        @mutex.synchronize do
+          return if @stop
 
-          if want_read?
-            do_read
-          end
-        else
-          rs, ws = @io.select
-          if !rs.empty? && want_read?
-            do_read
+          if @draining && @drain_time < Time.now
+            raise 'trasport is closing'
           end
 
-          if !ws.empty? && want_write?
-            send
+          if @no_write_data && !@streams.empty?
+            @io.wait_readable
+
+            if want_read?
+              do_read
+            end
+          else
+            rs, ws = @io.select
+            if !rs.empty? && want_read?
+              do_read
+            end
+
+            if !ws.empty? && want_write?
+              send
+            end
           end
         end
       end
@@ -155,8 +159,10 @@ module GrpcKit
       def on_stream_close(stream_id, error_code)
         GrpcKit.logger.debug("on_stream_close stream_id=#{stream_id}, error_code=#{error_code}")
         stream = @streams.delete(stream_id)
-        return unless stream
-
+        unless stream
+          GrpcKit.logger.warn("on_stream_close stream_id=#{stream_id} not remain on ClientSession")
+          return
+        end
         stream.close
       end
 

data/lib/grpc_kit/session/control_queue.rb

@@ -3,8 +3,9 @@
 module GrpcKit
   module Session
     class ControlQueue
-      def initialize
+      def initialize(waker: proc { })
         @event_stream = Queue.new
+        @waker = waker
       end
 
       # Be nonblocking
@@ -20,14 +21,17 @@ module GrpcKit
 
       def submit_response(id, headers)
         @event_stream.push([:submit_response, id, headers])
+        @waker.call(:submit_response)
       end
 
       def submit_headers(id, headers)
         @event_stream.push([:submit_headers, id, headers])
+        @waker.call(:submit_headers)
       end
 
       def resume_data(id)
         @event_stream.push([:resume_data, id])
+        @waker.call(:submit_response)
       end
     end
   end

data/lib/grpc_kit/session/drain_controller.rb

@@ -53,7 +53,7 @@ module GrpcKit
             return
           end
 
-          session.submit_goaway(DS9::NO_ERROR, session.last_proc_stream_id)
+          session.submit_goaway(session.last_proc_stream_id, DS9::NO_ERROR)
           next_step
         when Status::SENT_GOAWAY
           # session.shutdown

data/lib/grpc_kit/session/io.rb

@@ -7,9 +7,12 @@ module GrpcKit
     class IO
       def initialize(io)
         @io = io
+        @wake_o, @wake_i = ::IO.pipe
       end
 
       def close
+        @wake_i.close
+        @wake_o.close
         @io.close
       end
 
@@ -52,8 +55,19 @@ module GrpcKit
 
       # Blocking until io object is readable or writable
       # @return [void]
-      def select(timeout = 1)
-        ::IO.select([@io], [@io], [], timeout)
+      def select(timeout: 1, write: true)
+        rs, ws = ::IO.select([@io, @wake_o], write ? [@io] : [], [], timeout)
+        @wake_o.read(@wake_o.stat.size) if rs&.delete(@wake_o) && !@wake_o.closed?
+        [rs || [], ws || []]
+      end
+
+      # Wake thread blocked at #select method
+      # @param [Symbol] Indicate what event needed to invoke blocking thread. This argument is for debugging purpose.
+      def wake!(memo = nil)
+        @wake_i.write_nonblock(?\0, exception: false)
+      rescue Errno::EPIPE
+      rescue IOError
+        raise unless @wake_i.closed?
       end
 
       # @return [void]

data/lib/grpc_kit/session/recv_buffer.rb

@@ -3,35 +3,69 @@
 module GrpcKit
   module Session
     class RecvBuffer
+      class Closed < Exception; end
+
       def initialize
         @buffer = +''.b
         @end = false
-        @mutex = Mutex.new
+        @queue = Queue.new
       end
 
       # @param data [String]
       # @return [void]
       def write(data)
-        @mutex.synchronize { @buffer << data }
+        @queue << data
+      rescue ClosedQueueError
+        raise Closed, "[BUG] write to closed queue"
+      end
+
+      # @return [Boolean]
+      def empty?
+        @queue.empty?
+      end
+
+      # @return [Boolean]
+      def closed?
+        @queue.closed?
       end
 
+      # @return [void]
+      def close
+        @queue.close
+      end
+
+      # This method is not thread safe (as RecvBuffer is designed to be a multi-producer/single-consumer)
       # @param size [Integer,nil]
       # @param last [Boolean]
-      # @return [String,nil]
-      def read(size = nil, last: false)
-        buf = @mutex.synchronize do
-          return nil if @buffer.empty?
-
-          if size.nil? || @buffer.bytesize < size
-            buf = @buffer
-            @buffer = ''.b
-            buf
-          else
-            @buffer.freeze
-            rbuf = @buffer.byteslice(0, size)
-            @buffer = @buffer.byteslice(size, @buffer.bytesize)
-            rbuf
-          end
+      # @param blocking [Boolean]
+      # @return [String,Symbol,nil]
+      def read(size = nil, last: false, blocking:)
+        if @buffer.empty?
+          return nil if empty? && closed?
+          return :wait_readable if empty? && !blocking
+
+          # Consume existing data as much as possible to continue (important on clients where single-threaded)
+          loop do
+            begin
+              data = @queue.shift(!blocking)
+              @buffer << data if data
+            rescue ThreadError
+              break
+            end
+
+            break if empty?
+          end 
+        end
+
+        buf = if size.nil? || @buffer.bytesize < size
+          rbuf = @buffer
+          @buffer = ''.b
+          rbuf
+        else
+          @buffer.freeze
+          rbuf = @buffer.byteslice(0, size)
+          @buffer = @buffer.byteslice(size, @buffer.bytesize)
+          rbuf
         end
 
         end_read if last

data/lib/grpc_kit/session/send_buffer.rb

@@ -65,6 +65,10 @@ module GrpcKit
         DS9::ERR_DEFERRED
       end
 
+      def eof?
+        end_write? && @mutex.synchronize { @buffer.empty? }
+      end
+
       private
 
       def do_read(size = nil)

data/lib/grpc_kit/session/server_session.rb

@@ -29,7 +29,7 @@ module GrpcKit
         @stop = false
         @inflights = []
         @drain_controller = GrpcKit::Session::DrainController.new
-        @control_queue = GrpcKit::Session::ControlQueue.new
+        @control_queue = GrpcKit::Session::ControlQueue.new(waker: @io.method(:wake!))
         @dispatcher = dispatcher
       end
 
@@ -64,7 +64,7 @@ module GrpcKit
           @drain_controller.next(self)
         end
 
-        rs, ws = @io.select
+        rs, ws = @io.select(timeout: 5, write: want_write?)
 
         if !rs.empty? && want_read?
           do_read
@@ -148,6 +148,8 @@ module GrpcKit
         data = @streams[stream_id].pending_send_data.read(length)
         if data.nil?
           submit_trailer(stream_id, stream.trailer_data)
+          @io.wake!(:submit_trailer)
+
           # trailer header
           false
         else
@@ -180,6 +182,7 @@ module GrpcKit
             stream.inflight = true
             @dispatcher.schedule([stream, @control_queue])
           end
+
         when DS9::Frames::Headers
           if frame.end_stream?
             stream = @streams[frame.stream_id]

data/lib/grpc_kit/session/stream.rb

@@ -13,7 +13,6 @@ module GrpcKit
 
       delegate %i[end_write?] => :@pending_send_data
       delegate %i[end_read?] => :@pending_recv_data
-      delegate %i[close close_remote close_local close? close_remote? close_local?] => :@status
 
       attr_reader :headers, :pending_send_data, :pending_recv_data, :trailer_data, :status
       attr_accessor :inflight, :stream_id
@@ -59,9 +58,10 @@ module GrpcKit
       end
 
       # @param last [Boolean]
+      # @param blocking [Boolean]
       # @return [void]
-      def read_recv_data(last: false)
-        @pending_recv_data.read(last: last)
+      def read_recv_data(last: false, blocking:)
+        @pending_recv_data.read(last: last, blocking: blocking)
       end
 
       # @param name [String]
@@ -70,6 +70,18 @@ module GrpcKit
       def add_header(name, value)
         @headers.add(name, value)
       end
+
+      delegate %i[close_local close? close_remote? close_local?] => :@status
+
+      def close
+        status.close
+        pending_recv_data.close
+      end
+
+      def close_remote
+        status.close_remote
+        pending_recv_data.close
+      end
     end
   end
 end

data/lib/grpc_kit/stream/client_stream.rb

@@ -47,6 +47,7 @@ module GrpcKit
         end
       end
 
+      # This method is not thread safe, never call from multiple threads at once.
       # @raise [StopIteration] when recving message finished
       # @param last [Boolean]
       # @param blocking [Boolean]

data/lib/grpc_kit/stream/server_stream.rb

@@ -15,10 +15,10 @@ module GrpcKit
       def invoke(rpc)
         rpc.invoke(self, metadata: @transport.recv_headers.metadata)
       rescue GrpcKit::Errors::BadStatus => e
-        GrpcKit.logger.debug(e)
+        GrpcKit.logger.warn(e)
         send_status(status: e.code, msg: e.reason, metadata: {}) # TODO: metadata should be set
       rescue StandardError => e
-        GrpcKit.logger.debug(e)
+        GrpcKit.logger.warn(e)
         send_status(status: GrpcKit::StatusCodes::UNKNOWN, msg: e.message, metadata: {})
       end
 
@@ -50,6 +50,7 @@ module GrpcKit
         end
       end
 
+      # This method is not thread safe, never call from multiple threads at once.
       # @raise [StopIteration] when recving message finished
       # @param codec [GrpcKit::Codec]
       # @param last [Boolean]
@@ -89,13 +90,18 @@ module GrpcKit
         t = build_trailers(status, msg, metadata)
         @transport.write_data(data, last: true) if data
 
-        @transport.end_write
-        if @started
+        if @started # Complete stream
           @transport.write_trailers(t)
-        elsif data
+          @transport.end_write
+
+        elsif data # Complete stream with a data
           @transport.write_trailers(t)
-          start_response
-        else
+          @transport.end_write
+
+          start_response # will send queued data and trailer.
+
+        else # return status (likely non-200) and immediately complete stream.
+          @transport.end_write
           send_headers(trailers: t)
         end
       end

data/lib/grpc_kit/transport/client_transport.rb

@@ -41,20 +41,31 @@ module GrpcKit
       end
 
       # @param last [Boolean]
-      # @return [nil,String]
+      # @return [nil,Array<Boolean,Integer,String>] nil when closed, tuple of Length-Prefixed-Message
       def read_data(last: false)
-        unpack(recv_data(last: last))
+        data_in_buffer = unpack(nil)
+        return data_in_buffer if data_in_buffer
+        loop do
+          data = recv_data(last: last)
+          return unpack(nil) unless data
+          message = unpack(data)
+          return message if message
+        end
       end
 
       # @param last [Boolean]
-      # @return [nil,String]
+      # @return [nil,Array<Boolean,Integer,String>,Symbol] nil when closed, tuple of Length-Prefixed-Message, or :wait_readable
       def read_data_nonblock(last: false)
+        data_in_buffer = unpack(nil) 
+        return data_in_buffer if data_in_buffer
+
         data = nonblock_recv_data(last: last)
         if data == :wait_readable
-          unpack(nil) # nil is needed read buffered data
           :wait_readable
+        elsif data == nil
+          return unpack(nil)
         else
-          unpack(data)
+          unpack(data) || :wait_readable
         end
       end
 
@@ -78,33 +89,26 @@ module GrpcKit
       end
 
       def nonblock_recv_data(last: false)
-        data = @stream.read_recv_data(last: last)
-        return data unless data.nil?
-
-        if @stream.close_remote?
-          return nil
-        end
-
-        @session.run_once
+        data = @stream.read_recv_data(last: last, blocking: false)
+        return data if data.is_a?(String)
+        return nil unless data
 
         :wait_readable
       end
 
       def recv_data(last: false)
         loop do
-          data = @stream.read_recv_data(last: last)
-          return data unless data.nil?
-
-          if @stream.close_remote?
-            # it do not receive data which we need, it may receive invalid grpc-status
-            unless @stream.end_read?
-              return nil
-            end
-
+          # FIXME: GrpcKit::Client isn't threaded, this cannot be blocked to trigger ClientSession#run_once appropriately
+          #        but run_once would block while no outbound requests. Could be problematic on BiDi calls.
+          data = @stream.read_recv_data(last: last, blocking: false)
+          case data
+          when :wait_readable
+            @session.run_once
+          when String
+            return data
+          when nil
             return nil
           end
-
-          @session.run_once
         end
       end
 

data/lib/grpc_kit/transport/packable.rb

@@ -24,8 +24,8 @@ module GrpcKit
       end
 
       class Unpacker
-        # Compressed bytes(1 Byte) + length bytes(4 Bytes)
-        METADATA_SIZE = 5
+        # Compressed-Flag (1 byte) + Message-Length (4 Bytes)
+        PREFIX_SIZE = 5
 
         def initialize
           @data = +''.b
@@ -44,14 +44,17 @@ module GrpcKit
 
         # @return [nil, Array<Boolean, Integer, String>]
         def read
-          return nil if @data.empty?
+          return nil if @data.bytesize < PREFIX_SIZE
+
+          prefix = @data.byteslice(0, PREFIX_SIZE)
+          compressed, length = prefix.unpack('CN')
+
+          return nil if (@data.bytesize-PREFIX_SIZE) < length
 
           d = @data.freeze
-          metadata = d.byteslice(0, METADATA_SIZE)
-          c, size = metadata.unpack('CN')
-          data = @data.byteslice(METADATA_SIZE, size)
-          @data = @data.byteslice(METADATA_SIZE + size, @data.bytesize)
-          [c != 0, size, data]
+          data = d.byteslice(PREFIX_SIZE, length)
+          @data = d.byteslice(PREFIX_SIZE + length, d.bytesize)
+          [compressed == 1, length, data]
         end
       end
     end

data/lib/grpc_kit/transport/server_transport.rb

@@ -36,9 +36,16 @@ module GrpcKit
       end
 
       # @param last [Boolean]
-      # @return [nil,String]
+      # @return [nil,Array<Boolean,Integer,String>] nil when closed, tuple of Length-Prefixed-Message
       def read_data(last: false)
-        unpack(recv_data(last: last))
+        data_in_buffer = unpack(nil)
+        return data_in_buffer if data_in_buffer
+        loop do
+          data = recv_data(last: last)
+          return nil unless data
+          message = unpack(data)
+          return message if message
+        end
       end
 
       # @param trailer [Hash<String, String>]
@@ -61,17 +68,7 @@ module GrpcKit
       private
 
       def recv_data(last: false)
-        loop do
-          data = @stream.read_recv_data(last: last)
-          return data if data
-
-          if @stream.close_remote?
-            # Call @stream.read_recv_data after checking @stream.close_remote?
-            # because of the order of nghttp2 callbacks which calls a callback receiving data before a callback receiving END_STREAM flag
-            data = @stream.read_recv_data(last: last)
-            return data
-          end
-        end
+        @stream.read_recv_data(last: last, blocking: true)
       end
 
       def send_data

data/lib/grpc_kit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GrpcKit
-  VERSION = '0.3.7'
+  VERSION = '0.5.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grpc_kit
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.5.1
 platform: ruby
 authors:
 - Yuta Iwama
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-08 00:00:00.000000000 Z
+date: 2021-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ds9
@@ -143,11 +143,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".ruby-version"
-- ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -252,8 +252,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: A kit for creating gRPC server/client

data/.ruby-version

@@ -1 +0,0 @@
-2.5

data/.travis.yml

@@ -1,14 +0,0 @@
-language: ruby
-cache:
- - bundler
-dist: trusty
-rvm:
-  - ruby-head
-  - 2.6.1
-  - 2.5.3
-  - 2.4.5
-before_install:
-  - gem install bundler -v 1.17.0
-matrix:
-  allow_failures:
-    - rvm: ruby-head